@deterministic-code/datasources-cli 0.0.0-stage → 0.1.2

package/node_modules/@deterministic-code/typescript-generators/src/client-bindings-ir.ts

@@ -0,0 +1,273 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import {
+  namedRoutes,
+  type RoutesApiBody,
+  type RoutesApiDoc,
+  type RoutesApiRouteDef,
+} from "@deterministic-code/generators-common/routes-api";
+import { loadRoutesApi } from "@deterministic-code/generators-common/routes-api-converter";
+import { createCasing } from "./common/default-casing.ts";
+import { httpPathFromRoutesApi } from "./common/http-path.ts";
+import { resolvesToSelf } from "./frontend-bindings-routes.ts";
+
+const camelIdent = (name: string): string =>
+  name.replace(/_([a-z0-9])/gi, (_, ch: string) => ch.toUpperCase());
+
+const pascalIdent = (name: string): string => {
+  const camel = camelIdent(name);
+  return `${camel.slice(0, 1).toUpperCase()}${camel.slice(1)}`;
+};
+
+export const clientBindingsSchema = (settings: Record<string, string>): string =>
+  settings["client_bindings.schema"] ?? "self";
+
+export const requireSelfSchema = (settings: Record<string, string>): void => {
+  const schema = clientBindingsSchema(settings);
+  if (!resolvesToSelf(schema)) {
+    throw new Error(
+      `generate-client-bindings: schema ${JSON.stringify(schema)} is not this backend (expected "self" or "id:...")`,
+    );
+  }
+};
+
+const pathParamNames = (path: string): string[] => {
+  const counts = new Map<string, number>();
+  return [...path.matchAll(/\{([^}]+)\}/g)].map((match) => {
+    const camel = camelIdent(match[1]!);
+    const n = (counts.get(camel) ?? 0) + 1;
+    counts.set(camel, n);
+    return n === 1 ? camel : `${camel}_${n}`;
+  });
+};
+
+const pathExpr = (path: string, params: string[]): string => {
+  if (params.length === 0) return JSON.stringify(path);
+  let i = 0;
+  const replaced = path.replace(/\{[^}]+\}/g, () => {
+    const name = params[i++]!;
+    return `\${encodeURIComponent(String(${name}))}`;
+  });
+  return `\`${replaced}\``;
+};
+
+const methodNameOf = (routeName: string, entity: string | null): string => {
+  if (entity === null) return camelIdent(routeName);
+  const prefix = camelIdent(entity);
+  if (!routeName.startsWith(prefix) || routeName.length === prefix.length) {
+    return camelIdent(routeName);
+  }
+  const rest = routeName.slice(prefix.length);
+  return rest[0]!.toLowerCase() + rest.slice(1);
+};
+
+const namedType = (typeName: string): string | undefined => {
+  if (typeName === "unknown" || typeName === "void") return undefined;
+  return typeName.endsWith("[]") ? typeName.slice(0, -2) : typeName;
+};
+
+const bodyName = (body: RoutesApiBody | undefined): string | undefined =>
+  body === undefined ? undefined : body.name;
+
+export type ClientMethodIr = {
+  methodName: string;
+  pascalName: string;
+  hookName: string;
+  httpMethod: string;
+  pathPattern: string;
+  pathExpr: string;
+  params: string[];
+  hasArgs: boolean;
+  hasBody: boolean;
+  hasResponse: boolean;
+  isList: boolean;
+  isQuery: boolean;
+  args: string;
+  callArgs: string;
+  liveArgs: string;
+  liveMutationArg: string;
+  mutationArg: string;
+  mutationCall: string;
+  hasMutationArg: boolean;
+  bodyType: string;
+  returnType: string;
+  mockReturn: string;
+  queryKeyExpr: string;
+};
+
+export type ClientEntityIr = {
+  fileBase: string;
+  clientName: string;
+  queryOptionsName: string;
+  mutationOptionsName: string;
+  pascalEntity: string;
+  methods: ClientMethodIr[];
+  queries: ClientMethodIr[];
+  mutations: ClientMethodIr[];
+  typeImports: Array<{ typeName: string; importPath: string }>;
+};
+
+export type ClientBindingsIr = {
+  entities: ClientEntityIr[];
+};
+
+const isListPath = (method: string, path: string): boolean =>
+  method === "GET" && !/\{[^}]+\}$/.test(path);
+
+const mutationShape = (
+  params: string[],
+  hasBody: boolean,
+  bodyType: string,
+): Pick<ClientMethodIr, "mutationArg" | "mutationCall" | "hasMutationArg"> => {
+  const fields = [
+    ...params.map((name) => `${name}: string | number`),
+    ...(hasBody ? [`body: ${bodyType}`] : []),
+  ];
+  if (fields.length === 0) {
+    return { mutationArg: "", mutationCall: "", hasMutationArg: false };
+  }
+  if (fields.length === 1) {
+    return {
+      mutationArg: fields[0]!,
+      mutationCall: hasBody ? "body" : params[0]!,
+      hasMutationArg: true,
+    };
+  }
+  return {
+    mutationArg: `vars: { ${fields.join("; ")} }`,
+    mutationCall: [
+      ...params.map((name) => `vars.${name}`),
+      ...(hasBody ? ["vars.body"] : []),
+    ].join(", "),
+    hasMutationArg: true,
+  };
+};
+
+const projectMethod = (
+  routeName: string,
+  def: RoutesApiRouteDef,
+): { method: ClientMethodIr; typeNames: string[] } => {
+  const pathPattern = httpPathFromRoutesApi(def.path);
+  const params = pathParamNames(pathPattern);
+  const httpMethod = def.method.toUpperCase();
+  const isList = isListPath(httpMethod, pathPattern);
+  const requestName = bodyName(def.request);
+  const responseName = bodyName(def.response);
+  const hasBody = requestName !== undefined;
+  const bodyType = requestName ?? "unknown";
+  const hasResponse = responseName !== undefined;
+  const returnType = !hasResponse
+    ? "void"
+    : isList
+      ? `${responseName}[]`
+      : responseName;
+  const methodName = methodNameOf(routeName, def.entity);
+  const argParts = [
+    ...params.map((name) => `${name}: string | number`),
+    ...(hasBody ? [`body: ${bodyType}`] : []),
+  ];
+  const callParts = [...params, ...(hasBody ? ["body"] : [])];
+  const liveParts = [...params.map(() => "1"), ...(hasBody ? ["{}"] : [])];
+  const typeNames = [namedType(bodyType), namedType(returnType)].filter(
+    (name): name is string => name !== undefined,
+  );
+  const method: ClientMethodIr = {
+    methodName,
+    pascalName: pascalIdent(methodName),
+    hookName: pascalIdent(`use_${def.entity ?? "custom"}_${methodName}`),
+    httpMethod,
+    pathPattern,
+    pathExpr: pathExpr(pathPattern, params),
+    params,
+    hasArgs: argParts.length > 0,
+    hasBody,
+    hasResponse,
+    isList,
+    isQuery: httpMethod === "GET",
+    args: argParts.join(", "),
+    callArgs: callParts.join(", "),
+    liveArgs: liveParts.join(", "),
+    liveMutationArg:
+      callParts.length === 0
+        ? ""
+        : callParts.length === 1
+          ? liveParts[0]!
+          : `{ ${callParts.map((name, i) => `${name}: ${liveParts[i]!}`).join(", ")} }`,
+    ...mutationShape(params, hasBody, bodyType),
+    bodyType,
+    returnType,
+    mockReturn: isList ? "[]" : hasResponse ? "{}" : "undefined",
+    queryKeyExpr: `[${[JSON.stringify(def.entity ?? "custom"), JSON.stringify(methodName), ...params].join(", ")}] as const`,
+  };
+  return { method, typeNames };
+};
+
+export const projectClientBindings = (
+  doc: RoutesApiDoc,
+  typeImport: (typeName: string) => string = (typeName) =>
+    `../../types/${typeName}`,
+): ClientBindingsIr => {
+  const grouped = new Map<
+    string,
+    { fileBase: string; clientName: string; pascalEntity: string; methods: ClientMethodIr[]; typeNames: Set<string> }
+  >();
+  for (const [routeName, def] of namedRoutes(doc.routes)) {
+    const fileBase = def.entity ?? "custom";
+    const bucket = grouped.get(fileBase) ?? {
+      fileBase,
+      clientName: camelIdent(`${fileBase}_client`),
+      pascalEntity: pascalIdent(fileBase),
+      methods: [],
+      typeNames: new Set<string>(),
+    };
+    if (!grouped.has(fileBase)) grouped.set(fileBase, bucket);
+    const projected = projectMethod(routeName, def);
+    bucket.methods.push(projected.method);
+    for (const name of projected.typeNames) bucket.typeNames.add(name);
+  }
+  const entities = [...grouped.values()]
+    .sort((a, b) => a.fileBase.localeCompare(b.fileBase))
+    .map((bucket) => ({
+      fileBase: bucket.fileBase,
+      clientName: bucket.clientName,
+      queryOptionsName: camelIdent(`${bucket.fileBase}_client_query_options`),
+      mutationOptionsName: camelIdent(`${bucket.fileBase}_client_mutation_options`),
+      pascalEntity: bucket.pascalEntity,
+      methods: bucket.methods,
+      queries: bucket.methods.filter((method) => method.isQuery),
+      mutations: bucket.methods.filter((method) => !method.isQuery),
+      typeImports: [...bucket.typeNames]
+        .sort((a, b) => a.localeCompare(b))
+        .map((typeName) => ({ typeName, importPath: typeImport(typeName) })),
+    }));
+  return { entities };
+};
+
+export const loadClientBindingsIr = async (
+  ctx: GenerateContext,
+): Promise<ClientBindingsIr> => {
+  requireSelfSchema(ctx.settings);
+  const ir = projectClientBindings(await loadRoutesApi(ctx));
+  const casing = createCasing(ctx.settings);
+  return {
+    entities: ir.entities.map((entity) => {
+      const originalEntity = entity.fileBase;
+      const fileBase = casing.fileBase(originalEntity);
+      const methods = entity.methods.map((method) => ({
+        ...method,
+        pascalName: casing.convertTypes(method.methodName),
+        hookName: casing.hookName(originalEntity, method.methodName),
+      }));
+      return {
+        ...entity,
+        fileBase,
+        clientName: casing.clientName(originalEntity),
+        queryOptionsName: casing.clientQueryOptionsName(originalEntity),
+        mutationOptionsName: casing.clientMutationOptionsName(originalEntity),
+        pascalEntity: casing.convertTypes(originalEntity),
+        methods,
+        queries: methods.filter((method) => method.isQuery),
+        mutations: methods.filter((method) => !method.isQuery),
+      };
+    }),
+  };
+};

