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

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

@@ -0,0 +1,308 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  isCollectionField,
+  TYPES_YAML,
+  typeHasTag,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  fieldRefKind,
+  fieldsBeyondParent,
+  fieldSize,
+  isAlias
+} from "./common/view-shape.js";
+import { toZod } from "./common/type-converters/native-to-zod.js";
+import { bag, Emit } from "./emit.js";
+import {
+  indexTmpl as defaultIndexTmpl,
+  schemaInheritTmpl as defaultSchemaInheritTmpl,
+  schemaStandaloneTmpl as defaultSchemaStandaloneTmpl,
+  schemaUnionTmpl as defaultSchemaUnionTmpl,
+  typeTmpl as defaultTypeTmpl
+} from "./resources/view-type-validators.js";
+const omitObj = (keys) => keys.map((k) => `${JSON.stringify(k)}: true`).join(", ");
+const WRITE_PREFIXES = ["update_", "create_"];
+const isWriteVariant = (name) => WRITE_PREFIXES.some((prefix) => name.startsWith(prefix));
+const BUILTIN_PARENTS = /* @__PURE__ */ new Set(["set", "dictionary", "file"]);
+const isBuiltinInherit = (view) => view.inherits !== void 0 && BUILTIN_PARENTS.has(view.inherits);
+const tighten = (field) => {
+  const base = toZod(field.base);
+  const max = fieldSize(field);
+  switch (field.base) {
+    case "string":
+    case "character": {
+      let expr = `${base}.trim()`;
+      if (field.minSize !== void 0 && field.minSize >= 0) expr += `.min(${field.minSize})`;
+      if (max !== void 0 && max >= 0) expr += `.max(${max})`;
+      return expr;
+    }
+    case "number":
+    case "integer":
+    case "biginteger":
+    case "smallinteger":
+    case "reference": {
+      let expr = `${base}.int()`;
+      if (field.name === "id" || field.name.endsWith("_id")) expr += ".nonnegative()";
+      if (field.minSize !== void 0) expr += `.min(${field.minSize})`;
+      if (max !== void 0) expr += `.max(${max})`;
+      return expr;
+    }
+    default:
+      return base;
+  }
+};
+const indexExports = (view, schemaName) => {
+  const schema = schemaName(view.name);
+  if (isWriteVariant(view.name)) return schema;
+  if ((view.removeFields?.length ?? 0) > 0) return void 0;
+  if (isAlias(view) || view.inherits !== void 0) return schema;
+  return [
+    schema,
+    schemaName(`create_${view.name}`),
+    schemaName(`update_${view.name}`),
+    schemaName(`patch_${view.name}`)
+  ].join(", ");
+};
+class Generator extends Emit {
+  referenceBackendType;
+  templates;
+  parentFieldsByName = /* @__PURE__ */ new Map();
+  typesByName = /* @__PURE__ */ new Map();
+  constructor(raw, mode) {
+    super(raw, mode.basePath ?? ".", mode.datasourceBasePath ?? ".");
+    this.referenceBackendType = mode.referenceBackendType ?? true;
+    this.templates = mode.templates ?? {
+      typeTmpl: defaultTypeTmpl,
+      indexTmpl: defaultIndexTmpl,
+      schemaUnionTmpl: defaultSchemaUnionTmpl,
+      schemaStandaloneTmpl: defaultSchemaStandaloneTmpl,
+      schemaInheritTmpl: defaultSchemaInheritTmpl
+    };
+  }
+  from(deterministic) {
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.parentFieldsByName = new Map(
+      datasourceTypesOf(deterministic).map((table) => [
+        table.name,
+        new Set(table.fields.map((field) => field.name))
+      ])
+    );
+    const expandedByName = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+    const views = authoredViewTypesOf(deterministic);
+    const entries = views.map((view) => {
+      const collected = this.collectImports(view, expandedByName.get(view.name));
+      const schemaName = this.casing.schemaName(view.name);
+      const validatedTypeName = this.casing.validatedTypeName(view.name);
+      return content(
+        this.imports.viewValidator(view.name),
+        fill(this.templates.typeTmpl, {
+          schemaVersion: this.settings.schemaVersion,
+          imports: collected.imports,
+          schemaBody: this.schemaBody(view, expandedByName.get(view.name)),
+          withTypeAnnotation: true,
+          className: this.casing.convertTypes(view.name),
+          schemaName,
+          validatedTypeName
+        }),
+        bag({
+          module: this.imports.viewValidatorRel(view.name),
+          exports: this.fileExports(view, schemaName, validatedTypeName),
+          imports: collected.importRels,
+          uses: collected.useNames
+        })
+      );
+    });
+    const index = this.imports.index(
+      this.imports.viewValidator(views[0]?.name ?? "index")
+    );
+    if (index && this.settings.createIndex) {
+      const indexed = views.flatMap((view) => {
+        const exports = indexExports(
+          view,
+          (name) => this.casing.schemaName(name)
+        );
+        if (exports === void 0) return [];
+        return [{
+          view,
+          exports,
+          className: this.casing.convertTypes(view.name),
+          validatedTypeName: this.casing.validatedTypeName(view.name),
+          fileBase: this.casing.fileBase(view.name)
+        }];
+      });
+      const exportNames = indexed.flatMap((row) => [
+        ...row.exports.split(", ").filter((name) => name.length > 0),
+        row.validatedTypeName
+      ]);
+      entries.push(
+        content(
+          index,
+          fill(this.templates.indexTmpl, {
+            withTypeAnnotation: true,
+            types: indexed
+          }),
+          bag({
+            module: this.imports.viewValidatorRel(views[0]?.name ?? "index").replace(/[^/]+$/, "index.ts"),
+            exports: exportNames,
+            imports: indexed.map(
+              (row) => this.imports.viewValidatorRel(row.view.name)
+            ),
+            uses: exportNames
+          })
+        )
+      );
+    }
+    return entries;
+  }
+  zodForField(field) {
+    const dict = dictionaryOfField(field, this.typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    if (entry !== void 0) {
+      const part = (f) => fieldRefKind(f, this.typesByName) === "primitive" ? toZod(f.base) : this.zodPart(f);
+      let expr2 = `z.record(${part(entry.key)}, ${part(entry.value)})`;
+      if (field.isNullable) expr2 += ".nullable()";
+      return expr2;
+    }
+    let expr = this.zodPart(field);
+    if (field.isArray) expr = `z.array(${expr})`;
+    if (field.isNullable) expr += ".nullable()";
+    return expr;
+  }
+  zodPart(field) {
+    const refKind = fieldRefKind(field, this.typesByName);
+    if (refKind === "primitive") return tighten(field);
+    const nested = refKind === "datasource" && this.referenceBackendType ? this.casing.schemaName(`datasource_${field.base}`) : this.casing.schemaName(field.base);
+    return `z.lazy(() => ${nested})`;
+  }
+  collectImports(view, expanded) {
+    const byPath = /* @__PURE__ */ new Map();
+    const refs = [];
+    const parentName = isAlias(view) ? view.name : view.inherits;
+    if (this.referenceBackendType && parentName !== void 0 && (isAlias(view) || !isBuiltinInherit(view))) {
+      const parent = this.typesByName.get(parentName);
+      if (isAlias(view) || parent !== void 0 && typeHasTag(parent, "datasource_type")) {
+        refs.push({ entity: parentName, kind: "datasource" });
+      }
+    }
+    const fields = expanded?.fields ?? view.fields;
+    for (const f of fields) {
+      const mapped = dictionaryOfField(f, this.typesByName);
+      const entry = mapped === void 0 ? void 0 : dictionaryEntryFields(mapped);
+      const target = entry?.value ?? f;
+      const refKind = fieldRefKind(target, this.typesByName);
+      if (refKind === "primitive") continue;
+      refs.push({
+        entity: target.base,
+        kind: !this.referenceBackendType && refKind === "datasource" ? "view" : refKind
+      });
+    }
+    const importRels = [];
+    const useNames = [];
+    for (const { entity, kind } of refs) {
+      if (kind === "view" && entity === view.name) continue;
+      const destRel = kind === "datasource" ? this.datasourceImports.datasourceValidatorRel(entity) : this.imports.viewValidatorRel(entity);
+      const fromPath = this.imports.spec(
+        this.imports.viewValidatorRel(view.name),
+        destRel
+      );
+      const schemaName = this.casing.schemaName(entity);
+      const token = kind === "datasource" ? `${schemaName} as ${this.casing.schemaName(`datasource_${entity}`)}` : schemaName;
+      const set = byPath.get(fromPath) ?? /* @__PURE__ */ new Set();
+      set.add(token);
+      byPath.set(fromPath, set);
+      if (!importRels.includes(destRel)) importRels.push(destRel);
+      if (!useNames.includes(schemaName)) useNames.push(schemaName);
+    }
+    return {
+      imports: [...byPath.entries()].map(([fromPath, tokens]) => ({
+        fromPath,
+        names: [...tokens].sort().join(", ")
+      })).sort((a, b) => a.fromPath.localeCompare(b.fromPath)),
+      importRels,
+      useNames
+    };
+  }
+  fileExports(view, schemaName, validatedTypeName) {
+    const names = [schemaName, validatedTypeName];
+    if (isWriteVariant(view.name)) return names;
+    if ((view.removeFields?.length ?? 0) > 0) return names;
+    const parentName = isAlias(view) ? view.name : view.inherits;
+    const inheritBackend = this.referenceBackendType && parentName !== void 0 && (isAlias(view) || !isBuiltinInherit(view));
+    if (inheritBackend) return names;
+    return [
+      schemaName,
+      this.casing.schemaName(`create_${view.name}`),
+      this.casing.schemaName(`update_${view.name}`),
+      this.casing.schemaName(`patch_${view.name}`),
+      validatedTypeName
+    ];
+  }
+  fieldTokens(fields) {
+    return fields.map((f) => ({
+      ident: this.casing.fieldIdent(f.name),
+      zodExpr: this.zodForField(f)
+    }));
+  }
+  schemaBody(view, expanded) {
+    const schemaName = this.casing.schemaName(view.name);
+    const t = {
+      create: this.casing.schemaName(`create_${view.name}`),
+      update: this.casing.schemaName(`update_${view.name}`),
+      patch: this.casing.schemaName(`patch_${view.name}`)
+    };
+    const parentName = isAlias(view) ? view.name : view.inherits;
+    const inheritBackend = this.referenceBackendType && parentName !== void 0 && (isAlias(view) || !isBuiltinInherit(view));
+    const inlineFields = expanded?.fields ?? view.fields;
+    const parentType = parentName === void 0 ? void 0 : this.typesByName.get(parentName);
+    const fields = [
+      ...this.fieldTokens(
+        inheritBackend && isAlias(view) ? inlineFields.filter(isCollectionField) : inheritBackend ? fieldsBeyondParent(inlineFields, parentType) : inlineFields
+      )
+    ];
+    if (!inheritBackend || parentName === void 0) {
+      return fill(this.templates.schemaStandaloneTmpl, {
+        schemaName,
+        emptyObject: fields.length === 0,
+        fields,
+        hasTrio: (view.removeFields?.length ?? 0) === 0,
+        createName: t.create,
+        updateName: t.update,
+        patchName: t.patch
+      }).trimEnd();
+    }
+    const parent = parentName;
+    const parentFields = this.parentFieldsByName.get(parent) ?? /* @__PURE__ */ new Set();
+    const onParent = (keys) => keys.filter((k) => parentFields.has(k));
+    const omits = onParent(view.removeFields ?? []);
+    return fill(this.templates.schemaInheritTmpl, {
+      schemaName,
+      dsAlias: this.casing.schemaName(`datasource_${parent}`),
+      hasOmits: omits.length > 0,
+      omitObj: omitObj(omits.map((k) => this.casing.convertFields(k))),
+      partialId: parentFields.has("id") && omits.length > 0 && !omits.includes("id"),
+      hasFields: fields.length > 0,
+      fields
+    }).trimEnd();
+  }
+}
+const generate = async (ctx, mode = {}) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings, mode).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

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

