From 35bbd6d9d8ffdc5d4602b6eb435ac7f2164fcbb1 Mon Sep 17 00:00:00 2001
From: mizdra <pp.mizdra@gmail.com>
Date: Tue, 3 Oct 2023 00:35:36 +0900
Subject: [PATCH 1/2] merge DefaultFieldsResolver and InputFieldsResolver

---
 README.md                                     |  4 ++--
 e2e/index.e2e.ts                              |  4 ++--
 src/__snapshots__/code-generator.test.ts.snap | 18 +++++++--------
 src/code-generator.ts                         | 10 ++++-----
 src/helper/factory.ts                         | 22 +++++++------------
 src/helper/field-resolver.test.ts             | 19 +++-------------
 src/helper/field-resolver.ts                  | 12 +++++-----
 src/helper/index.ts                           |  2 +-
 8 files changed, 35 insertions(+), 56 deletions(-)

diff --git a/README.md b/README.md
index 6e12d43..48e6cc2 100644
--- a/README.md
+++ b/README.md
@@ -260,7 +260,7 @@ However, you must prepare a custom `define<Type>Factory` to use Transient Fields
 import {
   defineAuthorFactoryInternal,
   dynamic,
-  DefaultFieldsResolver,
+  FieldsResolver,
   Traits,
   AuthorFactoryDefineOptions,
   AuthorFactoryInterface,
@@ -272,7 +272,7 @@ type AuthorTransientFields = {
   bookCount: number;
 };
 function defineAuthorFactoryWithTransientFields<
-  _DefaultFieldsResolver extends DefaultFieldsResolver<Author & AuthorTransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Author & AuthorTransientFields>,
   _Traits extends Traits<Author, AuthorTransientFields>,
 >(
   options: AuthorFactoryDefineOptions<AuthorTransientFields, _DefaultFieldsResolver, _Traits>,
diff --git a/e2e/index.e2e.ts b/e2e/index.e2e.ts
index bfdb2ad..1e0b819 100644
--- a/e2e/index.e2e.ts
+++ b/e2e/index.e2e.ts
@@ -2,7 +2,7 @@ import { expect, it, describe, assertType, expectTypeOf, vi } from 'vitest';
 import {
   AuthorFactoryDefineOptions,
   AuthorFactoryInterface,
-  DefaultFieldsResolver,
+  FieldsResolver,
   Traits,
   defineAuthorFactory,
   defineAuthorFactoryInternal,
@@ -516,7 +516,7 @@ describe('defineTypeFactory', () => {
         bookCount: number;
       };
       function defineAuthorFactoryWithTransientFields<
-        _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalAuthor & AuthorTransientFields>,
+        _DefaultFieldsResolver extends FieldsResolver<OptionalAuthor & AuthorTransientFields>,
         _Traits extends Traits<OptionalAuthor, AuthorTransientFields>,
       >(
         options: AuthorFactoryDefineOptions<AuthorTransientFields, _DefaultFieldsResolver, _Traits>,
diff --git a/src/__snapshots__/code-generator.test.ts.snap b/src/__snapshots__/code-generator.test.ts.snap
index 2b20dbb..a826e5d 100644
--- a/src/__snapshots__/code-generator.test.ts.snap
+++ b/src/__snapshots__/code-generator.test.ts.snap
@@ -5,7 +5,7 @@ exports[`generateCode > generates code 1`] = `
   type Traits,
   type TypeFactoryDefineOptions,
   type TypeFactoryInterface,
-  type DefaultFieldsResolver,
+  type FieldsResolver,
   defineTypeFactoryInternal,
 } from '@mizdra/graphql-codegen-typescript-fabbrica/helper';
 import type { Maybe, Book, Author } from './types';
@@ -21,19 +21,19 @@ const BookFieldNames = ['id', 'title', 'author'] as const;
 
 export type BookFactoryDefineOptions<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalBook & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalBook & TransientFields>,
   _Traits extends Traits<OptionalBook, TransientFields>,
 > = TypeFactoryDefineOptions<OptionalBook, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export type BookFactoryInterface<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalBook & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalBook & TransientFields>,
   _Traits extends Traits<OptionalBook, TransientFields>,
 > = TypeFactoryInterface<OptionalBook, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export function defineBookFactoryInternal<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalBook & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalBook & TransientFields>,
   _Traits extends Traits<OptionalBook, TransientFields>,
 >(
   options: BookFactoryDefineOptions<TransientFields, _DefaultFieldsResolver, _Traits>,
@@ -48,7 +48,7 @@ export function defineBookFactoryInternal<
  * @returns factory {@link BookFactoryInterface}
  */
 export function defineBookFactory<
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalBook>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalBook>,
   _Traits extends Traits<OptionalBook, {}>,
 >(
   options: BookFactoryDefineOptions<{}, _DefaultFieldsResolver, _Traits>,
@@ -66,19 +66,19 @@ const AuthorFieldNames = ['id', 'name', 'books'] as const;
 
 export type AuthorFactoryDefineOptions<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalAuthor & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalAuthor & TransientFields>,
   _Traits extends Traits<OptionalAuthor, TransientFields>,
 > = TypeFactoryDefineOptions<OptionalAuthor, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export type AuthorFactoryInterface<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalAuthor & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalAuthor & TransientFields>,
   _Traits extends Traits<OptionalAuthor, TransientFields>,
 > = TypeFactoryInterface<OptionalAuthor, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export function defineAuthorFactoryInternal<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalAuthor & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalAuthor & TransientFields>,
   _Traits extends Traits<OptionalAuthor, TransientFields>,
 >(
   options: AuthorFactoryDefineOptions<TransientFields, _DefaultFieldsResolver, _Traits>,
@@ -93,7 +93,7 @@ export function defineAuthorFactoryInternal<
  * @returns factory {@link AuthorFactoryInterface}
  */
 export function defineAuthorFactory<
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalAuthor>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalAuthor>,
   _Traits extends Traits<OptionalAuthor, {}>,
 >(
   options: AuthorFactoryDefineOptions<{}, _DefaultFieldsResolver, _Traits>,
diff --git a/src/code-generator.ts b/src/code-generator.ts
index f8b8492..e2d496c 100644
--- a/src/code-generator.ts
+++ b/src/code-generator.ts
@@ -8,7 +8,7 @@ import {
   type Traits,
   type TypeFactoryDefineOptions,
   type TypeFactoryInterface,
-  type DefaultFieldsResolver,
+  type FieldsResolver,
   defineTypeFactoryInternal,
 } from '@mizdra/graphql-codegen-typescript-fabbrica/helper';
 import type { Maybe, ${joinedTypeNames} } from '${config.typesFile}';
@@ -48,19 +48,19 @@ function generateTypeFactoryCode(config: Config, typeInfo: TypeInfo): string {
   return `
 export type ${name}FactoryDefineOptions<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<Optional${name} & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Optional${name} & TransientFields>,
   _Traits extends Traits<Optional${name}, TransientFields>,
 > = TypeFactoryDefineOptions<Optional${name}, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export type ${name}FactoryInterface<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<Optional${name} & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Optional${name} & TransientFields>,
   _Traits extends Traits<Optional${name}, TransientFields>,
 > = TypeFactoryInterface<Optional${name}, TransientFields, _DefaultFieldsResolver, _Traits>;
 
 export function define${name}FactoryInternal<
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends ${wrapRequired(`DefaultFieldsResolver<Optional${name} & TransientFields>`)},
+  _DefaultFieldsResolver extends ${wrapRequired(`FieldsResolver<Optional${name} & TransientFields>`)},
   _Traits extends Traits<Optional${name}, TransientFields>,
 >(
   options: ${name}FactoryDefineOptions<TransientFields, _DefaultFieldsResolver, _Traits>,
@@ -75,7 +75,7 @@ export function define${name}FactoryInternal<
  * @returns factory {@link ${name}FactoryInterface}
  */
 export function define${name}Factory<
-  _DefaultFieldsResolver extends ${wrapRequired(`DefaultFieldsResolver<Optional${name}>`)},
+  _DefaultFieldsResolver extends ${wrapRequired(`FieldsResolver<Optional${name}>`)},
   _Traits extends Traits<Optional${name}, {}>,
 >(
   options: ${name}FactoryDefineOptions<{}, _DefaultFieldsResolver, _Traits>,
diff --git a/src/helper/factory.ts b/src/helper/factory.ts
index 5a450bf..d08c2ab 100644
--- a/src/helper/factory.ts
+++ b/src/helper/factory.ts
@@ -1,25 +1,19 @@
 // MEMO: The tests for this module are covered by `e2e/*.e2e.ts`.
 
-import {
-  ResolvedFields,
-  DefaultFieldsResolver,
-  InputFieldsResolver,
-  resolveFields,
-  FieldResolver,
-} from './field-resolver.js';
+import { ResolvedFields, FieldsResolver, resolveFields, FieldResolver } from './field-resolver.js';
 import { getSequenceCounter, resetSequence } from './sequence.js';
 import { Merge, StrictlyPick } from './util.js';
 
 export type Traits<OptionalType extends Record<string, unknown>, TransientFields extends Record<string, unknown>> = {
   [traitName: string]: {
-    defaultFields: InputFieldsResolver<OptionalType & TransientFields>;
+    defaultFields: FieldsResolver<OptionalType & TransientFields>;
   };
 };
 
 export interface TypeFactoryDefineOptions<
   OptionalType extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalType & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
   _Traits extends Traits<OptionalType, TransientFields>,
 > {
   defaultFields: _DefaultFieldsResolver;
@@ -36,13 +30,13 @@ export interface TypeFactoryInterface<
   _Traits extends Traits<OptionalType, TransientFields>,
 > {
   build(): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof OptionalType>>;
-  build<T extends InputFieldsResolver<OptionalType & TransientFields>>(
+  build<T extends FieldsResolver<OptionalType & TransientFields>>(
     inputFieldsResolver: T,
   ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>>;
   buildList(
     count: number,
   ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof OptionalType>[]>;
-  buildList<T extends InputFieldsResolver<OptionalType & TransientFields>>(
+  buildList<T extends FieldsResolver<OptionalType & TransientFields>>(
     count: number,
     inputFieldsResolver: T,
   ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>[]>;
@@ -60,7 +54,7 @@ export interface TypeFactoryInterface<
 export function defineTypeFactoryInternal<
   OptionalType extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalType & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
   _Traits extends Traits<OptionalType, TransientFields>,
 >(
   typeFieldNames: readonly (keyof OptionalType)[],
@@ -72,7 +66,7 @@ export function defineTypeFactoryInternal<
   const seqKey = {};
   const getSeq = () => getSequenceCounter(seqKey);
   return {
-    async build<T extends InputFieldsResolver<OptionalType & TransientFields>>(
+    async build<T extends FieldsResolver<OptionalType & TransientFields>>(
       inputFieldsResolver?: T,
     ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>> {
       const seq = getSeq();
@@ -83,7 +77,7 @@ export function defineTypeFactoryInternal<
         inputFieldsResolver ?? ({} as T),
       );
     },
-    async buildList<T extends InputFieldsResolver<OptionalType & TransientFields>>(
+    async buildList<T extends FieldsResolver<OptionalType & TransientFields>>(
       count: number,
       inputFieldsResolver?: T,
     ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>[]> {
diff --git a/src/helper/field-resolver.test.ts b/src/helper/field-resolver.test.ts
index c70296f..5aa3c8a 100644
--- a/src/helper/field-resolver.test.ts
+++ b/src/helper/field-resolver.test.ts
@@ -5,8 +5,7 @@ import {
   type ResolvedField,
   Dynamic,
   dynamic,
-  InputFieldsResolver,
-  DefaultFieldsResolver,
+  FieldsResolver,
 } from './field-resolver.js';
 import { DeepOptional, DeepReadonly } from './util.js';
 
@@ -53,22 +52,10 @@ it('FieldResolver', () => {
   >();
 });
 
-it('DefaultFieldsResolver', () => {
+it('FieldsResolver', () => {
   type OptionalTypeWithTransientFields = { a: number | undefined; b: OptionalSubType[] | undefined };
   type OptionalSubType = { c: number | undefined };
-  expectTypeOf<DefaultFieldsResolver<OptionalTypeWithTransientFields>>().toEqualTypeOf<{
-    a?: number | undefined | Dynamic<OptionalTypeWithTransientFields, number | undefined>;
-    b?:
-      | readonly { readonly c: number | undefined }[]
-      | undefined
-      | Dynamic<OptionalTypeWithTransientFields, readonly { readonly c: number | undefined }[] | undefined>;
-  }>();
-});
-
-it('InputFieldsResolver', () => {
-  type OptionalTypeWithTransientFields = { a: number | undefined; b: OptionalSubType[] | undefined };
-  type OptionalSubType = { c: number | undefined };
-  expectTypeOf<InputFieldsResolver<OptionalTypeWithTransientFields>>().toEqualTypeOf<{
+  expectTypeOf<FieldsResolver<OptionalTypeWithTransientFields>>().toEqualTypeOf<{
     a?: number | undefined | Dynamic<OptionalTypeWithTransientFields, number | undefined>;
     b?:
       | readonly { readonly c: number | undefined }[]
diff --git a/src/helper/field-resolver.ts b/src/helper/field-resolver.ts
index 76affbd..d0446df 100644
--- a/src/helper/field-resolver.ts
+++ b/src/helper/field-resolver.ts
@@ -27,16 +27,14 @@ export function dynamic<OptionalTypeWithTransientFields, Field>(
 export type FieldResolver<OptionalTypeWithTransientFields, Field> =
   | Field
   | Dynamic<OptionalTypeWithTransientFields, Field>;
-/** The type of `defaultFields` option of `defineFactory` function. */
-export type DefaultFieldsResolver<OptionalTypeWithTransientFields> = {
+
+/** The type of `defaultFields` or `inputFields` option. */
+export type FieldsResolver<OptionalTypeWithTransientFields> = {
   [FieldName in keyof OptionalTypeWithTransientFields]?: FieldResolver<
     OptionalTypeWithTransientFields,
     DeepReadonly<OptionalTypeWithTransientFields[FieldName]>
   >;
 };
-/** The type of `inputFields` option of `build` method. */
-export type InputFieldsResolver<OptionalTypeWithTransientFields> =
-  DefaultFieldsResolver<OptionalTypeWithTransientFields>;
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export type ResolvedField<T extends FieldResolver<unknown, unknown>> = T extends FieldResolver<infer _, infer R>
@@ -50,8 +48,8 @@ export type ResolvedFields<FieldsResolver extends Record<string, FieldResolver<u
 export async function resolveFields<
   OptionalType extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends DefaultFieldsResolver<OptionalType & TransientFields>,
-  _InputFieldsResolver extends InputFieldsResolver<OptionalType & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
+  _InputFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
 >(
   fieldNames: readonly (keyof OptionalType)[],
   seq: number,
diff --git a/src/helper/index.ts b/src/helper/index.ts
index bb6f8c1..fe97123 100644
--- a/src/helper/index.ts
+++ b/src/helper/index.ts
@@ -1,3 +1,3 @@
-export { DefaultFieldsResolver, dynamic } from './field-resolver.js';
+export { FieldsResolver, dynamic } from './field-resolver.js';
 export { resetAllSequence, resetSequence } from './sequence.js';
 export { Traits, TypeFactoryDefineOptions, TypeFactoryInterface, defineTypeFactoryInternal } from './factory.js';

From 077a10bf0df0c8a04c78d2009085dd403ae4612f Mon Sep 17 00:00:00 2001
From: mizdra <pp.mizdra@gmail.com>
Date: Tue, 3 Oct 2023 00:38:29 +0900
Subject: [PATCH 2/2] OptionalType => Type

---
 src/helper/factory.ts             | 66 +++++++++++++------------------
 src/helper/field-resolver.test.ts | 50 +++++++++++------------
 src/helper/field-resolver.ts      | 56 ++++++++++++--------------
 3 files changed, 79 insertions(+), 93 deletions(-)

diff --git a/src/helper/factory.ts b/src/helper/factory.ts
index d08c2ab..d08750a 100644
--- a/src/helper/factory.ts
+++ b/src/helper/factory.ts
@@ -4,87 +4,77 @@ import { ResolvedFields, FieldsResolver, resolveFields, FieldResolver } from './
 import { getSequenceCounter, resetSequence } from './sequence.js';
 import { Merge, StrictlyPick } from './util.js';
 
-export type Traits<OptionalType extends Record<string, unknown>, TransientFields extends Record<string, unknown>> = {
+export type Traits<Type extends Record<string, unknown>, TransientFields extends Record<string, unknown>> = {
   [traitName: string]: {
-    defaultFields: FieldsResolver<OptionalType & TransientFields>;
+    defaultFields: FieldsResolver<Type & TransientFields>;
   };
 };
 
 export interface TypeFactoryDefineOptions<
-  OptionalType extends Record<string, unknown>,
+  Type extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
-  _Traits extends Traits<OptionalType, TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Type & TransientFields>,
+  _Traits extends Traits<Type, TransientFields>,
 > {
   defaultFields: _DefaultFieldsResolver;
   traits?: _Traits;
 }
 
 export interface TypeFactoryInterface<
-  OptionalType extends Record<string, unknown>,
+  Type extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
   // NOTE: The constraints of _DefaultFieldsResolver are loose so that `Merge<_DefaultFieldsResolver, _Traits[T]['defaultFields']>` is accepted.
-  _DefaultFieldsResolver extends Partial<
-    Record<keyof OptionalType, FieldResolver<OptionalType & TransientFields, unknown>>
-  >,
-  _Traits extends Traits<OptionalType, TransientFields>,
+  _DefaultFieldsResolver extends Partial<Record<keyof Type, FieldResolver<Type & TransientFields, unknown>>>,
+  _Traits extends Traits<Type, TransientFields>,
 > {
-  build(): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof OptionalType>>;
-  build<T extends FieldsResolver<OptionalType & TransientFields>>(
+  build(): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof Type>>;
+  build<T extends FieldsResolver<Type & TransientFields>>(
     inputFieldsResolver: T,
-  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>>;
+  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof Type>>;
   buildList(
     count: number,
-  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof OptionalType>[]>;
-  buildList<T extends FieldsResolver<OptionalType & TransientFields>>(
+  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<{}>>, keyof Type>[]>;
+  buildList<T extends FieldsResolver<Type & TransientFields>>(
     count: number,
     inputFieldsResolver: T,
-  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>[]>;
+  ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof Type>[]>;
   use<T extends keyof _Traits>(
     traitName: T,
-  ): TypeFactoryInterface<
-    OptionalType,
-    TransientFields,
-    Merge<_DefaultFieldsResolver, _Traits[T]['defaultFields']>,
-    _Traits
-  >;
+  ): TypeFactoryInterface<Type, TransientFields, Merge<_DefaultFieldsResolver, _Traits[T]['defaultFields']>, _Traits>;
   resetSequence(): void;
 }
 
 export function defineTypeFactoryInternal<
-  OptionalType extends Record<string, unknown>,
+  Type extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
-  _Traits extends Traits<OptionalType, TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Type & TransientFields>,
+  _Traits extends Traits<Type, TransientFields>,
 >(
-  typeFieldNames: readonly (keyof OptionalType)[],
+  typeFieldNames: readonly (keyof Type)[],
   {
     defaultFields: defaultFieldsResolver,
     traits,
-  }: TypeFactoryDefineOptions<OptionalType, TransientFields, _DefaultFieldsResolver, _Traits>,
-): TypeFactoryInterface<OptionalType, TransientFields, _DefaultFieldsResolver, _Traits> {
+  }: TypeFactoryDefineOptions<Type, TransientFields, _DefaultFieldsResolver, _Traits>,
+): TypeFactoryInterface<Type, TransientFields, _DefaultFieldsResolver, _Traits> {
   const seqKey = {};
   const getSeq = () => getSequenceCounter(seqKey);
   return {
-    async build<T extends FieldsResolver<OptionalType & TransientFields>>(
+    async build<T extends FieldsResolver<Type & TransientFields>>(
       inputFieldsResolver?: T,
-    ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>> {
+    ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof Type>> {
       const seq = getSeq();
-      return resolveFields<OptionalType, TransientFields, _DefaultFieldsResolver, T>(
+      return resolveFields<Type, TransientFields, _DefaultFieldsResolver, T>(
         typeFieldNames,
         seq,
         defaultFieldsResolver,
         inputFieldsResolver ?? ({} as T),
       );
     },
-    async buildList<T extends FieldsResolver<OptionalType & TransientFields>>(
+    async buildList<T extends FieldsResolver<Type & TransientFields>>(
       count: number,
       inputFieldsResolver?: T,
-    ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof OptionalType>[]> {
-      const array: StrictlyPick<
-        Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>,
-        keyof OptionalType
-      >[] = [];
+    ): Promise<StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof Type>[]> {
+      const array: StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<T>>, keyof Type>[] = [];
       for (let i = 0; i < count; i++) {
         if (inputFieldsResolver) {
           // eslint-disable-next-line no-await-in-loop, @typescript-eslint/no-explicit-any
@@ -99,7 +89,7 @@ export function defineTypeFactoryInternal<
     use<T extends keyof _Traits>(
       traitName: T,
     ): TypeFactoryInterface<
-      OptionalType,
+      Type,
       TransientFields,
       Merge<_DefaultFieldsResolver, _Traits[T]['defaultFields']>,
       _Traits
diff --git a/src/helper/field-resolver.test.ts b/src/helper/field-resolver.test.ts
index 5aa3c8a..d545f1b 100644
--- a/src/helper/field-resolver.test.ts
+++ b/src/helper/field-resolver.test.ts
@@ -10,16 +10,16 @@ import {
 import { DeepOptional, DeepReadonly } from './util.js';
 
 it('Dynamic', async () => {
-  type OptionalTypeWithTransientFields = { id: string | undefined; a: number | undefined };
+  type TypeWithTransientFields = { id: string | undefined; a: number | undefined };
   type Field = string;
-  const readonlyOptionalType: DeepReadonly<DeepOptional<OptionalTypeWithTransientFields>> = {
+  const readonlyType: DeepReadonly<DeepOptional<TypeWithTransientFields>> = {
     id: '',
     a: 1,
   };
-  const get = async <FieldName extends keyof OptionalTypeWithTransientFields>(fieldName: FieldName) =>
-    Promise.resolve(readonlyOptionalType[fieldName]);
+  const get = async <FieldName extends keyof TypeWithTransientFields>(fieldName: FieldName) =>
+    Promise.resolve(readonlyType[fieldName]);
 
-  const dynamic1 = new Dynamic<OptionalTypeWithTransientFields, Field>(({ seq }) => `Book-${seq}`);
+  const dynamic1 = new Dynamic<TypeWithTransientFields, Field>(({ seq }) => `Book-${seq}`);
   expect(await dynamic1.get({ seq: 0, get })).toBe('Book-0');
 
   const dynamic2 = new Dynamic(async ({ seq }) => Promise.resolve(`Book-${seq}`));
@@ -27,58 +27,58 @@ it('Dynamic', async () => {
 });
 
 it('dynamic', async () => {
-  type OptionalTypeWithTransientFields = { id: string | undefined; a: number | undefined };
+  type TypeWithTransientFields = { id: string | undefined; a: number | undefined };
   type Field = string;
-  const readonlyOptionalType: DeepReadonly<DeepOptional<OptionalTypeWithTransientFields>> = {
+  const readonlyType: DeepReadonly<DeepOptional<TypeWithTransientFields>> = {
     id: '',
     a: 1,
   };
-  const get = async <FieldName extends keyof OptionalTypeWithTransientFields>(fieldName: FieldName) =>
-    Promise.resolve(readonlyOptionalType[fieldName]);
+  const get = async <FieldName extends keyof TypeWithTransientFields>(fieldName: FieldName) =>
+    Promise.resolve(readonlyType[fieldName]);
 
-  const l1 = dynamic<OptionalTypeWithTransientFields, Field>(({ seq }) => `Book-${seq}`);
+  const l1 = dynamic<TypeWithTransientFields, Field>(({ seq }) => `Book-${seq}`);
   expect(l1).instanceOf(Dynamic);
   expect(await l1.get({ seq: 0, get })).toBe('Book-0');
 
-  const l2 = dynamic<OptionalTypeWithTransientFields, Field>(async ({ seq }) => Promise.resolve(`Book-${seq}`));
+  const l2 = dynamic<TypeWithTransientFields, Field>(async ({ seq }) => Promise.resolve(`Book-${seq}`));
   expect(l2).instanceOf(Dynamic);
   expect(await l2.get({ seq: 0, get })).toBe('Book-0');
 });
 
 it('FieldResolver', () => {
-  type OptionalTypeWithTransientFields = { a: number };
-  expectTypeOf<FieldResolver<OptionalTypeWithTransientFields, OptionalTypeWithTransientFields['a']>>().toEqualTypeOf<
+  type TypeWithTransientFields = { a: number };
+  expectTypeOf<FieldResolver<TypeWithTransientFields, TypeWithTransientFields['a']>>().toEqualTypeOf<
     number | Dynamic<{ a: number }, number>
   >();
 });
 
 it('FieldsResolver', () => {
-  type OptionalTypeWithTransientFields = { a: number | undefined; b: OptionalSubType[] | undefined };
+  type TypeWithTransientFields = { a: number | undefined; b: OptionalSubType[] | undefined };
   type OptionalSubType = { c: number | undefined };
-  expectTypeOf<FieldsResolver<OptionalTypeWithTransientFields>>().toEqualTypeOf<{
-    a?: number | undefined | Dynamic<OptionalTypeWithTransientFields, number | undefined>;
+  expectTypeOf<FieldsResolver<TypeWithTransientFields>>().toEqualTypeOf<{
+    a?: number | undefined | Dynamic<TypeWithTransientFields, number | undefined>;
     b?:
       | readonly { readonly c: number | undefined }[]
       | undefined
-      | Dynamic<OptionalTypeWithTransientFields, readonly { readonly c: number | undefined }[] | undefined>;
+      | Dynamic<TypeWithTransientFields, readonly { readonly c: number | undefined }[] | undefined>;
   }>();
 });
 
 it('ResolvedField', () => {
-  type OptionalTypeWithTransientFields = { a: number | undefined };
+  type TypeWithTransientFields = { a: number | undefined };
   expectTypeOf<ResolvedField<number>>().toEqualTypeOf<number>();
-  expectTypeOf<
-    ResolvedField<Dynamic<OptionalTypeWithTransientFields, OptionalTypeWithTransientFields['a']>>
-  >().toEqualTypeOf<number | undefined>();
+  expectTypeOf<ResolvedField<Dynamic<TypeWithTransientFields, TypeWithTransientFields['a']>>>().toEqualTypeOf<
+    number | undefined
+  >();
 });
 
 it('ResolvedFields', () => {
-  type OptionalTypeWithTransientFields = { a: number | undefined };
+  type TypeWithTransientFields = { a: number | undefined };
   expectTypeOf<
     ResolvedFields<{
-      a: FieldResolver<OptionalTypeWithTransientFields, number>;
-      b: FieldResolver<OptionalTypeWithTransientFields, undefined>;
-      c: FieldResolver<OptionalTypeWithTransientFields, number | undefined>;
+      a: FieldResolver<TypeWithTransientFields, number>;
+      b: FieldResolver<TypeWithTransientFields, undefined>;
+      c: FieldResolver<TypeWithTransientFields, number | undefined>;
     }>
   >().toEqualTypeOf<{
     a: number;
diff --git a/src/helper/field-resolver.ts b/src/helper/field-resolver.ts
index d0446df..8c135d2 100644
--- a/src/helper/field-resolver.ts
+++ b/src/helper/field-resolver.ts
@@ -1,38 +1,34 @@
 import { DeepReadonly, Merge, StrictlyPick } from './util.js';
 
-export type FieldResolverOptions<OptionalTypeWithTransientFields> = {
+export type FieldResolverOptions<TypeWithTransientFields> = {
   seq: number;
-  get: <FieldName extends keyof OptionalTypeWithTransientFields>(
+  get: <FieldName extends keyof TypeWithTransientFields>(
     fieldName: FieldName,
-  ) => Promise<DeepReadonly<OptionalTypeWithTransientFields[FieldName]> | undefined>;
+  ) => Promise<DeepReadonly<TypeWithTransientFields[FieldName]> | undefined>;
 };
 
-export class Dynamic<OptionalTypeWithTransientFields, Field> {
+export class Dynamic<TypeWithTransientFields, Field> {
   constructor(
-    private readonly factory: (
-      options: FieldResolverOptions<OptionalTypeWithTransientFields>,
-    ) => Field | Promise<Field>,
+    private readonly factory: (options: FieldResolverOptions<TypeWithTransientFields>) => Field | Promise<Field>,
   ) {}
-  async get(options: FieldResolverOptions<OptionalTypeWithTransientFields>): Promise<Field> {
+  async get(options: FieldResolverOptions<TypeWithTransientFields>): Promise<Field> {
     return this.factory(options);
   }
 }
 /** Wrapper to delay field generation until needed. */
-export function dynamic<OptionalTypeWithTransientFields, Field>(
-  factory: (options: FieldResolverOptions<OptionalTypeWithTransientFields>) => Field | Promise<Field>,
-): Dynamic<OptionalTypeWithTransientFields, Field> {
+export function dynamic<TypeWithTransientFields, Field>(
+  factory: (options: FieldResolverOptions<TypeWithTransientFields>) => Field | Promise<Field>,
+): Dynamic<TypeWithTransientFields, Field> {
   return new Dynamic(factory);
 }
 
-export type FieldResolver<OptionalTypeWithTransientFields, Field> =
-  | Field
-  | Dynamic<OptionalTypeWithTransientFields, Field>;
+export type FieldResolver<TypeWithTransientFields, Field> = Field | Dynamic<TypeWithTransientFields, Field>;
 
 /** The type of `defaultFields` or `inputFields` option. */
-export type FieldsResolver<OptionalTypeWithTransientFields> = {
-  [FieldName in keyof OptionalTypeWithTransientFields]?: FieldResolver<
-    OptionalTypeWithTransientFields,
-    DeepReadonly<OptionalTypeWithTransientFields[FieldName]>
+export type FieldsResolver<TypeWithTransientFields> = {
+  [FieldName in keyof TypeWithTransientFields]?: FieldResolver<
+    TypeWithTransientFields,
+    DeepReadonly<TypeWithTransientFields[FieldName]>
   >;
 };
 
@@ -46,26 +42,26 @@ export type ResolvedFields<FieldsResolver extends Record<string, FieldResolver<u
 };
 
 export async function resolveFields<
-  OptionalType extends Record<string, unknown>,
+  Type extends Record<string, unknown>,
   TransientFields extends Record<string, unknown>,
-  _DefaultFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
-  _InputFieldsResolver extends FieldsResolver<OptionalType & TransientFields>,
+  _DefaultFieldsResolver extends FieldsResolver<Type & TransientFields>,
+  _InputFieldsResolver extends FieldsResolver<Type & TransientFields>,
 >(
-  fieldNames: readonly (keyof OptionalType)[],
+  fieldNames: readonly (keyof Type)[],
   seq: number,
   defaultFieldsResolver: _DefaultFieldsResolver,
   inputFieldsResolver: _InputFieldsResolver,
 ): Promise<
-  StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<_InputFieldsResolver>>, keyof OptionalType>
+  StrictlyPick<Merge<ResolvedFields<_DefaultFieldsResolver>, ResolvedFields<_InputFieldsResolver>>, keyof Type>
 > {
-  type OptionalTypeWithTransientFields = OptionalType & TransientFields;
+  type TypeWithTransientFields = Type & TransientFields;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Use any type as it is impossible to match types.
   const fields = {} as any;
 
   async function resolveField<
-    _FieldResolverOptions extends FieldResolverOptions<OptionalTypeWithTransientFields>,
-    _FieldResolver extends FieldResolver<OptionalTypeWithTransientFields, unknown>,
+    _FieldResolverOptions extends FieldResolverOptions<TypeWithTransientFields>,
+    _FieldResolver extends FieldResolver<TypeWithTransientFields, unknown>,
   >(options: _FieldResolverOptions, fieldResolver: _FieldResolver): Promise<ResolvedField<_FieldResolver>> {
     if (fieldResolver instanceof Dynamic) {
       return fieldResolver.get(options);
@@ -74,12 +70,12 @@ export async function resolveFields<
     }
   }
 
-  async function resolveFieldAndUpdateCache<FieldName extends keyof OptionalTypeWithTransientFields>(
+  async function resolveFieldAndUpdateCache<FieldName extends keyof TypeWithTransientFields>(
     fieldName: FieldName,
-  ): Promise<DeepReadonly<OptionalTypeWithTransientFields[FieldName]> | undefined> {
+  ): Promise<DeepReadonly<TypeWithTransientFields[FieldName]> | undefined> {
     if (fieldName in fields) return fields[fieldName];
 
-    let fieldResolver: FieldResolver<OptionalType & TransientFields, unknown>;
+    let fieldResolver: FieldResolver<Type & TransientFields, unknown>;
     if (fieldName in inputFieldsResolver) {
       fieldResolver = inputFieldsResolver[fieldName as keyof _InputFieldsResolver];
     } else if (fieldName in defaultFieldsResolver) {
@@ -93,7 +89,7 @@ export async function resolveFields<
     return fields[fieldName];
   }
 
-  const options: FieldResolverOptions<OptionalTypeWithTransientFields> = {
+  const options: FieldResolverOptions<TypeWithTransientFields> = {
     seq,
     get: resolveFieldAndUpdateCache,
   };