Implement defineTypeFactory, .build() and defaultFields

Author: mizdra

.eslintrc.cjs

@@ -11,6 +11,9 @@ module.exports = {
     es2022: true,
     node: true,
   },
+  rules: {
+    'no-use-before-define': 'off',
+  },
   overrides: [
     {
       files: ['*.ts', '*.tsx', '*.cts', '*.mts'],

src/index.test.ts

@@ -0,0 +1,44 @@
+import { expectType } from 'ts-expect';
+import { expect, it, describe } from 'vitest';
+import { defineBookFactory, type Book } from './index.js';
+
+describe('defineTypeFactory', () => {
+  it('basic', async () => {
+    const BookFactory = defineBookFactory({
+      defaultFields: {
+        id: async () => Promise.resolve('Book-1'),
+        title: async () => Promise.resolve('ゆゆ式'),
+        author: async () =>
+          Promise.resolve({
+            id: 'Author-1',
+            name: '三上小又',
+            books: [],
+          }),
+      },
+    });
+    const book1 = await BookFactory.build();
+    expect(book1).toMatchInlineSnapshot(`
+      {
+        "author": {
+          "books": [],
+          "id": "Author-1",
+          "name": "三上小又",
+        },
+        "id": "Book-1",
+        "title": "ゆゆ式",
+      }
+    `);
+    expectType<{
+      id: string;
+      title: string;
+      author: {
+        id: string;
+        name: string;
+        books: Book[];
+      };
+    }>(book1);
+    // @ts-expect-error
+    // eslint-disable-next-line no-unused-expressions
+    book1.unknownField;
+  });
+});

src/index.ts

@@ -1,2 +1,75 @@
-export { run } from './runner.js';
-export { add } from './math.js';
+export type Book = {
+  id: string;
+  title: string;
+  author: Author;
+};
+export type Author = {
+  id: string;
+  name: string;
+  books: Book[];
+};
+
+/** Convert `{ a: number, b: { c: number } }` into `{ a: number | undefined, b: { c: number | undefined } | undefined }`. */
+type DeepOptional<T> = {
+  [K in keyof T]: T[K] extends Record<string, unknown> ? DeepOptional<T[K]> | undefined : T[K] | undefined;
+};
+type Entries<T> = {
+  [K in keyof T]: [K, T[K]];
+}[keyof T][];
+type FieldResolver<Field> = () => Promise<Field>;
+type ResolvedFields<FieldsResolver> = {
+  [FieldName in keyof FieldsResolver]: FieldsResolver[FieldName] extends FieldResolver<infer Field> ? Field : never;
+};
+
+interface BookFactoryInterfaceWithoutTraits<TOptions extends BookFactoryDefineOptions> {
+  build<T extends Partial<DeepOptional<Book>>>(inputFields?: T): Promise<ResolvedFields<TOptions['defaultFields']> & T>;
+}
+interface BookFactoryDefineOptions {
+  defaultFields: {
+    [Key in keyof Book]: FieldResolver<DeepOptional<Book>[Key]>;
+  };
+}
+type BookFactoryInterface<TOptions extends BookFactoryDefineOptions> = BookFactoryInterfaceWithoutTraits<TOptions>;
+
+async function resolveFields<
+  TOptions extends BookFactoryDefineOptions,
+  InputFields extends Partial<DeepOptional<Book>>,
+>(
+  defaultFieldResolvers: TOptions['defaultFields'],
+  inputFields: InputFields,
+): Promise<ResolvedFields<TOptions['defaultFields']> & InputFields> {
+  const fields: ResolvedFields<TOptions['defaultFields']> & InputFields = {} as never;
+  for (const [key, defaultFieldResolver] of Object.entries(defaultFieldResolvers) as Entries<
+    TOptions['defaultFields']
+  >) {
+    // eslint-disable-next-line no-await-in-loop
+    fields[key] = inputFields[key as keyof InputFields] ?? (await defaultFieldResolver());
+  }
+  return fields;
+}
+
+function defineBookFactoryInternal<const TOptions extends BookFactoryDefineOptions>({
+  defaultFields: defaultFieldResolvers,
+}: TOptions): BookFactoryInterface<TOptions> {
+  return {
+    async build(inputFields) {
+      const fields = await resolveFields(
+        defaultFieldResolvers,
+        inputFields ?? ({} as Exclude<typeof inputFields, undefined>),
+      );
+      return fields;
+    },
+  };
+}
+
+/**
+ * Define factory for {@link Book} model.
+ *
+ * @param options
+ * @returns factory {@link BookFactoryInterface}
+ */
+export function defineBookFactory<TOptions extends BookFactoryDefineOptions>(
+  options: TOptions,
+): BookFactoryInterface<TOptions> {
+  return defineBookFactoryInternal(options);
+}