@@ -0,0 +1,101 @@
+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 {
+  fieldTestsTmpl,
+  typeTestTmpl
+} from "./resources/view-types-tests.js";
+import {
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import {
+  renderObject,
+  renderValue,
+  shapedViewNodes
+} from "./common/view-test-shape.js";
+import { bag, Emit } from "./emit.js";
+const renderFieldTests = (node, className) => fill(fieldTestsTmpl, {
+  className,
+  testName: node.testName,
+  ident: node.ident,
+  access: node.access,
+  sampleExpr: renderValue(node),
+  nextExpr: renderValue(node),
+  nullable: node.nullable,
+  isRoot: node.isRoot,
+  nestedTests: node.nested.map((child) => renderFieldTests(child, className)).join("")
+}).trimEnd() + "\n\n";
+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));
+  }
+  tests(view) {
+    const fields = shapedViewNodes(view, this);
+    const src = this.imports.view(view.name);
+    const className = this.casing.convertTypes(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        prelude: preludeSource(fakeTestData),
+        schemaVersion: this.settings.schemaVersion,
+        className,
+        viewName: view.name,
+        typeImport: this.imports.testSpec(src, view.name),
+        isShaped: true,
+        isUnion: false,
+        fixture: fields.length === 0 ? "{}" : renderObject(fields),
+        fieldTests: fields.map((field) => renderFieldTests(field, className)).join(""),
+        members: []
+      }),
+      bag({
+        module: this.imports.viewTestRel(view.name),
+        imports: this.imports.viewRel(view.name),
+        uses: className
+      })
+    );
+  }
+}
+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
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-view-types.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+export declare const generate: (ctx: GenerateContext) => Promise<GenerateEntry[]>;

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

