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

package/node_modules/@deterministic-code/generators-common/src/deterministic-type-converter.ts

@@ -0,0 +1,35 @@
+export class DeterministicTypeConverter {
+  readonly dictionary: Record<string, string>;
+  readonly #reverse: Map<string, string[]>;
+
+  constructor(dictionary: Record<string, string>) {
+    this.dictionary = dictionary;
+    this.#reverse = new Map();
+    for (const [specType, native] of Object.entries(dictionary)) {
+      const existing = this.#reverse.get(native);
+      if (existing === undefined) this.#reverse.set(native, [specType]);
+      else existing.push(specType);
+    }
+  }
+
+  convert(specType: string): string {
+    const native = this.dictionary[specType];
+    if (native === undefined) {
+      throw new Error(`Unknown spec field type: ${specType}`);
+    }
+    return native;
+  }
+
+  reverseConvert(native: string): string {
+    const specTypes = this.#reverse.get(native);
+    if (specTypes === undefined) {
+      throw new Error(`Unknown native field type: ${native}`);
+    }
+    if (specTypes.length > 1) {
+      throw new Error(
+        `Native field type ${native} maps to multiple spec types: ${specTypes.join(", ")}`,
+      );
+    }
+    return specTypes[0]!;
+  }
+}

package/node_modules/@deterministic-code/generators-common/src/fill.ts

@@ -0,0 +1,6 @@
+import Mustache from "#mustache";
+
+export const fill = (text: string, tokens: Record<string, unknown>): string =>
+  Mustache.render(text, tokens, undefined, {
+    escape: (value: unknown) => String(value),
+  });

package/node_modules/@deterministic-code/generators-common/src/generate-context.ts

@@ -0,0 +1,6 @@
+import type { IDeterministicReader } from "./deterministic-reader.ts";
+
+export type GenerateContext = {
+  reader: IDeterministicReader;
+  settings: Record<string, string>;
+};

package/node_modules/@deterministic-code/generators-common/src/generate-entry.ts

@@ -0,0 +1,54 @@
+export type ReferenceAttributes = Record<string, string>;
+
+export type PatchAppendIfNotExists = "None" | "End" | "Start";
+
+export type GenerateEntry =
+  | {
+      kind: "content";
+      filename: string;
+      contents: string;
+      attributes?: ReferenceAttributes;
+    }
+  | {
+      kind: "patch";
+      filename: string;
+      content: string;
+      section?: string;
+      appendIfNotExists?: PatchAppendIfNotExists;
+    };
+
+export const content = (
+  filename: string,
+  contents: string,
+  attributes?: ReferenceAttributes,
+): GenerateEntry =>
+  attributes === undefined
+    ? { kind: "content", filename, contents }
+    : { kind: "content", filename, contents, attributes };
+
+export const patch = (
+  filename: string,
+  fileContent: string,
+  section?: string,
+  appendIfNotExists?: PatchAppendIfNotExists,
+): GenerateEntry => {
+  if (section === undefined && appendIfNotExists === undefined) {
+    return { kind: "patch", filename, content: fileContent };
+  }
+  return {
+    kind: "patch",
+    filename,
+    content: fileContent,
+    ...(section === undefined ? {} : { section }),
+    ...(appendIfNotExists === undefined ? {} : { appendIfNotExists }),
+  };
+};
+
+export const stripAttributes = (entries: GenerateEntry[]): GenerateEntry[] =>
+  entries.map((entry) => {
+    if (entry.kind !== "content" || entry.attributes === undefined) {
+      return entry;
+    }
+    const { attributes: _attributes, ...rest } = entry;
+    return rest;
+  });

package/node_modules/@deterministic-code/generators-common/src/import-generator.ts

@@ -0,0 +1,39 @@
+export type IImportGenerator = {
+  datasource: (entity: string) => string;
+  datasourceRel: (entity: string) => string;
+  datasourceQual: (entity: string) => string;
+  datasourceValidator: (entity: string) => string;
+  datasourceValidatorRel: (entity: string) => string;
+  view: (entity: string) => string;
+  viewRel: (entity: string) => string;
+  viewQual: (entity: string) => string;
+  viewValidator: (entity: string) => string;
+  viewValidatorRel: (entity: string) => string;
+  service: (entity: string) => string;
+  serviceRel: (entity: string) => string;
+  serviceCustom: (name: string, module?: string) => string;
+  serviceCustomRel: (entity: string) => string;
+  serviceTest: (entity: string) => string;
+  serviceTestRel: (entity: string) => string;
+  serviceIntegrationTest: (entity: string) => string;
+  serviceIntegrationTestRel: (entity: string) => string;
+  serviceUse: (entity: string, symbol: string) => string;
+  route: (entity: string) => string;
+  routeRel: (entity: string) => string;
+  routeCustom: (name: string, module?: string) => string;
+  routeTest: (entity: string) => string;
+  enrichment: (targetTable: string) => string;
+  test: (srcFile: string, fileBase: string) => string;
+  testSpec: (srcFile: string, fileBase: string) => string;
+  index: (beside: string) => string;
+  spec: (fromFile: string, toFile: string) => string;
+  routeModule: (entity: string) => string;
+  appWiring: () => string;
+  validatorFn: (
+    kind: "datasource" | "view",
+    entity: string,
+    fn: string,
+  ) => string;
+  apiPath: (entity: string) => string;
+  frontend: (relPath: string) => string;
+};