package/node_modules/@deterministic-code/typescript-generators/src/common/default-casing.test.ts

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createCasing } from "./default-casing.ts";
+
+const NAME = "notification_type";
+
+describe("createCasing Auto defaults", () => {
+  it("matches Default Casings for TypeScript", () => {
+    const casing = createCasing({});
+    assert.equal(casing.convertFileName(NAME), "notificationType");
+    assert.equal(casing.convertTypes(NAME), "NotificationType");
+    assert.equal(casing.convertFields(NAME), "notification_type");
+    assert.equal(casing.convertDirectories(NAME), "notificationType");
+    assert.equal(casing.filePath(NAME), "notificationType.ts");
+    assert.equal(casing.serviceClassName("user"), "UserService");
+    assert.equal(casing.serviceInterfaceName("user"), "IUserService");
+    assert.equal(casing.serviceInterfaceName("contact"), "IContactService");
+    assert.equal(
+      casing.serviceInterfaceName("contact_group"),
+      "IContactGroupService",
+    );
+    assert.equal(
+      casing.authoredInterfaceName("ContactImportService"),
+      "IContactImportService",
+    );
+    assert.equal(casing.finderMethod("channel_name"), "find_by_channel_name");
+    assert.equal(casing.schemaName("contact_group"), "ContactGroupSchema");
+    assert.equal(
+      casing.schemaName("create_contact_group"),
+      "CreateContactGroupSchema",
+    );
+    assert.equal(
+      casing.validatedTypeName("contact_group"),
+      "ContactGroupValidated",
+    );
+    assert.equal(casing.routerFnName("contact_group"), "ContactGroupRouter");
+    assert.equal(casing.hookName("contact_group", "list"), "UseContactGroupList");
+    assert.equal(casing.convertTypes("getHealth"), "GetHealth");
+    assert.equal(casing.convertTypes("import_contacts"), "ImportContacts");
+    assert.equal(
+      casing.convertTypes("ContactImportService"),
+      "ContactImportService",
+    );
+    assert.equal(casing.baseTypeName("contact"), "ContactBase");
+    assert.equal(casing.clientName("contact_source"), "ContactSourceClient");
+    assert.equal(
+      casing.clientQueryOptionsName("contact_source"),
+      "ContactSourceClientQueryOptions",
+    );
+    assert.equal(
+      casing.clientMutationOptionsName("contact_source"),
+      "ContactSourceClientMutationOptions",
+    );
+    assert.equal(casing.appFnName(), "CreateBackendApp");
+    assert.equal(casing.appComponentName(), "App");
+    assert.equal(casing.homeComponentName(), "Home");
+    assert.equal(casing.rootLayoutName(), "RootLayout");
+    assert.equal(casing.appConfigName(), "AppConfig");
+    assert.equal(casing.filePath("app"), "app.ts");
+    assert.equal(casing.filePath("server"), "server.ts");
+    assert.equal(casing.fileBase("app_boot"), "appBoot");
+  });
+});
+
+describe("createCasing overrides", () => {
+  it("pascals file names", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.file_names": "Pascal",
+    });
+    assert.equal(casing.filePath(NAME), "NotificationType.ts");
+    assert.equal(casing.convertTypes(NAME), "NotificationType");
+    assert.equal(casing.convertFields(NAME), "notification_type");
+  });
+
+  it("kebabs file names and directories", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.file_names": "Kebab",
+      "languages.typescript.casing.directories": "Kebab",
+    });
+    assert.equal(casing.fileBase(NAME), "notification-type");
+    assert.equal(casing.directory(NAME), "notification-type");
+  });
+
+  it("snakes type names", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.types": "Snake",
+    });
+    assert.equal(casing.convertTypes(NAME), "notification_type");
+    assert.equal(casing.serviceClassName("contact"), "contact_service");
+    assert.equal(casing.serviceInterfaceName("contact"), "i_contact_service");
+    assert.equal(
+      casing.serviceInterfaceName("contact_group"),
+      "i_contact_group_service",
+    );
+    assert.notEqual(
+      casing.serviceInterfaceName("contact_group"),
+      `I${casing.serviceClassName("contact_group")}`,
+    );
+    assert.equal(casing.schemaName("contact_group"), "contact_group_schema");
+    assert.equal(
+      casing.schemaName("create_contact_group"),
+      "create_contact_group_schema",
+    );
+    assert.equal(
+      casing.validatedTypeName("contact_group"),
+      "contact_group_validated",
+    );
+    assert.equal(casing.routerFnName("contact"), "contact_router");
+    assert.equal(
+      casing.hookName("contact_group", "list"),
+      "use_contact_group_list",
+    );
+    assert.equal(
+      casing.authoredInterfaceName("ContactImportService"),
+      "i_contact_import_service",
+    );
+    assert.equal(casing.convertTypes("getHealth"), "get_health");
+    assert.equal(casing.convertTypes("import_contacts"), "import_contacts");
+    assert.equal(
+      casing.convertTypes("ContactImportService"),
+      "contact_import_service",
+    );
+    assert.equal(casing.baseTypeName("contact"), "contact_base");
+    assert.equal(casing.clientName("contact_source"), "contact_source_client");
+    assert.equal(
+      casing.clientQueryOptionsName("contact_source"),
+      "contact_source_client_query_options",
+    );
+    assert.equal(casing.appFnName(), "create_backend_app");
+    assert.equal(casing.appComponentName(), "app");
+    assert.equal(casing.homeComponentName(), "home");
+    assert.equal(casing.rootLayoutName(), "root_layout");
+    assert.equal(casing.appConfigName(), "app_config");
+  });
+
+  it("camels type names and wraps I with every token", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.types": "Camel",
+    });
+    assert.equal(casing.convertTypes(NAME), "notificationType");
+    assert.equal(casing.serviceClassName("contact"), "contactService");
+    assert.equal(casing.serviceInterfaceName("contact"), "iContactService");
+    assert.equal(
+      casing.serviceInterfaceName("contact_group"),
+      "iContactGroupService",
+    );
+    assert.equal(
+      casing.serviceInterfaceName("notification_type"),
+      "iNotificationTypeService",
+    );
+    assert.equal(
+      casing.authoredInterfaceName("ContactImportService"),
+      "iContactImportService",
+    );
+    assert.notEqual(
+      casing.serviceInterfaceName("contact_group"),
+      `I${casing.serviceClassName("contact_group")}`,
+    );
+  });
+
+  it("camels fields", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.fields": "Camel",
+    });
+    assert.equal(casing.convertFields("role_id"), "roleId");
+    assert.equal(casing.fieldIdent("role_id"), "roleId");
+    assert.equal(casing.finderMethod("channel_name"), "findByChannelName");
+  });
+
+  it("pascals fields", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.fields": "Pascal",
+    });
+    assert.equal(casing.convertFields("role_id"), "RoleId");
+  });
+
+  it("kebabs fields", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.fields": "Kebab",
+    });
+    assert.equal(casing.convertFields("role_id"), "role-id");
+    assert.equal(casing.fieldIdent("role_id"), '"role-id"');
+  });
+
+  it("snakes directories independently of files", () => {
+    const casing = createCasing({
+      "languages.typescript.casing.file_names": "Pascal",
+      "languages.typescript.casing.directories": "Snake",
+    });
+    assert.equal(casing.fileBase(NAME), "NotificationType");
+    assert.equal(casing.directory(NAME), "notification_type");
+  });
+});

