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

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

@@ -0,0 +1,287 @@
+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 {
+  SERVICES_YAML,
+  identityColumns,
+  tableByName,
+  tableKind,
+  typeHasTag,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type CustomServiceEntry,
+  type DatasourceTable,
+  type IDeterministic,
+  type ServiceCandidate,
+  type Type,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.ts";
+import { bag, customRelKey, Emit } from "./emit.ts";
+import {
+  customStubTmpl,
+  genericTmpl,
+  indexTmpl,
+} from "./resources/services.ts";
+
+class Generator extends Emit {
+  private viewNames = new Set<string>();
+  private tables = new Map<string, DatasourceTable>();
+
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.tables = tableByName(deterministic);
+    this.viewNames = new Set(viewTypesOf(deterministic).map((view) => view.name));
+    const customs = deterministic.services.customs;
+    const generics = deterministic.services.generics.filter(
+      (c) => !isDictionaryCandidate(c),
+    );
+    const entries: GenerateEntry[] = [
+      ...generics.map((c) => this.generic(c, typesByName.get(c.name))),
+      ...customs.map((c) => this.custom(c)),
+    ];
+    if (this.settings.createIndex) {
+      entries.push(...this.indexes(generics, customs));
+    }
+    return entries;
+  }
+
+  private isDatasource(type: Type | undefined): boolean {
+    return type !== undefined && typeHasTag(type, "datasource_type");
+  }
+
+  private typeModule(candidate: ServiceCandidate, type: Type | undefined): string {
+    return this.isDatasource(type)
+      ? this.imports.datasourceRel(candidate.name)
+      : this.imports.viewRel(candidate.name);
+  }
+
+  private mutateView(name: string): string | undefined {
+    if (this.viewNames.has(`create_${name}`)) return `create_${name}`;
+    if (this.viewNames.has(`update_${name}`)) return `update_${name}`;
+    return undefined;
+  }
+
+  private identity(type: Type | undefined, name: string): string[] {
+    const cols = identityColumns(type, this.tables.get(type?.name ?? name));
+    return cols.length > 0 ? cols : ["id"];
+  }
+
+  private pkColumn(type: Type | undefined, name: string): string {
+    return this.identity(type, name)[0] ?? "id";
+  }
+
+  private fieldIdTs(type: Type | undefined, column: string): string {
+    const field = type?.fields.find((f) => f.name === column);
+    if (field === undefined) return "number";
+    return toNative(typeof field.type === "string" ? field.type : "integer") ===
+      "number"
+      ? "number"
+      : "string";
+  }
+
+  private idTsType(type: Type | undefined, name: string): string {
+    const columns = this.identity(type, name);
+    if (columns.length <= 1) return this.fieldIdTs(type, columns[0] ?? "id");
+    return `{ ${columns.map((c) => `${c}: ${this.fieldIdTs(type, c)}`).join("; ")} }`;
+  }
+
+  private generic(
+    candidate: ServiceCandidate,
+    type: Type | undefined,
+  ): GenerateEntry {
+    const { simpleDoc, descriptionDoc } = this.settings;
+    const typeName = this.casing.convertTypes(candidate.name);
+    const className = this.casing.serviceClassName(candidate.name);
+    const interfaceName = this.casing.serviceInterfaceName(candidate.name);
+    const generatePath = this.imports.service(candidate.name);
+    const module = this.imports.serviceRel(candidate.name);
+    const typeModule = this.typeModule(candidate, type);
+    const typeImportPath = this.imports.spec(
+      this.imports.serviceRel(candidate.name),
+      this.isDatasource(type)
+        ? this.imports.datasourceRel(candidate.name)
+        : this.imports.viewRel(candidate.name),
+    );
+    const mutate = this.mutateView(candidate.name);
+    const mutateTypeName =
+      mutate === undefined ? false : this.casing.convertTypes(mutate);
+    const mutateModule =
+      mutate === undefined ? undefined : this.imports.viewRel(mutate);
+    const mutateImport =
+      mutate === undefined || mutateModule === undefined
+        ? false
+        : {
+            mutateTypeName,
+            mutateImportPath: this.imports.spec(
+              this.imports.serviceRel(candidate.name),
+              mutateModule,
+            ),
+          };
+    return content(
+      generatePath,
+      fill(genericTmpl, {
+        simpleDoc,
+        descriptionDoc,
+        typeImport: true,
+        typeName,
+        typeImportPath,
+        mutateTypeName,
+        mutateImport,
+        interfaceName,
+        className,
+        idTsType: this.idTsType(type, candidate.name),
+        pkField: this.casing.convertFields(this.pkColumn(type, candidate.name)),
+        pkOmit: this.identity(type, candidate.name)
+          .map((c) => `"${c}"`)
+          .join(" | "),
+        datasourceType: type === undefined ? "standard" : tableKind(type),
+        finders: candidate.byFields
+          .filter((bf) => !this.identity(type, candidate.name).includes(bf.field))
+          .map((bf) => ({
+            method: this.casing.finderMethod(bf.field),
+            param: this.casing.fieldIdent(bf.field),
+            paramType: toNative(bf.type),
+            field: this.casing.convertFields(bf.field),
+            typeName,
+          })),
+      }),
+      bag({
+        module,
+        exports: [className, interfaceName],
+        imports: [typeModule, mutateModule].filter(
+          (value): value is string => value !== undefined,
+        ),
+        uses: [typeName, mutateTypeName === false ? undefined : mutateTypeName].filter(
+          (value): value is string => value !== undefined,
+        ),
+      }),
+    );
+  }
+
+  /** Map emit paths like `../custom/foo.ts` to Rel keys `services/custom/foo.ts`. */
+  private customModuleKey(emitPath: string): string {
+    return customRelKey(emitPath, "services");
+  }
+
+  private custom(entry: CustomServiceEntry): GenerateEntry {
+    const { simpleDoc, descriptionDoc } = this.settings;
+    const className = entry.name;
+    const interfaceName = this.casing.authoredInterfaceName(entry.name);
+    const path = this.imports.serviceCustom(entry.name, entry.module);
+    return content(
+      path,
+      fill(customStubTmpl, {
+        simpleDoc,
+        descriptionDoc,
+        interfaceName,
+        className,
+        hasMethods: entry.methods.length > 0,
+        methods: entry.methods.map((name) => ({ name })),
+      }),
+      bag({
+        module: this.customModuleKey(path),
+        exports: [className, interfaceName],
+      }),
+    );
+  }
+
+  private indexes(
+    generics: ServiceCandidate[],
+    customs: CustomServiceEntry[],
+  ): GenerateEntry[] {
+    const entries: GenerateEntry[] = [];
+    if (generics.length > 0) {
+      const sorted = [...generics].sort((a, b) =>
+        this.casing.serviceClassName(a.name).localeCompare(
+          this.casing.serviceClassName(b.name),
+        ),
+      );
+      const index = this.imports.index(this.imports.service(sorted[0]!.name));
+      if (index) {
+        const exports = sorted
+          .flatMap((c) => [
+            this.casing.serviceClassName(c.name),
+            this.casing.serviceInterfaceName(c.name),
+          ])
+          .join(", ");
+        entries.push(
+          content(
+            index,
+            fill(indexTmpl, {
+              types: sorted.map((c) => ({
+                className: this.casing.serviceClassName(c.name),
+                interfaceName: this.casing.serviceInterfaceName(c.name),
+                fileBase: this.casing.fileBase(`${c.name}_service`),
+              })),
+            }),
+            bag({
+              module: this.imports
+                .serviceRel(sorted[0]!.name)
+                .replace(/[^/]+$/, "index.ts"),
+              exports,
+              imports: sorted.map((c) => this.imports.serviceRel(c.name)),
+              uses: exports,
+            }),
+          ),
+        );
+      }
+    }
+    const customDirEntries = customs.filter(
+      (e) => !e.module || !e.module.startsWith("."),
+    );
+    if (customDirEntries.length > 0) {
+      const sorted = [...customDirEntries].sort((a, b) =>
+        a.name.localeCompare(b.name),
+      );
+      const index = this.imports.index(this.imports.serviceCustom(sorted[0]!.name));
+      if (index) {
+        const exports = sorted
+          .flatMap((e) => [
+            e.name,
+            this.casing.authoredInterfaceName(e.name),
+          ])
+          .join(", ");
+        const modules = sorted.map((e) =>
+          this.customModuleKey(this.imports.serviceCustom(e.name, e.module)),
+        );
+        entries.push(
+          content(
+            index,
+            fill(indexTmpl, {
+              types: sorted.map((e) => ({
+                className: e.name,
+                interfaceName: this.casing.authoredInterfaceName(e.name),
+                fileBase: this.casing.fileBase(e.name),
+              })),
+            }),
+            bag({
+              module: this.customModuleKey(index),
+              exports,
+              imports: modules,
+              uses: exports,
+            }),
+          ),
+        );
+      }
+    }
+    return entries;
+  }
+}
+
+/** Returns attributed entries. Cross-lane type imports need host `finalizeEntries` with views/datasource entries. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity),
+    }),
+  );
+};

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

@@ -0,0 +1,233 @@
+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,
+  TYPES_YAML,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type IDeterministic,
+  type Type,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch,
+} from "./common/fake-test-data.ts";
+import { typeTestTmpl } from "./resources/view-type-validators-tests.ts";
+import {
+  escapeTestName,
+  flattenNodes,
+  renderMutatedObject,
+  renderObject,
+  shapedViewNodes,
+  type ShapeNode,
+  type ShapeOpts,
+} from "./common/view-test-shape.ts";
+import { bag, Emit } from "./emit.ts";
+
+type CaseTok = {
+  name: string;
+  fixture: string;
+  assertion: string;
+};
+
+const MUTABLE_SCALAR = new Set([
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "reference",
+  "binary",
+]);
+
+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 mutationCases = (
+  roots: ShapeNode[],
+  targets: ShapeNode[],
+  { inherited = false } = {},
+): CaseTok[] => {
+  const cases: CaseTok[] = [];
+  for (const field of targets) {
+    const missingPrefix = inherited
+      ? "missing inherited required field"
+      : "missing required field";
+    const nullPrefix = inherited
+      ? "null for non-nullable inherited field"
+      : "null for non-nullable field";
+    // A sample map key is not a required property; an empty record is valid.
+    if (!field.mapEntry && !field.nullable && !field.hasDefault) {
+      cases.push({
+        name: escapeTestName(
+          `rejects when ${missingPrefix} "${field.path}"`,
+        ),
+        fixture: renderMutatedObject(roots, field, "omit"),
+        assertion: "toThrow",
+      });
+      cases.push({
+        name: escapeTestName(
+          `rejects when ${nullPrefix} "${field.path}"`,
+        ),
+        fixture: renderMutatedObject(roots, field, "null"),
+        assertion: "toThrow",
+      });
+      if (inherited) break;
+    }
+    if (inherited) continue;
+    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.path}"`,
+          ),
+          fixture: renderMutatedObject(roots, field, bad),
+          assertion: "toThrow",
+        });
+      }
+    }
+  }
+  return cases;
+};
+
+class Generator extends Emit implements ShapeOpts {
+  readonly tables: ShapeOpts["tables"];
+  readonly views: ShapeOpts["views"];
+  readonly typesByName: ShapeOpts["typesByName"];
+  readonly referenceBackendType: boolean;
+
+  constructor(
+    raw: Record<string, string>,
+    basePath: string,
+    deterministic: IDeterministic,
+    referenceBackendType: boolean,
+  ) {
+    super(raw, basePath);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t]),
+    );
+    this.views = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.referenceBackendType = referenceBackendType;
+  }
+
+  from(): GenerateEntry[] {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+
+  private shapedCases(view: Type): CaseTok[] {
+    const fields = shapedViewNodes(view, this);
+    const declared = view.fields.map((declaredField) => {
+      const node = fields.find((f) => f.name === declaredField.name);
+      if (node === undefined) {
+        throw new Error(`missing shaped field ${declaredField.name}`);
+      }
+      return node;
+    });
+    const cases: CaseTok[] = [
+      {
+        name: "parses a valid payload",
+        fixture: renderObject(fields),
+        assertion: "not.toThrow",
+      },
+    ];
+    if (fields.some((f) => f.nullable)) {
+      cases.push({
+        name: "accepts null for nullable fields",
+        fixture: renderObject(
+          fields.map((f) =>
+            f.nullable
+              ? {
+                  ...f,
+                  isObject: false,
+                  isPrimitive: true,
+                  isArray: false,
+                  expr: "null",
+                  nested: [],
+                }
+              : f,
+          ),
+        ),
+        assertion: "not.toThrow",
+      });
+    }
+    const inheritedMutation = fields.find(
+      (f) =>
+        !declared.some((d) => d.name === f.name) &&
+        !f.nullable &&
+        !f.hasDefault,
+    );
+    if (inheritedMutation !== undefined) {
+      cases.push(
+        ...mutationCases(fields, [inheritedMutation], { inherited: true }),
+      );
+    }
+    cases.push(...mutationCases(fields, flattenNodes(declared)));
+    return cases;
+  }
+
+  private tests(view: Type): GenerateEntry {
+    const src = this.imports.viewValidator(view.name);
+    const schemaName = this.casing.schemaName(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        prelude: preludeSource(fakeTestData),
+        schemaVersion: this.settings.schemaVersion,
+        schemaName,
+        viewName: view.name,
+        schemaImport: this.imports.testSpec(src, view.name),
+        cases: this.shapedCases(view),
+      }),
+      bag({
+        module: this.imports.validatorTestRel("view", view.name),
+        imports: this.imports.viewValidatorRel(view.name),
+        uses: schemaName,
+      }),
+    );
+  }
+}
+
+/** Returns attributed entries. Cross-lane validator imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+  basePath = ".",
+  referenceBackendType = true,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings,
+  );
+  return withFakerPackagePatch(
+    new Generator(
+      ctx.settings,
+      basePath,
+      deterministic,
+      referenceBackendType,
+    ).from(),
+    basePath === "." || basePath === "" ? "package.json" : "frontend/package.json",
+  );
+};