package/node_modules/@deterministic-code/generators-common/src/mustache-module.d.ts

@@ -0,0 +1,9 @@
+declare const Mustache: {
+  render: (
+    template: string,
+    view: Record<string, unknown>,
+    partials?: unknown,
+    options?: { escape?: (value: unknown) => string },
+  ) => string;
+};
+export default Mustache;

package/node_modules/@deterministic-code/generators-common/src/pluralize-module.d.ts

@@ -0,0 +1,10 @@
+declare module "pluralize" {
+  const pluralize: {
+    (word: string, count?: number, inclusive?: boolean): string;
+    plural: (word: string) => string;
+    singular: (word: string) => string;
+    isPlural: (word: string) => boolean;
+    isSingular: (word: string) => boolean;
+  };
+  export default pluralize;
+}

package/node_modules/@deterministic-code/generators-common/src/reference-verifier.test.ts

@@ -0,0 +1,257 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  content,
+  patch,
+  stripAttributes,
+  type GenerateEntry,
+  type ReferenceAttributes,
+} from "./generate-entry.ts";
+import {
+  containsIdent,
+  finalizeEntries,
+  isRelativeModulePath,
+  pickReferenceAttributes,
+  referenceAttributesFromEntries,
+  ReferenceVerifier,
+  verifyEntries,
+} from "./reference-verifier.ts";
+
+describe("ReferenceVerifier", () => {
+  it("succeeds when imports and uses match declared modules and exports", () => {
+    const attrs: ReferenceAttributes[] = [
+      {
+        module: "types/generated/views/user.ts",
+        exports: "User",
+      },
+      {
+        module: "services/generated/userService.ts",
+        exports: "UserService, IUserService",
+        imports: "types/generated/views/user.ts",
+        uses: "User",
+      },
+    ];
+    assert.doesNotThrow(() => new ReferenceVerifier().verify(attrs));
+  });
+
+  it("fails on casing mismatch for uses", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          { module: "types/generated/views/user.ts", exports: "User" },
+          { module: "services/generated/userService.ts", uses: "user" },
+        ]),
+      /uses "user".*did you mean "User"/,
+    );
+  });
+
+  it("fails on casing mismatch for imports", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          { module: "types/generated/views/User.ts" },
+          {
+            module: "services/generated/userService.ts",
+            imports: "types/generated/views/user.ts",
+          },
+        ]),
+      /import "types\/generated\/views\/user\.ts".*did you mean "types\/generated\/views\/User\.ts"/,
+    );
+  });
+
+  it("fails when module is missing", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          {
+            module: "services/generated/userService.ts",
+            imports: "types/generated/views/missing.ts",
+          },
+        ]),
+      /import "types\/generated\/views\/missing\.ts"/,
+    );
+  });
+
+  it("allows the same export name from different modules", () => {
+    assert.doesNotThrow(() =>
+      new ReferenceVerifier().verify([
+        { module: "types/generated/datasource/user.ts", exports: "User" },
+        { module: "types/generated/views/user.ts", exports: "User" },
+      ]),
+    );
+  });
+
+  it("fails on duplicate module identity", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          { module: "shared.ts", exports: "A" },
+          { module: "shared.ts", exports: "B" },
+        ]),
+      /duplicateModule "shared\.ts"/,
+    );
+  });
+
+  it("fails on namespaceRef mismatch", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          {
+            module: "User.cs",
+            namespace: "Backend.Types.Datasource",
+          },
+          {
+            module: "UserService.cs",
+            namespaceRefs: "Backend.Types.DataSource",
+          },
+        ]),
+      /namespaceRef "Backend\.Types\.DataSource".*did you mean "Backend\.Types\.Datasource"/,
+    );
+  });
+
+  it("rejects relative ../../ paths in imports", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verify([
+          { module: "types/generated/views/user.ts", exports: "User" },
+          {
+            module: "services/generated/userService.ts",
+            imports: "../../types/generated/views/user",
+            uses: "User",
+          },
+        ]),
+      /relativePath.*\.\.\/\.\./,
+    );
+  });
+
+  it("accepts comma-separated list values", () => {
+    assert.doesNotThrow(() =>
+      new ReferenceVerifier().verify([
+        {
+          module: "a.ts",
+          exports: "Foo, Bar",
+          namespace: "Ns.A",
+        },
+        {
+          module: "b.ts",
+          imports: "a.ts",
+          uses: "Foo,Bar",
+          namespaceRefs: "Ns.A",
+        },
+      ]),
+    );
+  });
+});
+
+describe("reference attribute helpers", () => {
+  it("pickReferenceAttributes drops non-verifier keys", () => {
+    assert.deepEqual(
+      pickReferenceAttributes({
+        module: "a.ts",
+        exports: "A",
+        typeName: "A",
+        typeImportPath: "../../a",
+      }),
+      { module: "a.ts", exports: "A" },
+    );
+  });
+
+  it("isRelativeModulePath detects ./ and ../", () => {
+    assert.equal(isRelativeModulePath("../../types/user"), true);
+    assert.equal(isRelativeModulePath("./user"), true);
+    assert.equal(isRelativeModulePath("types/generated/views/user.ts"), false);
+  });
+
+  it("containsIdent requires identifier boundaries", () => {
+    assert.equal(containsIdent("export type User = {}", "User"), true);
+    assert.equal(containsIdent("export type UserService = {}", "User"), false);
+    assert.equal(containsIdent("IcontactService", "i_contact_service"), false);
+  });
+
+  it("verifyContents fails when uses is declared but glued in the file", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verifyContents([
+          content(
+            "contact.ts",
+            'import { IcontactService } from "../../services/generated/contact_service";',
+            {
+              module: "routes/generated/contact.ts",
+              uses: "i_contact_service",
+            },
+          ),
+        ]),
+      /missingUse "i_contact_service".*not in file/,
+    );
+  });
+
+  it("verifyContents hints when the file has the name in the wrong case", () => {
+    assert.throws(
+      () =>
+        new ReferenceVerifier().verifyContents([
+          content("user.ts", "export type user = {}", {
+            module: "types/generated/views/user.ts",
+            exports: "User",
+          }),
+        ]),
+      /missingExport "User".*file has "user"/,
+    );
+  });
+
+  it("referenceAttributesFromEntries feeds verifier; finalize strips", () => {
+    const entries: GenerateEntry[] = [
+      content("user.ts", "export type User = {}", {
+        module: "types/generated/views/user.ts",
+        exports: "User",
+        typeName: "User",
+      }),
+      content(
+        "userService.ts",
+        "import { User }\nexport class UserService {}",
+        {
+          module: "services/generated/userService.ts",
+          exports: "UserService",
+          imports: "types/generated/views/user.ts",
+          uses: "User",
+          typeImportPath: "../../types/generated/views/user",
+        },
+      ),
+      content("plain.ts", "no attrs"),
+      patch("pkg.json", "{}", "typescript"),
+    ];
+    const attrs = referenceAttributesFromEntries(entries);
+    assert.deepEqual(attrs, [
+      { module: "types/generated/views/user.ts", exports: "User" },
+      {
+        module: "services/generated/userService.ts",
+        exports: "UserService",
+        imports: "types/generated/views/user.ts",
+        uses: "User",
+      },
+    ]);
+    assert.doesNotThrow(() => new ReferenceVerifier().verify(attrs));
+    assert.doesNotThrow(() => verifyEntries(entries));
+    assert.deepEqual(finalizeEntries(entries), [
+      {
+        kind: "content",
+        filename: "user.ts",
+        contents: "export type User = {}",
+      },
+      {
+        kind: "content",
+        filename: "userService.ts",
+        contents: "import { User }\nexport class UserService {}",
+      },
+      { kind: "content", filename: "plain.ts", contents: "no attrs" },
+      { kind: "patch", filename: "pkg.json", content: "{}", section: "typescript" },
+    ]);
+  });
+
+  it("stripAttributes leaves patches and plain content unchanged", () => {
+    const entries: GenerateEntry[] = [
+      content("a.ts", "body"),
+      patch("pkg.json", "{}", "typescript"),
+    ];
+    assert.deepEqual(stripAttributes(entries), entries);
+  });
+});