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

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

@@ -0,0 +1,172 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  isReadonlyLookup,
+  ROUTES_YAML,
+  tableKind
+} 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 {
+  crudTmpl,
+  customStubTmpl,
+  indexTmpl,
+  readonlyTmpl
+} from "./resources/routes.js";
+const customRouteMeta = (entry, casing) => {
+  const className = entry.routeClass ?? casing.convertTypes(entry.name);
+  return {
+    module: entry.module,
+    className,
+    interfaceName: casing.convertTypes(`i_${className}`)
+  };
+};
+class Generator extends Emit {
+  typesByName = /* @__PURE__ */ new Map();
+  from(deterministic) {
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    const parsed = deterministic.routes;
+    const candidates = parsed.candidates.filter(
+      (c) => !isDictionaryCandidate(c)
+    );
+    const entries = [
+      ...candidates.map((c) => this.entityRouter(c)),
+      ...parsed.customs.map((c) => this.custom(c))
+    ];
+    if (this.settings.createIndex) {
+      entries.push(...this.indexes(candidates, parsed.customs));
+    }
+    return entries;
+  }
+  customModuleKey(emitPath) {
+    return customRelKey(emitPath, "routes");
+  }
+  entityRouter(candidate) {
+    const { simpleDoc, descriptionDoc } = this.settings;
+    const entity = candidate.name;
+    const type = this.typesByName.get(entity);
+    const readOnly = type !== void 0 && isReadonlyLookup(type);
+    const fnName = this.casing.routerFnName(entity);
+    return content(
+      this.imports.route(entity),
+      fill(readOnly ? readonlyTmpl : crudTmpl, {
+        simpleDoc,
+        descriptionDoc,
+        fnName,
+        datasourceType: type === void 0 ? "standard" : tableKind(type)
+      }),
+      bag({
+        module: this.imports.routeRel(entity),
+        exports: fnName
+      })
+    );
+  }
+  custom(entry) {
+    const { simpleDoc, descriptionDoc } = this.settings;
+    const { module, className, interfaceName } = customRouteMeta(
+      entry,
+      this.casing
+    );
+    const path = this.imports.routeCustom(entry.name, module);
+    return content(
+      path,
+      fill(customStubTmpl, {
+        simpleDoc,
+        descriptionDoc,
+        interfaceName,
+        className
+      }),
+      bag({
+        module: this.customModuleKey(path),
+        exports: [className, interfaceName]
+      })
+    );
+  }
+  indexes(candidates, customs) {
+    const entries = [];
+    if (candidates.length > 0) {
+      const sorted = [...candidates].sort((a, b) => a.name.localeCompare(b.name));
+      const index = this.imports.index(this.imports.route(sorted[0].name));
+      if (index) {
+        const exports = sorted.map((c) => this.casing.routerFnName(c.name)).join(", ");
+        entries.push(
+          content(
+            index,
+            fill(indexTmpl, {
+              routers: sorted.map((c) => ({
+                fnName: this.casing.routerFnName(c.name),
+                fileBase: this.casing.fileBase(c.name)
+              }))
+            }),
+            bag({
+              module: this.imports.routeRel(sorted[0].name).replace(/[^/]+$/, "index.ts"),
+              exports,
+              imports: sorted.map((c) => this.imports.routeRel(c.name)),
+              uses: exports
+            })
+          )
+        );
+      }
+    }
+    const customDir = customs.filter((e) => {
+      const { module } = customRouteMeta(e, this.casing);
+      return module === void 0 || !module.startsWith(".");
+    });
+    if (customDir.length > 0) {
+      const sorted = [...customDir].sort((a, b) => a.name.localeCompare(b.name));
+      const index = this.imports.index(this.imports.routeCustom(sorted[0].name));
+      if (index) {
+        const exports = sorted.flatMap((e) => {
+          const { className, interfaceName } = customRouteMeta(
+            e,
+            this.casing
+          );
+          return [className, interfaceName];
+        }).join(", ");
+        entries.push(
+          content(
+            index,
+            fill(indexTmpl, {
+              types: sorted.map((e) => {
+                const { className, interfaceName } = customRouteMeta(
+                  e,
+                  this.casing
+                );
+                return {
+                  className,
+                  interfaceName,
+                  fileBase: this.casing.fileBase(`${e.name}_route`)
+                };
+              })
+            }),
+            bag({
+              module: this.customModuleKey(index),
+              exports,
+              imports: sorted.map(
+                (e) => this.customModuleKey(
+                  this.imports.routeCustom(e.name, e.module)
+                )
+              ),
+              uses: exports
+            })
+          )
+        );
+      }
+    }
+    return entries;
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-service-integration-tests.js

@@ -0,0 +1,282 @@
+import {
+  createDatasourceNaming
+} from "@deterministic-code/generators-common/datasource-naming";
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { datasourceTypeAncestry } from "@deterministic-code/generators-common/datasource-type-tree";
+import { toNative } from "./deterministic-type-converter.js";
+import {
+  datasourceTypesOf,
+  isPkField,
+  isReadonlyLookup,
+  pkName,
+  SERVICES_YAML,
+  tableByName,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fieldSize, refParent } from "./common/view-shape.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { genericTmpl } from "./resources/service-integration-tests.js";
+import { createCasing } from "./common/default-casing.js";
+import {
+  fakeTestData,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { bag, Emit } from "./emit.js";
+const SYSTEM_COLUMNS = /* @__PURE__ */ new Set(["id", "uuid", "created", "updated"]);
+const hasStampColumns = (table) => {
+  const names = new Set(table.fields.map((f) => f.name));
+  return names.has("created") && names.has("updated");
+};
+const hasFieldMappings = (overlay) => (overlay?.fields ?? []).some((f) => f.mapping !== void 0);
+const writableScalars = (table, overlay) => table.fields.filter(
+  (field) => !SYSTEM_COLUMNS.has(field.name) && !isPkField(field, table, overlay) && field.references === void 0 && !field.isNullable && field.hasDefault !== true
+);
+const serviceVarName = (className) => {
+  const lowered = `${className.slice(0, 1).toLowerCase()}${className.slice(1)}`;
+  return lowered === className ? `${className}_instance` : lowered;
+};
+class Generator extends Emit {
+  naming;
+  datasources;
+  byName;
+  overlays;
+  viewNames;
+  seeds;
+  spec;
+  constructor(raw, spec) {
+    super(raw);
+    this.spec = spec;
+    this.naming = createDatasourceNaming(raw);
+    this.datasources = datasourceTypesOf(spec);
+    this.byName = new Map(this.datasources.map((t) => [t.name, t]));
+    this.overlays = tableByName(spec);
+    this.viewNames = new Set(viewTypesOf(spec).map((v) => v.name));
+    this.seeds = spec.datasourceSeeds;
+  }
+  from() {
+    return withFakerPackagePatch(
+      this.spec.services.generics.filter((c) => !isDictionaryCandidate(c)).flatMap((c) => {
+        const table = this.byName.get(c.name);
+        if (table === void 0 || hasFieldMappings(this.overlays.get(c.name))) {
+          return [];
+        }
+        return [this.test(table)];
+      })
+    );
+  }
+  mutateView(name) {
+    if (this.viewNames.has(`create_${name}`)) return `create_${name}`;
+    if (this.viewNames.has(`update_${name}`)) return `update_${name}`;
+    return void 0;
+  }
+  tableNameJson(name) {
+    return JSON.stringify(
+      this.naming.resolveTable(name, this.overlays.get(name)?.mapping)
+    );
+  }
+  typeRel(entity) {
+    return this.viewNames.has(entity) ? this.imports.viewRel(entity) : this.imports.datasourceRel(entity);
+  }
+  typeImports(fromRel, entities) {
+    const byPath = /* @__PURE__ */ new Map();
+    const add = (entity) => {
+      const fromPath = this.imports.spec(fromRel, this.typeRel(entity));
+      const typeName = this.casing.convertTypes(entity);
+      const names = byPath.get(fromPath) ?? [];
+      if (!names.includes(typeName)) names.push(typeName);
+      byPath.set(fromPath, names);
+    };
+    for (const name of entities) {
+      add(name);
+      const mutate = this.mutateView(name);
+      if (mutate !== void 0) add(mutate);
+    }
+    return [...byPath.entries()].map(([fromPath, names]) => ({
+      fromPath,
+      names: names.sort().join(", ")
+    })).sort((a, b) => a.fromPath.localeCompare(b.fromPath));
+  }
+  pkEntry(node) {
+    const overlay = this.overlays.get(node.name);
+    const column = pkName(node, overlay);
+    const type = node.fields.find((f) => f.name === column)?.type ?? "integer";
+    return {
+      entityNameJson: JSON.stringify(node.name),
+      columnJson: JSON.stringify(column),
+      pkIdTypeJson: JSON.stringify(type === "uuid" ? "uuid" : "integer"),
+      isUuidPk: type === "uuid",
+      idTsType: toNative(type),
+      pkIdent: this.casing.fieldIdent(column)
+    };
+  }
+  serviceRef(name, entity) {
+    const isSubject = name === entity;
+    const className = this.casing.serviceClassName(name);
+    return {
+      className,
+      serviceVar: isSubject ? "service" : serviceVarName(className),
+      varName: isSubject ? "row" : this.casing.convertFields(name)
+    };
+  }
+  test(table) {
+    const entity = table.name;
+    const pk = this.pkEntry(table);
+    const path = this.imports.serviceIntegrationTest(entity);
+    const stamps = hasStampColumns(table);
+    const className = this.casing.serviceClassName(entity);
+    const chainNames = [
+      ...datasourceTypeAncestry(this.datasources, entity),
+      entity
+    ];
+    const missingLookup = chainNames.find((name) => {
+      const node = this.byName.get(name);
+      return node !== void 0 && isReadonlyLookup(node) && (this.seeds.get(name) ?? []).length === 0;
+    });
+    const isLookup = isReadonlyLookup(table);
+    const chainSupportsStamps = chainNames.every((name) => {
+      const node = this.byName.get(name);
+      return node !== void 0 && (isReadonlyLookup(node) || hasStampColumns(node));
+    });
+    const hierarchy = missingLookup === void 0 && !isLookup && stamps && chainSupportsStamps ? this.hierarchyTokens(entity, chainNames) : false;
+    const mutate = this.mutateView(entity);
+    return content(
+      path,
+      fill(genericTmpl, {
+        prelude: hierarchy ? preludeSource(fakeTestData) : "",
+        className,
+        parentImports: hierarchy === false ? [] : hierarchy.parentImports,
+        typeImports: this.typeImports(
+          this.imports.serviceIntegrationTestRel(entity),
+          chainNames
+        ),
+        serviceImport: this.imports.spec(
+          this.imports.serviceIntegrationTestRel(entity),
+          this.imports.serviceRel(entity)
+        ),
+        rowTypeName: this.casing.convertTypes(entity),
+        createTypeName: mutate === void 0 ? false : this.casing.convertTypes(mutate),
+        tableNameJson: this.tableNameJson(entity),
+        pkEntries: chainNames.flatMap((name) => {
+          const node = this.byName.get(name);
+          return node === void 0 ? [] : [this.pkEntry(node)];
+        }),
+        entityNameJson: JSON.stringify(entity),
+        entityName: entity,
+        idTsType: pk.idTsType,
+        isUuidPk: pk.isUuidPk,
+        missingId: pk.isUuidPk ? JSON.stringify("00000000-0000-0000-0000-000000000000") : "99999",
+        canCreate: hierarchy === false && !isLookup && missingLookup === void 0 && stamps,
+        canUpdate: stamps,
+        hierarchy,
+        missingLookupSeed: missingLookup === void 0 ? false : { lookupName: missingLookup }
+      }),
+      bag({
+        module: this.imports.serviceIntegrationTestRel(entity),
+        imports: this.imports.serviceRel(entity),
+        uses: className
+      })
+    );
+  }
+  hierarchyTokens(entity, chainNames) {
+    const parents = chainNames.filter((name) => name !== entity);
+    const parentImports = parents.map((name) => ({
+      className: this.casing.serviceClassName(name),
+      importPath: this.imports.spec(
+        this.imports.serviceIntegrationTestRel(entity),
+        this.imports.serviceRel(name)
+      )
+    }));
+    const chainServices = parents.map((name) => {
+      const ref = this.serviceRef(name, entity);
+      return {
+        varName: ref.serviceVar,
+        className: ref.className,
+        rowTypeName: this.casing.convertTypes(name),
+        tableNameJson: this.tableNameJson(name),
+        entityNameJson: JSON.stringify(name),
+        isUuidPk: this.pkEntry(this.byName.get(name)).isUuidPk
+      };
+    });
+    const creates = chainNames.map((name) => {
+      const node = this.byName.get(name);
+      const ref = this.serviceRef(name, entity);
+      const mutate = this.mutateView(name);
+      return {
+        isLookup: isReadonlyLookup(node),
+        varName: ref.varName,
+        serviceVar: ref.serviceVar,
+        seedId: (this.seeds.get(name) ?? [])[0]?.id ?? 1,
+        missingSeedErrorJson: JSON.stringify(`expected seeded ${name}`),
+        createTypeName: mutate === void 0 ? false : this.casing.convertTypes(mutate),
+        fields: this.payloadFields(node)
+      };
+    });
+    const writable = chainNames.filter((name) => {
+      const node = this.byName.get(name);
+      return node !== void 0 && !isReadonlyLookup(node);
+    });
+    const updates = [...writable].reverse().map((name) => {
+      const node = this.byName.get(name);
+      const ref = this.serviceRef(name, entity);
+      return {
+        serviceVar: ref.serviceVar,
+        varName: ref.varName,
+        updatedVarName: `${ref.varName}Updated`,
+        pkIdent: this.pkEntry(node).pkIdent,
+        fields: this.scalarFields(node)
+      };
+    });
+    const deletes = [...writable].reverse().map((name) => {
+      const node = this.byName.get(name);
+      const ref = this.serviceRef(name, entity);
+      return {
+        serviceVar: ref.serviceVar,
+        varName: ref.varName,
+        pkIdent: this.pkEntry(node).pkIdent
+      };
+    });
+    return { parentImports, chainServices, creates, updates, deletes };
+  }
+  scalarFields(table) {
+    return writableScalars(table, this.overlays.get(table.name)).map(
+      (field) => ({
+        ident: this.casing.fieldIdent(field.name),
+        expr: fieldExpr(fakeTestData, field.type, {
+          nativeType: toNative(field.type),
+          size: fieldSize(field)
+        })
+      })
+    );
+  }
+  payloadFields(table) {
+    const fks = table.fields.flatMap((field) => {
+      const parentName = refParent(field);
+      if (parentName === void 0 || !this.byName.has(parentName)) return [];
+      const parent = this.byName.get(parentName);
+      return [
+        {
+          ident: this.casing.fieldIdent(field.name),
+          expr: `${this.casing.convertFields(parentName)}.${this.pkEntry(parent).pkIdent}`
+        }
+      ];
+    });
+    return [...fks, ...this.scalarFields(table)];
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const casing = createCasing(ctx.settings);
+  const spec = await DeterministicParser(ctx.reader).parse(ctx.settings, {
+    serviceClassName: (entity) => casing.serviceClassName(entity)
+  });
+  return new Generator(ctx.settings, spec).from();
+};
+export {
+  generate
+};

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

@@ -0,0 +1,80 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  identityColumns,
+  SERVICES_YAML,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  asIdType,
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { genericTmpl } from "./resources/service-tests.js";
+import { createCasing } from "./common/default-casing.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { bag, Emit } from "./emit.js";
+class Generator extends Emit {
+  types;
+  tables;
+  constructor(raw, types, tables) {
+    super(raw);
+    this.types = types;
+    this.tables = tables;
+  }
+  from(deterministic) {
+    return deterministic.services.generics.filter((c) => !isDictionaryCandidate(c)).map((c) => this.test(c));
+  }
+  test(candidate) {
+    const table = this.types.find((d) => d.name === candidate.name);
+    const overlay = this.tables.get(candidate.name);
+    const columns = table !== void 0 ? identityColumns(table, overlay) : ["id"];
+    const keys = (columns.length > 0 ? columns : ["id"]).map((column) => {
+      const pkType = table?.fields.find((f) => f.name === column)?.type ?? "integer";
+      return { column, pkType };
+    });
+    const idExpr = keys.length === 1 ? fakeTestData.id(asIdType(keys[0].pkType)) : `{ ${keys.map((k) => `${k.column}: ${fakeTestData.id(asIdType(k.pkType))}`).join(", ")} }`;
+    const src = this.imports.service(candidate.name);
+    const path = this.imports.serviceTest(candidate.name);
+    const fileBase = `${candidate.name}_service`;
+    const className = this.casing.serviceClassName(candidate.name);
+    return content(
+      path,
+      fill(genericTmpl, {
+        prelude: preludeSource(fakeTestData),
+        className,
+        importPath: this.imports.testSpec(src, fileBase),
+        entityNameJson: JSON.stringify(candidate.name),
+        idExpr
+      }),
+      bag({
+        module: this.imports.serviceTestRel(candidate.name),
+        imports: this.imports.serviceRel(candidate.name),
+        uses: className
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const casing = createCasing(ctx.settings);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings,
+    { serviceClassName: (entity) => casing.serviceClassName(entity) }
+  );
+  return withFakerPackagePatch(
+    new Generator(
+      ctx.settings,
+      datasourceTypesOf(deterministic),
+      tableByName(deterministic)
+    ).from(deterministic)
+  );
+};
+export {
+  generate
+};