package/node_modules/@deterministic-code/typescript-generators/src/common/default-casing.ts

@@ -0,0 +1,90 @@
+import {
+  createCasingStrategy,
+  type ICasingStrategy,
+} from "@deterministic-code/generators-common/casing-strategy";
+
+export const GENERATOR_LANGUAGE = "typescript";
+
+const IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const VARIANT_PREFIXES = ["update_", "create_"] as const;
+
+export const jsIdent = (name: string): string =>
+  IDENT_RE.test(name) ? name : JSON.stringify(name);
+
+const featureEntity = (entity: string): string => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === undefined ? entity : entity.slice(prefix.length);
+};
+
+export type PackCasing = ICasingStrategy & {
+  fileBase: (stem: string) => string
+  directory: (entity: string) => string
+  filePath: (stem: string) => string
+  fieldIdent: (field: string) => string
+  serviceClassName: (entity: string) => string
+  serviceInterfaceName: (entity: string) => string
+  authoredInterfaceName: (name: string) => string
+  baseTypeName: (entity: string) => string
+  schemaName: (name: string) => string
+  validatedTypeName: (name: string) => string
+  routerFnName: (entity: string) => string
+  hookName: (entity: string, method: string) => string
+  finderMethod: (field: string) => string
+  clientName: (entity: string) => string
+  clientQueryOptionsName: (entity: string) => string
+  clientMutationOptionsName: (entity: string) => string
+  appFnName: () => string
+  appComponentName: () => string
+  homeComponentName: () => string
+  rootLayoutName: () => string
+  appConfigName: () => string
+};
+
+/** Language defaults + settings overrides. Layout (by-feature) lives on ImportGenerator. */
+export const createCasing = (
+  settings: Record<string, string>,
+): PackCasing => {
+  const casing = createCasingStrategy(GENERATOR_LANGUAGE, settings);
+  const fileBase = (stem: string): string => casing.convertFileName(stem);
+  const directory = (entity: string): string =>
+    casing.convertDirectories(featureEntity(entity));
+  const filePath = (stem: string): string => `${fileBase(stem)}.ts`;
+  const convertFields = (text: string): string => casing.convertFields(text);
+  const fieldIdent = (field: string): string => jsIdent(convertFields(field));
+  return {
+    convertFileName: (text: string) => casing.convertFileName(text),
+    convertTypes: (text: string) => casing.convertTypes(text),
+    convertFields,
+    convertDirectories: (text: string) => casing.convertDirectories(text),
+    fileBase,
+    directory,
+    filePath,
+    fieldIdent,
+    serviceClassName: (entity: string) => casing.convertTypes(`${entity}_service`),
+    serviceInterfaceName: (entity: string) =>
+      casing.convertTypes(`i_${entity}_service`),
+    authoredInterfaceName: (name: string) => casing.convertTypes(`i_${name}`),
+    baseTypeName: (entity: string) => casing.convertTypes(`${entity}_base`),
+    schemaName: (name: string) => casing.convertTypes(`${name}_schema`),
+    validatedTypeName: (name: string) =>
+      casing.convertTypes(`${name}_validated`),
+    routerFnName: (entity: string) => casing.convertTypes(`${entity}_router`),
+    hookName: (entity: string, method: string) =>
+      casing.convertTypes(`use_${entity}_${method}`),
+    finderMethod: (field: string) => convertFields(`find_by_${field}`),
+    clientName: (entity: string) => casing.convertTypes(`${entity}_client`),
+    clientQueryOptionsName: (entity: string) =>
+      casing.convertTypes(`${entity}_client_query_options`),
+    clientMutationOptionsName: (entity: string) =>
+      casing.convertTypes(`${entity}_client_mutation_options`),
+    appFnName: () => casing.convertTypes("create_backend_app"),
+    appComponentName: () => casing.convertTypes("app"),
+    homeComponentName: () => casing.convertTypes("home"),
+    rootLayoutName: () => casing.convertTypes("root_layout"),
+    appConfigName: () => casing.convertTypes("app_config"),
+  };
+};
+
+export const defaultCasing = (
+  settings: Record<string, string>,
+): ICasingStrategy => createCasing(settings);

