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

package/node_modules/@deterministic-code/typescript-generators/dist/generate-services.js

@@ -0,0 +1,239 @@
+import { toNative } from "./deterministic-type-converter.js";
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  SERVICES_YAML,
+  identityColumns,
+  tableByName,
+  tableKind,
+  typeHasTag,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { bag, customRelKey, Emit } from "./emit.js";
+import {
+  customStubTmpl,
+  genericTmpl,
+  indexTmpl
+} from "./resources/services.js";
+class Generator extends Emit {
+  viewNames = /* @__PURE__ */ new Set();
+  tables = /* @__PURE__ */ new Map();
+  from(deterministic) {
+    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 = [
+      ...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;
+  }
+  isDatasource(type) {
+    return type !== void 0 && typeHasTag(type, "datasource_type");
+  }
+  typeModule(candidate, type) {
+    return this.isDatasource(type) ? this.imports.datasourceRel(candidate.name) : this.imports.viewRel(candidate.name);
+  }
+  mutateView(name) {
+    if (this.viewNames.has(`create_${name}`)) return `create_${name}`;
+    if (this.viewNames.has(`update_${name}`)) return `update_${name}`;
+    return void 0;
+  }
+  identity(type, name) {
+    const cols = identityColumns(type, this.tables.get(type?.name ?? name));
+    return cols.length > 0 ? cols : ["id"];
+  }
+  pkColumn(type, name) {
+    return this.identity(type, name)[0] ?? "id";
+  }
+  fieldIdTs(type, column) {
+    const field = type?.fields.find((f) => f.name === column);
+    if (field === void 0) return "number";
+    return toNative(typeof field.type === "string" ? field.type : "integer") === "number" ? "number" : "string";
+  }
+  idTsType(type, name) {
+    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("; ")} }`;
+  }
+  generic(candidate, type) {
+    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 === void 0 ? false : this.casing.convertTypes(mutate);
+    const mutateModule = mutate === void 0 ? void 0 : this.imports.viewRel(mutate);
+    const mutateImport = mutate === void 0 || mutateModule === void 0 ? 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 === void 0 ? "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 !== void 0
+        ),
+        uses: [typeName, mutateTypeName === false ? void 0 : mutateTypeName].filter(
+          (value) => value !== void 0
+        )
+      })
+    );
+  }
+  /** Map emit paths like `../custom/foo.ts` to Rel keys `services/custom/foo.ts`. */
+  customModuleKey(emitPath) {
+    return customRelKey(emitPath, "services");
+  }
+  custom(entry) {
+    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]
+      })
+    );
+  }
+  indexes(generics, customs) {
+    const entries = [];
+    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;
+  }
+}
+const generate = async (ctx) => {
+  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)
+    })
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-view-type-validators-tests.js

@@ -0,0 +1,192 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  TYPES_YAML,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { typeTestTmpl } from "./resources/view-type-validators-tests.js";
+import {
+  escapeTestName,
+  flattenNodes,
+  renderMutatedObject,
+  renderObject,
+  shapedViewNodes
+} from "./common/view-test-shape.js";
+import { bag, Emit } from "./emit.js";
+const MUTABLE_SCALAR = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "reference",
+  "binary"
+]);
+const wrongTypeExpr = (type) => {
+  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 void 0;
+  }
+};
+const mutationCases = (roots, targets, { inherited = false } = {}) => {
+  const cases = [];
+  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";
+    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 !== void 0) {
+        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 {
+  tables;
+  views;
+  typesByName;
+  referenceBackendType;
+  constructor(raw, basePath, deterministic, referenceBackendType) {
+    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() {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+  shapedCases(view) {
+    const fields = shapedViewNodes(view, this);
+    const declared = view.fields.map((declaredField) => {
+      const node = fields.find((f) => f.name === declaredField.name);
+      if (node === void 0) {
+        throw new Error(`missing shaped field ${declaredField.name}`);
+      }
+      return node;
+    });
+    const cases = [
+      {
+        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 !== void 0) {
+      cases.push(
+        ...mutationCases(fields, [inheritedMutation], { inherited: true })
+      );
+    }
+    cases.push(...mutationCases(fields, flattenNodes(declared)));
+    return cases;
+  }
+  tests(view) {
+    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
+      })
+    );
+  }
+}
+const generate = async (ctx, basePath = ".", referenceBackendType = true) => {
+  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"
+  );
+};
+export {
+  generate
+};