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

package/node_modules/@deterministic-code/typescript-generators/src/generate-backend-app.ts

@@ -0,0 +1,116 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  appBootTestTs,
+  appTs,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  healthTestTs,
+  packageJson,
+  serverTs,
+  tsconfigJson,
+  vitestConfigTs,
+} from "./resources/backend-app.ts";
+import {
+  minimalAppTs,
+  minimalHealthTestTs,
+  minimalPackageJson,
+  minimalServerTs,
+  minimalTsconfigJson,
+} from "./resources/backend-app-minimal.ts";
+import { Emit } from "./emit.ts";
+
+const DEFAULT_APP_NAME = "generated-app";
+const DEFAULT_COMPLEXITY = "deterministic";
+
+type AppGenerateComplexity = "minimal" | "deterministic";
+
+const complexityOf = (settings: Record<string, string>): AppGenerateComplexity => {
+  const raw = settings.app_generate_complexity;
+  if (raw === undefined || raw === "") return DEFAULT_COMPLEXITY;
+  if (raw === "minimal" || raw === "deterministic") return raw;
+  throw new Error(
+    `settings.app_generate_complexity must be "minimal" or "deterministic", got ${JSON.stringify(raw)}`,
+  );
+};
+
+class Generator extends Emit {
+  from(appName: string, complexity: AppGenerateComplexity): GenerateEntry[] {
+    return complexity === "minimal"
+      ? this.minimal(appName)
+      : this.deterministic(appName);
+  }
+
+  private tokens(appName: string) {
+    const appFile = this.imports.app();
+    const serverFile = this.imports.server();
+    return {
+      appName,
+      appFnName: this.casing.appFnName(),
+      appFile,
+      appFileBase: this.casing.fileBase("app"),
+      serverFile,
+      serverFileBase: this.casing.fileBase("server"),
+      healthTestFile: this.imports.appTest("health"),
+      appBootTestFile: this.imports.appTest("app_boot"),
+      statusField: this.casing.convertFields("status"),
+      includeJson: JSON.stringify([
+        appFile,
+        serverFile,
+        ...this.imports.tsconfigIncludes(),
+        "perf-server.ts",
+      ]),
+    };
+  }
+
+  private minimal(appName: string): GenerateEntry[] {
+    const named = this.tokens(appName);
+    return [
+      content(named.appFile, fill(minimalAppTs, named)),
+      content(named.serverFile, fill(minimalServerTs, named)),
+      content("package.json", fill(minimalPackageJson, named)),
+      content("tsconfig.json", fill(minimalTsconfigJson, named)),
+      content(named.healthTestFile, fill(minimalHealthTestTs, named)),
+    ];
+  }
+
+  private deterministic(appName: string): GenerateEntry[] {
+    const named = this.tokens(appName);
+    const owned = new Set([
+      named.serverFile,
+      "tsconfig.json",
+      named.healthTestFile,
+    ]);
+    return [
+      ...this.minimal(appName).filter((e) => !owned.has(e.filename)),
+      patch(named.appFile, fill(appTs, named)),
+      content(named.serverFile, fill(serverTs, named)),
+      patch("package.json", fill(packageJson, named)),
+      content("tsconfig.json", fill(tsconfigJson, named)),
+      patch("Dockerfile", fill(dockerfile, named)),
+      patch(".dockerignore", "node_modules"),
+      patch("scripts/entrypoint.sh", entrypointSh),
+      patch("docker-compose.yml", dockerComposeYml),
+      patch(".env", envFile),
+      patch(".env.example", envFile),
+      patch(".gitignore", gitignore),
+      content("vitest.config.ts", vitestConfigTs),
+      content(named.healthTestFile, fill(healthTestTs, named)),
+      content(named.appBootTestFile, fill(appBootTestTs, named)),
+    ];
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const appName = ctx.settings.application_name || DEFAULT_APP_NAME;
+  return new Generator(ctx.settings).from(
+    appName,
+    complexityOf(ctx.settings),
+  );
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-client-bindings-live-tests.ts

@@ -0,0 +1,29 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { loadClientBindingsIr } from "./client-bindings-ir.ts";
+import { clientBindingLiveTestPath } from "./client-binding-transport.ts";
+import {
+  httpEntityTmpl,
+  tanstackEntityTmpl,
+} from "./resources/client-bindings-live-tests.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const ir = await loadClientBindingsIr(ctx);
+  return ir.entities.flatMap((entity) => [
+    content(
+      clientBindingLiveTestPath("fetch", entity.fileBase),
+      fill(httpEntityTmpl, entity),
+    ),
+    content(
+      clientBindingLiveTestPath("axios", entity.fileBase),
+      fill(httpEntityTmpl, entity),
+    ),
+    content(
+      clientBindingLiveTestPath("tanstack", entity.fileBase),
+      fill(tanstackEntityTmpl, entity),
+    ),
+  ]);
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-client-bindings-mock-tests.ts

@@ -0,0 +1,29 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { loadClientBindingsIr } from "./client-bindings-ir.ts";
+import { clientBindingMockTestPath } from "./client-binding-transport.ts";
+import {
+  httpEntityTmpl,
+  tanstackEntityTmpl,
+} from "./resources/client-bindings-mock-tests.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const ir = await loadClientBindingsIr(ctx);
+  return ir.entities.flatMap((entity) => [
+    content(
+      clientBindingMockTestPath("fetch", entity.fileBase),
+      fill(httpEntityTmpl, entity),
+    ),
+    content(
+      clientBindingMockTestPath("axios", entity.fileBase),
+      fill(httpEntityTmpl, entity),
+    ),
+    content(
+      clientBindingMockTestPath("tanstack", entity.fileBase),
+      fill(tanstackEntityTmpl, entity),
+    ),
+  ]);
+};

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

@@ -0,0 +1,56 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { fromSettings } from "@deterministic-code/generators-common/settings";
+import { loadClientBindingsIr } from "./client-bindings-ir.ts";
+import {
+  clientBindingFilePath,
+  clientBindingHttpPath,
+  clientBindingIndexPath,
+  clientBindingRootIndex,
+} from "./client-binding-transport.ts";
+import {
+  axiosHttpTmpl,
+  entityTmpl,
+  fetchHttpTmpl,
+  rootIndexTmpl,
+  tanstackIndexTmpl,
+  tanstackTmpl,
+  transportIndexTmpl,
+} from "./resources/client-bindings.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const ir = await loadClientBindingsIr(ctx);
+  const entries: GenerateEntry[] = [
+    content(clientBindingHttpPath("fetch"), fetchHttpTmpl),
+    content(clientBindingHttpPath("axios"), axiosHttpTmpl),
+    ...ir.entities.flatMap((entity) => [
+      content(
+        clientBindingFilePath("fetch", entity.fileBase),
+        fill(entityTmpl, entity),
+      ),
+      content(
+        clientBindingFilePath("axios", entity.fileBase),
+        fill(entityTmpl, entity),
+      ),
+      content(
+        clientBindingFilePath("tanstack", entity.fileBase),
+        fill(tanstackTmpl, entity),
+      ),
+    ]),
+  ];
+  if (!fromSettings(ctx.settings).createIndex) return entries;
+  const indexTokens = { entities: ir.entities, hasHttp: true };
+  entries.push(
+    content(clientBindingIndexPath("fetch"), fill(transportIndexTmpl, indexTokens)),
+    content(clientBindingIndexPath("axios"), fill(transportIndexTmpl, indexTokens)),
+    content(
+      clientBindingIndexPath("tanstack"),
+      fill(tanstackIndexTmpl, { entities: ir.entities }),
+    ),
+    content(clientBindingRootIndex, rootIndexTmpl),
+  );
+  return entries;
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-context.ts

@@ -0,0 +1 @@
+export type { GenerateContext } from "@deterministic-code/generators-common/generate-context";

package/node_modules/@deterministic-code/typescript-generators/src/generate-datasource-type-validators-tests.ts

@@ -0,0 +1,203 @@
+import { toNative } from "./deterministic-type-converter.ts";
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  TYPES_YAML,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fieldSize } from "./common/view-shape.ts";
+import { typeTestTmpl } from "./resources/datasource-type-validators-tests.ts";
+import {
+  fakeTestData,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch,
+} from "./common/fake-test-data.ts";
+import { bag, Emit } from "./emit.ts";
+
+type FieldTok = {
+  name: string;
+  ident: string;
+  sampleExpr: string;
+  isNullable: boolean;
+  hasDefault: boolean;
+  type: string;
+};
+
+type CaseTok = {
+  name: string;
+  fixture: string;
+  assertion: string;
+};
+
+const MUTABLE_SCALAR = new Set([
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "reference",
+  "binary",
+]);
+
+const escapeTestName = (name: string): string =>
+  name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+
+const objectLiteral = (fields: Array<{ ident: string; expr: string }>): string =>
+  `{ ${fields.map((f) => `${f.ident}: ${f.expr}`).join(", ")} }`;
+
+const wrongTypeExpr = (type: string): string | undefined => {
+  switch (type) {
+    case "string":
+      return "123";
+    case "number":
+    case "reference":
+      return `"not-a-number"`;
+    case "boolean":
+      return `"not-a-boolean"`;
+    case "datetime":
+      return "42";
+    case "binary":
+      return `"not-binary"`;
+    default:
+      return undefined;
+  }
+};
+
+const fieldTok = (
+  field: TypeField,
+  fieldIdent: (name: string) => string,
+  typesByName: ReadonlyMap<string, Type>,
+): FieldTok => {
+  const ident = fieldIdent(field.name);
+  const specType = fieldTypeOf(field, typesByName);
+  const sampleExpr = fieldExpr(fakeTestData, specType, {
+    nativeType: toNative(specType),
+    size: fieldSize(field),
+  });
+  return {
+    name: field.name,
+    ident,
+    sampleExpr,
+    isNullable: field.isNullable,
+    hasDefault: field.hasDefault === true,
+    type: specType,
+  };
+};
+
+const casesFor = (fields: FieldTok[]): CaseTok[] => {
+  const valid = objectLiteral(
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr })),
+  );
+  const cases: CaseTok[] = [
+    { name: "parses a valid payload", fixture: valid, assertion: "not.toThrow" },
+  ];
+  if (fields.some((f) => f.isNullable)) {
+    cases.push({
+      name: "accepts null for nullable fields",
+      fixture: objectLiteral(
+        fields.map((f) => ({
+          ident: f.ident,
+          expr: f.isNullable ? "null" : f.sampleExpr,
+        })),
+      ),
+      assertion: "not.toThrow",
+    });
+  }
+  for (const field of fields) {
+    if (!field.isNullable && !field.hasDefault) {
+      cases.push({
+        name: escapeTestName(`rejects when missing required field "${field.name}"`),
+        fixture: objectLiteral(
+          fields
+            .filter((f) => f.ident !== field.ident)
+            .map((f) => ({ ident: f.ident, expr: f.sampleExpr })),
+        ),
+        assertion: "toThrow",
+      });
+    }
+    if (!field.isNullable) {
+      cases.push({
+        name: escapeTestName(`rejects when null for non-nullable field "${field.name}"`),
+        fixture: objectLiteral(
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === field.ident ? "null" : f.sampleExpr,
+          })),
+        ),
+        assertion: "toThrow",
+      });
+    }
+    if (MUTABLE_SCALAR.has(field.type)) {
+      const bad = wrongTypeExpr(field.type);
+      if (bad !== undefined) {
+        cases.push({
+          name: escapeTestName(`rejects when wrong type on field "${field.name}"`),
+          fixture: objectLiteral(
+            fields.map((f) => ({
+              ident: f.ident,
+              expr: f.ident === field.ident ? bad : f.sampleExpr,
+            })),
+          ),
+          assertion: "toThrow",
+        });
+      }
+    }
+  }
+  return cases;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    return datasourceTypesOf(deterministic).map((table) =>
+      this.tests(table, typesByName),
+    );
+  }
+
+  private tests(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const fields = persistedColumnFields(table, typesByName).map((f) =>
+      fieldTok(f, (name) => this.casing.fieldIdent(name), typesByName),
+    );
+    const src = this.imports.datasourceValidator(table.name);
+    const schemaName = this.casing.schemaName(table.name);
+    return content(
+      this.imports.test(src, table.name),
+      fill(typeTestTmpl, {
+        prelude: preludeSource(fakeTestData),
+        schemaVersion: this.settings.schemaVersion,
+        schemaName,
+        tableName: table.name,
+        schemaImport: this.imports.testSpec(src, table.name),
+        cases: casesFor(fields),
+      }),
+      bag({
+        module: this.imports.validatorTestRel("datasource", table.name),
+        imports: this.imports.datasourceValidatorRel(table.name),
+        uses: schemaName,
+      }),
+    );
+  }
+}
+
+/** Returns attributed entries. Cross-lane validator imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return withFakerPackagePatch(
+    new Generator(ctx.settings).from(
+      await DeterministicParser(ctx.reader).parse(ctx.settings),
+    ),
+  );
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-datasource-type-validators.ts

@@ -0,0 +1,191 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  TYPES_YAML,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type IDeterministic,
+  type Type,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { idTypeToZod, toZod, toZodDefault } from "./common/type-converters/native-to-zod.ts";
+import { fieldSize } from "./common/view-shape.ts";
+import { bag, Emit } from "./emit.ts";
+import { indexTmpl, typeTmpl } from "./resources/datasource-type-validators.ts";
+import type { TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+
+type FieldShape = Pick<
+  TypeField,
+  | "name"
+  | "type"
+  | "isNullable"
+  | "references"
+  | "minSize"
+  | "size"
+  | "hasDefault"
+  | "defaultValue"
+>;
+
+const fkTarget = (field: FieldShape): string | undefined => {
+  if (field.references === undefined) return undefined;
+  return Array.isArray(field.references)
+    ? field.references[1]
+    : field.references.split(".")[1];
+};
+
+const tightenString = (base: string, field: FieldShape): string => {
+  let expr = `${base}.trim()`;
+  if (field.minSize !== undefined && field.minSize >= 0) {
+    expr = `${expr}.min(${field.minSize})`;
+  }
+  const max = fieldSize(field);
+  if (max !== undefined && max >= 0) {
+    expr = `${expr}.max(${max})`;
+  }
+  return expr;
+};
+
+const tightenInteger = (
+  base: string,
+  field: FieldShape,
+  { isFk, isIdLike }: { isFk: boolean; isIdLike: boolean },
+): string => {
+  let expr = `${base}.int()`;
+  if (isFk || isIdLike) expr = `${expr}.nonnegative()`;
+  if (field.minSize !== undefined) expr = `${expr}.min(${field.minSize})`;
+  const max = fieldSize(field);
+  if (max !== undefined) expr = `${expr}.max(${max})`;
+  return expr;
+};
+
+const tightenExpr = (field: FieldShape): string => {
+  const base = toZod(field.type);
+  const isFk = fkTarget(field) !== undefined;
+  const isIdLike = field.name === "id" || field.name.endsWith("_id");
+
+  switch (field.type) {
+    case "string":
+    case "character":
+      return tightenString(base, field);
+    case "number":
+    case "integer":
+    case "biginteger":
+    case "smallinteger":
+    case "reference":
+      return tightenInteger(base, field, { isFk, isIdLike });
+    case "float":
+      return field.minSize !== undefined
+        ? `${base}.min(${field.minSize})`
+        : base;
+    default:
+      return base;
+  }
+};
+
+const zodForField = (field: FieldShape, useZodId: boolean): string => {
+  let expr =
+    useZodId || fkTarget(field) === "id"
+      ? idTypeToZod(field.type)
+      : tightenExpr(field);
+  if (field.isNullable) expr = `${expr}.nullable()`;
+  if (field.hasDefault) {
+    expr = `${expr}.default(${toZodDefault(field.type, field.defaultValue)})`;
+  }
+  return expr;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    const types = datasourceTypesOf(deterministic);
+    const entries = types.map((table) => this.validator(table, typesByName));
+    const index = this.imports.index(
+      this.imports.datasourceValidator(types[0]?.name ?? "index"),
+    );
+    if (index && this.settings.createIndex) {
+      entries.push(this.index(types, index));
+    }
+    return entries;
+  }
+
+  private validator(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const fields = persistedColumnFields(table, typesByName).map((field) => {
+      const resolved = { ...field, type: fieldTypeOf(field, typesByName) };
+      return {
+        ident: this.casing.fieldIdent(field.name),
+        zodExpr: zodForField(resolved, field.name === "id"),
+      };
+    });
+    const className = this.casing.convertTypes(table.name);
+    const schemaName = this.casing.schemaName(table.name);
+    const validatedTypeName = this.casing.validatedTypeName(table.name);
+    return content(
+      this.imports.datasourceValidator(table.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        schemaName,
+        className,
+        validatedTypeName,
+        withTypeAnnotation: true,
+        fields,
+      }),
+      bag({
+        module: this.imports.datasourceValidatorRel(table.name),
+        exports: [schemaName, validatedTypeName],
+      }),
+    );
+  }
+
+  private index(
+    types: Type[],
+    index: string,
+  ): GenerateEntry {
+    const modules = types.map((t) => this.imports.datasourceValidatorRel(t.name));
+    const exports = types.flatMap((t) => [
+      this.casing.schemaName(t.name),
+      this.casing.validatedTypeName(t.name),
+    ]);
+    return content(
+      index,
+      fill(indexTmpl, {
+        withTypeAnnotation: true,
+        types: types.map((t) => {
+          const className = this.casing.convertTypes(t.name);
+          return {
+            schemaName: this.casing.schemaName(t.name),
+            className,
+            validatedTypeName: this.casing.validatedTypeName(t.name),
+            fileBase: this.casing.fileBase(t.name),
+          };
+        }),
+      }),
+      bag({
+        module: this.imports
+          .datasourceValidatorRel(types[0]?.name ?? "index")
+          .replace(/[^/]+$/, "index.ts"),
+        exports,
+        imports: modules,
+        uses: exports,
+      }),
+    );
+  }
+}
+
+/** Self-checks references; keeps attributes for host `finalizeEntries` before write. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  const entries = new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  );
+  verifyEntries(entries);
+  return entries;
+};