@@ -0,0 +1,5 @@
+import { generateViewTypes } from "./emit-shaped-types.js";
+const generate = async (ctx) => generateViewTypes(ctx);
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/import-generator.js

@@ -0,0 +1,241 @@
+import { posix } from "node:path";
+import { createCasing } from "./common/default-casing.js";
+const importSpec = (fromFile, toFile) => {
+  const toNoExt = toFile.endsWith(".ts") ? toFile.slice(0, -3) : toFile;
+  const rel = posix.relative(posix.dirname(fromFile), toNoExt);
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+const modulePathParts = (mod) => {
+  const parts = mod.split("/").filter((p) => p !== "" && p !== ".");
+  while (parts.length && parts[0] === "..") parts.shift();
+  return parts;
+};
+class TypeScriptImportGenerator {
+  organizeByFeature;
+  flat;
+  basePath;
+  casing;
+  constructor(basePath, settings) {
+    this.basePath = basePath;
+    this.flat = basePath !== "" && basePath !== ".";
+    this.organizeByFeature = !this.flat && settings["other.organize_by_feature"] === "true";
+    this.casing = createCasing(settings);
+  }
+  datasource(entity) {
+    const file = this.organizeByFeature ? `${this.casing.fileBase(entity)}.datasource.ts` : this.tsFile(entity);
+    const path = this.organizeByFeature ? this.featurePath(entity, file) : file;
+    return this.underBase(path);
+  }
+  datasourceRel(entity) {
+    return this.rel("types/generated/datasource", this.datasource(entity));
+  }
+  datasourceQual(entity) {
+    return this.casing.convertTypes(entity);
+  }
+  datasourceValidator(entity) {
+    const file = this.organizeByFeature ? `${this.casing.fileBase(entity)}.datasource.validator.ts` : this.tsFile(entity);
+    const path = this.organizeByFeature ? this.featurePath(entity, file) : file;
+    return this.underBase(path);
+  }
+  datasourceValidatorRel(entity) {
+    return this.rel(
+      "types/generated/datasource/validators",
+      this.datasourceValidator(entity)
+    );
+  }
+  datasourceTestRel(entity) {
+    return this.rel(
+      "types/generated/datasource",
+      this.test(this.datasource(entity), entity)
+    );
+  }
+  datasourceValidatorTestRel(entity) {
+    return this.rel(
+      "types/generated/datasource/validators",
+      this.test(this.datasourceValidator(entity), entity)
+    );
+  }
+  view(entity) {
+    return this.underBase(this.viewLike(entity, ""));
+  }
+  viewRel(entity) {
+    return this.rel("types/generated/views", this.view(entity));
+  }
+  viewQual(entity) {
+    return this.casing.convertTypes(entity);
+  }
+  viewValidator(entity) {
+    return this.underBase(this.viewLike(entity, ".validator"));
+  }
+  viewValidatorRel(entity) {
+    return this.rel(
+      "types/generated/views/validators",
+      this.viewValidator(entity)
+    );
+  }
+  viewTestRel(entity) {
+    return this.rel("types/generated/views", this.test(this.view(entity), entity));
+  }
+  viewValidatorTestRel(entity) {
+    return this.rel(
+      "types/generated/views/validators",
+      this.test(this.viewValidator(entity), entity)
+    );
+  }
+  validatorTestRel(kind, entity) {
+    return kind === "datasource" ? this.datasourceValidatorTestRel(entity) : this.viewValidatorTestRel(entity);
+  }
+  service(entity) {
+    const file = `${this.serviceStem(entity)}.ts`;
+    const path = this.organizeByFeature ? this.featurePath(entity, file) : file;
+    return this.underBase(path);
+  }
+  serviceRel(entity) {
+    return this.rel("services/generated", this.service(entity));
+  }
+  serviceCustom(name, module) {
+    return this.resolveCustom(name, module, "services");
+  }
+  serviceCustomRel(entity) {
+    const file = `${this.serviceStem(entity)}.ts`;
+    return this.organizeByFeature ? `features/${this.casing.directory(entity)}/custom/${file}` : `services/custom/${file}`;
+  }
+  serviceTest(entity) {
+    const file = `${this.serviceStem(entity)}.test.ts`;
+    const path = this.organizeByFeature ? `features/${this.casing.directory(entity)}/__tests__/${file}` : file;
+    return this.underBase(path);
+  }
+  serviceTestRel(entity) {
+    return this.rel("services/generated/__tests__", this.serviceTest(entity));
+  }
+  serviceIntegrationTest(entity) {
+    return this.serviceTest(entity).replace(/\.test\.ts$/, ".integration.test.js");
+  }
+  serviceIntegrationTestRel(entity) {
+    return this.rel(
+      "services/generated/__tests__",
+      this.serviceIntegrationTest(entity)
+    );
+  }
+  serviceUse(_entity, _symbol) {
+    return "";
+  }
+  route(entity) {
+    const file = this.organizeByFeature ? `${this.casing.fileBase(entity)}.route.ts` : this.tsFile(entity);
+    const path = this.organizeByFeature ? this.featurePath(entity, file) : file;
+    return this.underBase(path);
+  }
+  routeRel(entity) {
+    return this.rel("routes/generated", this.route(entity));
+  }
+  routeCustom(name, module) {
+    return this.resolveCustom(name, module, "routes");
+  }
+  routeTest(entity) {
+    const file = `${this.casing.fileBase(entity)}.integration.test.ts`;
+    const path = this.organizeByFeature ? `features/${this.casing.directory(entity)}/__tests__/${file}` : file;
+    return this.underBase(path);
+  }
+  routeTestRel(entity) {
+    return this.rel("routes/generated/__tests__", this.routeTest(entity));
+  }
+  enrichment(_targetTable) {
+    return "";
+  }
+  test(srcFile, fileBase) {
+    if (this.organizeByFeature) {
+      const stem = posix.basename(srcFile).replace(/\.ts$/, "");
+      return `${posix.dirname(srcFile)}/__tests__/${stem}.test.ts`;
+    }
+    return srcFile.replace(/\.ts$/, ".test.js");
+  }
+  testSpec(srcFile, fileBase) {
+    if (!srcFile.includes("/")) return `../${this.casing.fileBase(fileBase)}`;
+    return importSpec(this.test(srcFile, fileBase), srcFile);
+  }
+  index(beside) {
+    if (this.organizeByFeature) return "";
+    return posix.join(posix.dirname(beside), "index.ts");
+  }
+  spec(fromFile, toFile) {
+    return importSpec(fromFile, toFile);
+  }
+  routeModule(entity) {
+    return this.casing.fileBase(entity);
+  }
+  appWiring() {
+    return "";
+  }
+  validatorFn(_kind, _entity, _fn) {
+    return "";
+  }
+  apiPath(entity) {
+    return entity.replace(/_/g, "-");
+  }
+  frontend(relPath) {
+    return posix.join("frontend", relPath);
+  }
+  app() {
+    return this.casing.filePath("app");
+  }
+  server() {
+    return this.casing.filePath("server");
+  }
+  appTest(stem) {
+    return `__tests__/${this.casing.fileBase(stem)}.test.ts`;
+  }
+  /** Layered types/services/routes globs, or features when by-feature. Empty when flat. */
+  tsconfigIncludes() {
+    if (this.flat) return [];
+    if (this.organizeByFeature) return ["features/**/*.ts"];
+    return ["types/**/*.ts", "services/**/*.ts", "routes/**/*.ts"];
+  }
+  rel(prefix, file) {
+    if (this.organizeByFeature || this.flat) return file;
+    return `${prefix}/${file}`;
+  }
+  tsFile(stem) {
+    return `${this.casing.fileBase(stem)}.ts`;
+  }
+  featurePath(entity, file) {
+    return `features/${this.casing.directory(entity)}/${file}`;
+  }
+  serviceStem(entity) {
+    return this.casing.fileBase(`${entity}_service`);
+  }
+  underBase(file) {
+    if (!this.flat) return file;
+    return `${this.basePath}/${file}`;
+  }
+  viewLike(entity, featureExt) {
+    const file = `${this.casing.fileBase(entity)}${this.organizeByFeature ? featureExt : ""}.ts`;
+    return this.organizeByFeature ? `features/${this.casing.directory(entity)}/${file}` : file;
+  }
+  resolveCustom(name, mod, layer) {
+    const kind = layer === "services" ? "service" : "route";
+    const stubFn = layer === "services" ? "generateCustomServiceStub" : "generateCustomRouteStub";
+    const file = layer === "services" ? this.tsFile(name) : `${this.casing.fileBase(`${name}_route`)}.ts`;
+    const defaultStub = this.organizeByFeature ? `features/${this.casing.directory(name)}/custom/${file}` : `../custom/${file}`;
+    if (this.organizeByFeature) {
+      if (typeof mod !== "string" || !mod.startsWith(".") || mod.startsWith("./services/") || mod.startsWith("./routes/")) {
+        return defaultStub;
+      }
+      const parts2 = modulePathParts(mod);
+      if (parts2[0] !== "features") {
+        throw new Error(
+          `${stubFn}: ${kind} "${name}" has module "${mod}" which is outside ./features/. When organize=by-feature, custom ${layer} must live under features/<entity>/custom/. Drop the module: field to use the convention default (${defaultStub.replace(/\.ts$/, "")}), or point module: into ./features/.`
+        );
+      }
+      return `${parts2.join("/")}.ts`;
+    }
+    if (!mod || !mod.startsWith(".")) return defaultStub;
+    const parts = modulePathParts(mod);
+    if (parts[0] === layer) parts.shift();
+    return `../${parts.join("/")}.ts`;
+  }
+}
+const createImportGenerator = (basePath, settings) => new TypeScriptImportGenerator(basePath, settings);
+export {
+  TypeScriptImportGenerator,
+  createImportGenerator
+};

package/node_modules/@deterministic-code/typescript-generators/dist/inline-inherited.js

@@ -0,0 +1,4 @@
+const referencesBackend = (settings) => settings.reference_backend_type === "true";
+export {
+  referencesBackend
+};

package/node_modules/@deterministic-code/typescript-generators/dist/resources/backend-app-minimal.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-backend-app/minimal/${rel}`, import.meta.url),
+  "utf8"
+);
+const [
+  minimalAppTs,
+  minimalServerTs,
+  minimalPackageJson,
+  minimalTsconfigJson,
+  minimalHealthTestTs
+] = await Promise.all([
+  resource("app.ts.tmpl"),
+  resource("server.ts.tmpl"),
+  resource("package.json.tmpl"),
+  resource("tsconfig.json.tmpl"),
+  resource("health.test.ts.tmpl")
+]);
+export {
+  minimalAppTs,
+  minimalHealthTestTs,
+  minimalPackageJson,
+  minimalServerTs,
+  minimalTsconfigJson
+};