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

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

@@ -0,0 +1,93 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import { isUnionEnum } from "./common/view-shape.js";
+import {
+  shapedToks,
+  viewExpr
+} from "./common/view-test-fixtures.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { typeTestTmpl } from "./resources/view-type-validators-tests.js";
+import { Emit } from "./emit.js";
+const shapedCases = (view, opts) => {
+  const fields = shapedToks(view, opts, /* @__PURE__ */ new Set([view.name]));
+  const cls = opts.casing.convertTypes(view.name);
+  const cases = [
+    {
+      ident: "parses_a_valid_payload",
+      fixture: `${cls} { ${fields.map((f) => `${f.ident}: ${f.sampleExpr}`).join(", ")} }`,
+      assertion: "is_ok()"
+    }
+  ];
+  if (fields.some((f) => f.nullable)) {
+    cases.push({
+      ident: "accepts_none_for_nullable_fields",
+      fixture: `${cls} { ${fields.map((f) => `${f.ident}: ${f.nullable ? "None" : f.sampleExpr}`).join(", ")} }`,
+      assertion: "is_ok()"
+    });
+  }
+  return cases;
+};
+const unionCases = (view, opts) => {
+  const cls = opts.casing.convertTypes(view.name);
+  return (view.union ?? []).map((name) => ({
+    ident: opts.casing.fnIdent(`accepts_${name}_member`),
+    fixture: `${cls}::${opts.casing.convertTypes(name)}(${viewExpr(name, opts, /* @__PURE__ */ new Set([view.name]))})`,
+    assertion: "is_ok()"
+  }));
+};
+class Generator extends Emit {
+  tables;
+  views;
+  expandedViews;
+  typesByName;
+  datasourceNames;
+  constructor(raw, deterministic) {
+    super(raw);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t])
+    );
+    this.views = new Map(
+      authoredViewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+    this.expandedViews = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.datasourceNames = new Set(this.tables.keys());
+  }
+  from() {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+  tests(view) {
+    const src = this.imports.view(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        typeUse: this.imports.viewQual(view.name),
+        fnName: this.casing.convertFields(`validate_${view.name}`),
+        cases: isUnionEnum(view) ? unionCases(view, this) : shapedCases(view, this)
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(
+    ctx.settings,
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  ).from();
+};
+export {
+  generate
+};

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

@@ -0,0 +1,137 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  emitViewFields,
+  fieldRefKind,
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource
+} from "./common/view-shape.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import {
+  checkArrayNullableTmpl,
+  checkArrayTmpl,
+  checkNullableTmpl,
+  checkRequiredTmpl,
+  typeTmpl
+} from "./resources/view-type-validators.js";
+import { Emit } from "./emit.js";
+class Generator extends Emit {
+  typesByName;
+  datasourceNames;
+  expandedByName;
+  constructor(raw, deterministic) {
+    super(raw);
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.datasourceNames = new Set(
+      datasourceTypesOf(deterministic).map((t) => t.name)
+    );
+    this.expandedByName = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+  }
+  from(deterministic) {
+    return authoredViewTypesOf(deterministic).map(
+      (view) => this.view(view, this.expandedByName.get(view.name))
+    );
+  }
+  typePath(entity, kind) {
+    return kind === "datasource" ? this.imports.datasourceQual(entity) : this.imports.viewQual(entity);
+  }
+  validatorFn(entity, kind) {
+    const fn = kind === "datasource" ? this.casing.convertFields(`validate_datasource_${entity}`) : this.casing.convertFields(`validate_${entity}`);
+    return this.imports.validatorFn(kind, entity, fn);
+  }
+  checkField(field) {
+    const prop = this.casing.convertFields(field.name);
+    const access = `obj.${prop}`;
+    if (field.isMap === true) {
+      const dict = dictionaryOfField(field, this.typesByName);
+      const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+      if (entry === void 0) return "";
+      const refKind2 = fieldRefKind(entry.value, this.typesByName);
+      if (refKind2 === "primitive") return "";
+      const fn2 = this.validatorFn(entry.value.base, refKind2);
+      return `    for item in ${access}.values() { if let Err(mut e) = ${fn2}(item) { errors.append(&mut e); } }`;
+    }
+    const refKind = fieldRefKind(field, this.typesByName);
+    if (refKind === "primitive") return "";
+    const fn = this.validatorFn(field.base, refKind);
+    if (field.isArray) {
+      const tmpl = field.isNullable ? checkArrayNullableTmpl : checkArrayTmpl;
+      return fill(tmpl, { access, fn }).trimEnd();
+    }
+    if (field.isNullable) {
+      return fill(checkNullableTmpl, { access, fn }).trimEnd();
+    }
+    return fill(checkRequiredTmpl, { fn, arg: `&${access}` }).trimEnd();
+  }
+  shapedBody(view, expanded) {
+    const checks = [];
+    const extras = emitViewFields(view, expanded, this.datasourceNames);
+    if (isAlias(view) && extras.length === 0) {
+      const fn = this.validatorFn(view.name, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "obj" }).trimEnd());
+    } else if (isAlias(view)) {
+      const fn = this.validatorFn(view.name, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "&obj.base" }).trimEnd());
+    } else if (wrapsInheritedDatasource(view, this.datasourceNames)) {
+      const fn = this.validatorFn(view.inherits, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "&obj.base" }).trimEnd());
+    }
+    for (const line of extras.map((f) => this.checkField(f))) {
+      if (line !== "") checks.push(line);
+    }
+    return checks;
+  }
+  view(view, expanded) {
+    const fnName = this.casing.convertFields(`validate_${view.name}`);
+    const path = this.imports.viewValidator(view.name);
+    const isUnion = isUnionEnum(view);
+    const enumName = this.casing.convertTypes(view.name);
+    const arms = (view.union ?? []).map((name) => {
+      const variant = this.casing.convertTypes(name);
+      const fn = this.validatorFn(name, "view");
+      return {
+        arm: `${enumName}::${variant}(inner) => ${fn}(inner),`
+      };
+    });
+    const checks = isUnion ? [] : this.shapedBody(view, expanded);
+    return content(
+      path,
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        isUnion,
+        isShaped: !isUnion,
+        fnName,
+        typePath: this.typePath(view.name, "view"),
+        paramName: checks.length > 0 ? "obj" : "_obj",
+        hasChecks: checks.length > 0,
+        checks: checks.map((line) => ({ line })),
+        arms
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings
+  );
+  return new Generator(ctx.settings, deterministic).from(deterministic);
+};
+export {
+  generate
+};

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