package/node_modules/@deterministic-code/typescript-generators/src/common/dictionary-candidate.ts

@@ -0,0 +1,4 @@
+/** Owned dictionaries are maps nested on an owner, not CRUD entities. */
+export const isDictionaryCandidate = (candidate: {
+  inherits?: string;
+}): boolean => candidate.inherits === "dictionary";

package/node_modules/@deterministic-code/typescript-generators/src/common/fake-test-data.ts

@@ -0,0 +1,132 @@
+import { patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+
+type LanguageTarget = "typescript" | "rust" | "csharp";
+type SqlDialect = "postgres" | "sqlite" | "mysql" | "sqlserver" | "oracle";
+type FakeTestTarget = LanguageTarget | SqlDialect;
+type FakeTestStrategy = "faker" | "homegrown";
+
+export type IdType = "integer" | "biginteger" | "uuid" | "string";
+
+/** Source expressions for one generated-test target. Faker vs homegrown is the strategy; dialect is the language or SQL dialect the snippet must compile as. */
+export interface IFakeTestData {
+  readonly target: FakeTestTarget;
+  readonly strategy: FakeTestStrategy;
+
+  /** Import / use / using lines the generated file needs. Empty when the dialect needs none. */
+  prelude: () => string[];
+
+  uuid: () => string;
+  string: (size?: number) => string;
+  integer: () => string;
+  biginteger: () => string;
+  float: () => string;
+  decimal: () => string;
+  boolean: () => string;
+  datetime: () => string;
+  date: () => string;
+  email: () => string;
+  binary: () => string;
+
+  id: (idType: IdType) => string;
+}
+
+const idExpr = (data: IFakeTestData, idType: IdType): string => {
+  if (idType === "uuid") return data.uuid();
+  if (idType === "string") return data.string();
+  if (idType === "biginteger") return data.biginteger();
+  return data.integer();
+};
+
+const typescriptFakerTestData: IFakeTestData = {
+  target: "typescript",
+  strategy: "faker",
+  prelude: () => [`import { faker } from "@faker-js/faker";`],
+  uuid: () => "faker.string.uuid()",
+  string: (size) =>
+    size === undefined
+      ? "faker.string.alphanumeric({ length: 12 })"
+      : `faker.string.alphanumeric({ length: ${size} })`,
+  integer: () => "faker.number.int({ min: 1 })",
+  biginteger: () => "faker.number.bigInt({ min: 1n })",
+  float: () => "faker.number.float()",
+  decimal: () => "faker.commerce.price()",
+  boolean: () => "faker.datatype.boolean()",
+  datetime: () => "faker.date.recent()",
+  date: () => "faker.date.recent().toISOString().slice(0, 10)",
+  email: () => "faker.internet.email()",
+  binary: () => "faker.string.alphanumeric({ length: 24 })",
+  id: (idType) => idExpr(typescriptFakerTestData, idType),
+};
+
+export const fakeTestData: IFakeTestData = typescriptFakerTestData;
+
+export const FAKER_DEV_DEPENDENCY = "^9.9.0";
+
+export const fakerPackagePatch = (
+  filename = "package.json",
+): GenerateEntry =>
+  patch(
+    filename,
+    JSON.stringify({
+      devDependencies: { "@faker-js/faker": FAKER_DEV_DEPENDENCY },
+    }),
+  );
+
+export const withFakerPackagePatch = (
+  entries: GenerateEntry[],
+  filename = "package.json",
+): GenerateEntry[] =>
+  entries.length === 0 ? entries : [...entries, fakerPackagePatch(filename)];
+
+export const asIdType = (idType: string): IdType => {
+  if (idType === "uuid" || idType === "string" || idType === "biginteger") {
+    return idType;
+  }
+  return "integer";
+};
+
+export const preludeSource = (data: IFakeTestData): string => {
+  const lines = data.prelude();
+  return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+};
+
+/** TypeScript source for one spec field in a generated test. `nativeType` is the id-column override (`bigint`). */
+export const fieldExpr = (
+  data: IFakeTestData,
+  type: string,
+  opts: { nativeType?: string; size?: number } = {},
+): string => {
+  if (opts.nativeType === "bigint") return data.biginteger();
+  switch (type) {
+    case "uuid":
+      return data.uuid();
+    case "string":
+    case "character":
+      return data.string(opts.size);
+    case "email":
+      return data.email();
+    case "binary":
+      return data.binary();
+    case "boolean":
+      return data.boolean();
+    case "decimal":
+      return data.decimal();
+    case "float":
+      return data.float();
+    case "datetime":
+      return data.datetime();
+    case "date":
+      return data.date();
+    case "number":
+    case "integer":
+    case "smallinteger":
+    case "biginteger":
+    case "unsignedinteger":
+    case "unsignedsmallinteger":
+    case "unsignedbiginteger":
+    case "reference":
+      return data.integer();
+    default:
+      return data.string(opts.size);
+  }
+};