@@ -0,0 +1,81 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import { isUnionEnum } from "./common/view-shape.js";
+import {
+  shapedToks,
+  viewExpr
+} from "./common/view-test-fixtures.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { typeTestTmpl } from "./resources/view-types-tests.js";
+import { Emit } from "./emit.js";
+class Generator extends Emit {
+  tables;
+  views;
+  expandedViews;
+  typesByName;
+  datasourceNames;
+  constructor(raw, deterministic) {
+    super(raw);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t])
+    );
+    this.views = new Map(
+      authoredViewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+    this.expandedViews = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.datasourceNames = new Set(this.tables.keys());
+  }
+  from() {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+  tests(view) {
+    const isUnion = isUnionEnum(view);
+    const cls = this.casing.convertTypes(view.name);
+    const members = isUnion ? (view.union ?? []).map((name) => ({
+      acceptsMemberTest: this.casing.fnIdent(`accepts_${name}_member`),
+      memberExpr: `${cls}::${this.casing.convertTypes(name)}(${viewExpr(name, this, /* @__PURE__ */ new Set([view.name]))})`
+    })) : [];
+    const fields = isUnion ? [] : shapedToks(view, this, /* @__PURE__ */ new Set([view.name]));
+    const fixture = fields.length === 0 ? `${cls} {}` : `${cls} {
+${fields.map((f) => `            ${f.ident}: ${f.sampleExpr},`).join("\n")}
+        }`;
+    const src = this.imports.view(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        structName: cls,
+        fileBase: this.casing.fileBase(view.name),
+        isShaped: !isUnion,
+        isUnion,
+        needsHashMap: fields.some((f) => f.sampleExpr.includes("HashMap")),
+        fixture,
+        fields,
+        members
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(
+    ctx.settings,
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  ).from();
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-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/rust-generators/dist/generate-view-types.js

@@ -0,0 +1,142 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  fieldTypeOf,
+  tableKind,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  emitViewFields,
+  fieldRefKind,
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource
+} from "./common/view-shape.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import {
+  convertSpecType,
+  rustLanguageZero,
+  rustSpecDefaultExpr
+} from "./deterministic-type-converter.js";
+import { typeTmpl } from "./resources/view-types.js";
+import { Emit } from "./emit.js";
+import { typesNeedingDefault } from "./struct-default.js";
+class Generator extends Emit {
+  typesByName;
+  datasourceNames;
+  expandedByName;
+  constructor(raw, deterministic) {
+    super(raw);
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.datasourceNames = new Set(
+      datasourceTypesOf(deterministic).map((t) => t.name)
+    );
+    this.expandedByName = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v])
+    );
+  }
+  from(deterministic) {
+    const needingDefault = typesNeedingDefault(deterministic);
+    return authoredViewTypesOf(deterministic).map(
+      (view) => this.view(view, this.expandedByName.get(view.name), needingDefault)
+    );
+  }
+  rustPart(field) {
+    const refKind = fieldRefKind(field, this.typesByName);
+    return refKind === "primitive" ? convertSpecType(field.base) : refKind === "datasource" ? this.imports.datasourceQual(field.base) : this.imports.viewQual(field.base);
+  }
+  rustTypeFor(field) {
+    const dict = dictionaryOfField(field, this.typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    let base;
+    if (entry !== void 0) {
+      base = `HashMap<${this.rustPart(entry.key)}, ${this.rustPart(entry.value)}>`;
+    } else {
+      base = this.rustPart(field);
+      if (field.isArray) base = `Vec<${base}>`;
+    }
+    return field.isNullable ? `Option<${base}>` : base;
+  }
+  fieldToken(field) {
+    const rustType = this.rustTypeFor(field);
+    const specExpr = field.kind === "primitive" ? rustSpecDefaultExpr(fieldTypeOf(field, this.typesByName), field) : void 0;
+    return {
+      ident: this.casing.convertFields(field.name),
+      rustType,
+      defaultExpr: specExpr ?? rustLanguageZero(rustType)
+    };
+  }
+  structFields(view, expanded) {
+    const fields = emitViewFields(view, expanded, this.datasourceNames).map(
+      (f) => this.fieldToken(f)
+    );
+    const synthetic = (ident, rustType) => ({
+      ident,
+      rustType,
+      defaultExpr: rustLanguageZero(rustType)
+    });
+    if (isAlias(view) && fields.length > 0) {
+      return [
+        synthetic("base", this.imports.datasourceQual(view.name)),
+        ...fields
+      ];
+    }
+    if (view.inherits !== void 0 && wrapsInheritedDatasource(view, this.datasourceNames)) {
+      return [
+        synthetic("base", this.imports.datasourceQual(view.inherits)),
+        ...fields
+      ];
+    }
+    return fields;
+  }
+  view(view, expanded, needingDefault) {
+    const structName = this.casing.convertTypes(view.name);
+    const isUnion = isUnionEnum(view);
+    const members = (view.union ?? []).map((name) => ({
+      variant: this.casing.convertTypes(name),
+      memberType: this.imports.viewQual(name)
+    }));
+    const fields = isUnion ? [] : this.structFields(view, expanded);
+    const alias = !isUnion && isAlias(view) && fields.length === 0;
+    const isStruct = !alias && !isUnion;
+    return content(
+      this.imports.view(view.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        structName,
+        datasourceType: tableKind(view),
+        target: isUnion ? "UnionView" : "ShapedView",
+        fieldCount: String(isStruct ? fields.length : 0),
+        isAlias: alias,
+        aliasType: isAlias(view) ? this.imports.datasourceQual(view.name) : "",
+        isUnion,
+        isStruct,
+        implDefault: isStruct && needingDefault.has(view.name),
+        needsHashMap: fields.some((f) => f.rustType.includes("HashMap<")),
+        members,
+        fields
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings
+  );
+  return new Generator(ctx.settings, deterministic).from(deterministic);
+};
+export {
+  generate
+};

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

@@ -0,0 +1,243 @@
+import { posix } from "node:path";
+import pluralize from "pluralize";
+import { createCasing } from "./common/default-casing.js";
+const VARIANT_PREFIXES = ["update_", "create_"];
+const featureEntity = (entity) => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === void 0 ? entity : entity.slice(prefix.length);
+};
+const pluralSnake = (entity) => {
+  const parts = entity.split(/[_-]/);
+  parts[parts.length - 1] = pluralize.plural(parts[parts.length - 1]);
+  return parts.join("_");
+};
+const CUSTOM_SUFFIX_TOKENS = /* @__PURE__ */ new Set(["service", "route"]);
+const featureEntityFromClass = (className) => {
+  const tokens = className.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase().split("-").filter(Boolean);
+  if (tokens.length === 0) return "";
+  const last = tokens[tokens.length - 1];
+  if (tokens.length > 1 && CUSTOM_SUFFIX_TOKENS.has(last)) tokens.pop();
+  return tokens.join("-");
+};
+const modulePathParts = (mod) => {
+  const parts = mod.split("/").filter((p) => p !== "" && p !== ".");
+  while (parts.length && parts[0] === "..") parts.shift();
+  return parts;
+};
+const crateFromFile = (toFile) => {
+  const stem = toFile.endsWith(".rs") ? toFile.slice(0, -3) : toFile;
+  return `crate::${stem.split("/").join("::")}`;
+};
+class RustImportGenerator {
+  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.rsFile(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.typeQual(
+      this.datasourceRel(entity),
+      this.casing.convertTypes(entity)
+    );
+  }
+  datasourceValidator(entity) {
+    if (this.organizeByFeature) {
+      return this.underBase(
+        this.featurePath(entity, this.rsFile(`${entity}_validator`))
+      );
+    }
+    return this.underBase(this.rsFile(`datasource_${entity}_validator`));
+  }
+  datasourceValidatorRel(entity) {
+    return this.rel(
+      "types/generated/datasource/validators",
+      this.datasourceValidator(entity)
+    );
+  }
+  view(entity) {
+    const file = this.rsFile(entity);
+    const path = this.organizeByFeature ? this.featurePath(featureEntity(entity), file) : file;
+    return this.underBase(path);
+  }
+  viewRel(entity) {
+    return this.rel("types/generated/views", this.view(entity));
+  }
+  viewQual(entity) {
+    return this.typeQual(this.viewRel(entity), this.casing.convertTypes(entity));
+  }
+  viewValidator(entity) {
+    const file = this.rsFile(`${entity}_validator`);
+    if (this.organizeByFeature) {
+      return this.underBase(this.featurePath(featureEntity(entity), file));
+    }
+    return this.underBase(file);
+  }
+  viewValidatorRel(entity) {
+    return this.rel(
+      "types/generated/views/validators",
+      this.viewValidator(entity)
+    );
+  }
+  service(entity) {
+    const file = `${this.serviceStem(entity)}.rs`;
+    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)}.rs`;
+    return this.organizeByFeature ? `features/${this.casing.directory(entity)}/custom/${file}` : `services/custom/${file}`;
+  }
+  serviceTest(entity) {
+    return this.test(this.service(entity), `${entity}_service`);
+  }
+  serviceTestRel(entity) {
+    return this.rel("services/generated/__tests__", this.serviceTest(entity));
+  }
+  serviceIntegrationTest(entity) {
+    const file = this.rsFile(`${entity}_service_integration_tests`);
+    if (this.organizeByFeature) {
+      return `features/${this.casing.directory(entity)}/__tests__/${file}`;
+    }
+    return file;
+  }
+  serviceIntegrationTestRel(entity) {
+    return this.rel(
+      "services/generated/__tests__",
+      this.serviceIntegrationTest(entity)
+    );
+  }
+  serviceUse(entity, symbol) {
+    return `use ${this.spec("", this.serviceRel(entity))}::${symbol};`;
+  }
+  route(entity) {
+    const file = `${this.routeStem(entity)}.rs`;
+    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) {
+    return this.test(this.route(entity), this.routeStem(entity));
+  }
+  enrichment(_targetTable) {
+    return "";
+  }
+  test(srcFile, fileBase) {
+    const file = `${this.casing.fileBase(`${fileBase}_tests`)}.rs`;
+    if (this.organizeByFeature) {
+      return `${posix.dirname(srcFile)}/__tests__/${file}`;
+    }
+    return file;
+  }
+  testSpec(srcFile, fileBase) {
+    return this.spec(this.test(srcFile, fileBase), srcFile);
+  }
+  index(beside) {
+    if (this.organizeByFeature) return "";
+    return posix.join(posix.dirname(beside), "mod.rs");
+  }
+  spec(_fromFile, toFile) {
+    return crateFromFile(toFile);
+  }
+  routeModule(entity) {
+    return this.routeStem(entity);
+  }
+  appWiring() {
+    return this.organizeByFeature ? "features/app_wiring.rs" : "app_wiring.rs";
+  }
+  validatorFn(kind, entity, fn) {
+    if (this.organizeByFeature) {
+      const file = kind === "datasource" ? this.datasourceValidator(entity) : this.viewValidator(entity);
+      return `${this.spec("", file)}::${fn}`;
+    }
+    const ns = kind === "datasource" ? "crate::types::generated::datasource::validators" : "crate::types::generated::views::validators";
+    return `${ns}::${fn}`;
+  }
+  apiPath(entity) {
+    return pluralSnake(entity).replace(/_/g, "-");
+  }
+  frontend(relPath) {
+    return posix.join("frontend", relPath);
+  }
+  rel(prefix, file) {
+    if (this.organizeByFeature || this.flat) return file;
+    return `${prefix}/${file}`;
+  }
+  typeQual(toFile, symbol) {
+    const crate = this.spec("", toFile);
+    if (this.organizeByFeature) return `${crate}::${symbol}`;
+    const parts = crate.split("::");
+    parts.pop();
+    return `${parts.join("::")}::${symbol}`;
+  }
+  rsFile(stem) {
+    return `${this.casing.fileBase(stem)}.rs`;
+  }
+  featurePath(entity, file) {
+    return `features/${this.casing.directory(entity)}/${file}`;
+  }
+  serviceStem(entity) {
+    return this.casing.fileBase(`${entity}_service`);
+  }
+  routeStem(entity) {
+    const plural = pluralSnake(entity);
+    return this.casing.fileBase(
+      this.organizeByFeature ? `${plural}_router` : plural
+    );
+  }
+  underBase(file) {
+    if (!this.flat) return file;
+    return `${this.basePath}/${file}`;
+  }
+  resolveCustom(name, mod, layer) {
+    const kind = layer === "services" ? "service" : "route";
+    const stubFn = layer === "services" ? "generateCustomServiceStub" : "generateCustomRouteStub";
+    const file = this.rsFile(name);
+    const entity = (featureEntityFromClass(name) || "shared").replace(/-/g, "_");
+    const defaultStub = this.organizeByFeature ? `features/${this.casing.directory(entity)}/custom/${file}` : `../custom/${file}`;
+    if (this.organizeByFeature) {
+      if (!mod || !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(/\.rs$/, "")}), or point module: into ./features/.`
+        );
+      }
+      return `${parts2.join("/")}.rs`;
+    }
+    if (!mod || !mod.startsWith(".")) return defaultStub;
+    const parts = modulePathParts(mod);
+    if (parts[0] === layer) parts.shift();
+    return `../${parts.join("/")}.rs`;
+  }
+}
+const createImportGenerator = (basePath, settings) => new RustImportGenerator(basePath, settings);
+export {
+  RustImportGenerator,
+  createImportGenerator
+};