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

package/node_modules/@deterministic-code/csharp-generators/src/generate-view-types-tests.ts

@@ -0,0 +1,187 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import { convertSpecType } from "./deterministic-type-converter.ts";
+import { Emit } from "./emit.ts";
+import { typeTestTmpl } from "./resources/view-types-tests.ts";
+
+type FieldTok = {
+  ident: string;
+  sampleExpr: string;
+  nextExpr: string;
+  nullable: boolean;
+  getsTest: string;
+  setsTest: string;
+  allowsNullTest: string;
+};
+
+const samplesForNative = (
+  native: string,
+  fieldType: string,
+): { sample: string; next: string } => {
+  switch (native) {
+    case "long":
+      return { sample: "1L", next: "2L" };
+    case "short":
+      return { sample: "(short)1", next: "(short)2" };
+    case "double":
+      return { sample: "1.0", next: "2.0" };
+    case "bool":
+      return { sample: "false", next: "true" };
+    case "byte[]":
+      return { sample: "new byte[] { }", next: "new byte[] { 1 }" };
+    case "System.DateTime":
+      return {
+        sample: 'System.DateTime.Parse("2024-01-01T00:00:00.000Z")',
+        next: 'System.DateTime.Parse("2024-01-02T00:00:00.000Z")',
+      };
+    default:
+      if (fieldType === "decimal") return { sample: '"0"', next: '"1"' };
+      if (fieldType === "uuid") {
+        return {
+          sample: '"00000000-0000-0000-0000-000000000000"',
+          next: '"00000000-0000-0000-0000-000000000001"',
+        };
+      }
+      if (fieldType === "datetime") {
+        return {
+          sample: '"2024-01-01T00:00:00.000Z"',
+          next: '"2024-01-02T00:00:00.000Z"',
+        };
+      }
+      return { sample: '"sample"', next: '"sample-next"' };
+  }
+};
+
+const listElemType = (
+  field: TypeField,
+  convertTypes: (text: string) => string,
+): string =>
+  field.kind === "primitive"
+    ? convertSpecType(field.base)
+    : convertTypes(field.base);
+
+const fieldTokens = (
+  field: TypeField,
+  convertTypes: (text: string) => string,
+  convertFields: (name: string) => string,
+  typesByName: Map<string, Type>,
+): FieldTok => {
+  const ident = convertFields(field.name);
+  const dict = dictionaryOfField(field, typesByName);
+  const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+  if (entry !== undefined) {
+    const keyType =
+      entry.key.kind === "primitive"
+        ? convertSpecType(entry.key.base)
+        : convertTypes(entry.key.base);
+    const valueType =
+      entry.value.kind === "primitive"
+        ? convertSpecType(entry.value.base)
+        : convertTypes(entry.value.base);
+    const sample =
+      entry.value.kind === "primitive"
+        ? samplesForNative(valueType, entry.value.base).sample
+        : `new ${valueType}()`;
+    const next =
+      entry.value.kind === "primitive"
+        ? samplesForNative(valueType, entry.value.base).next
+        : `new ${valueType}()`;
+    return {
+      ident,
+      sampleExpr: `new Dictionary<${keyType}, ${valueType}> { ["k"] = ${sample} }`,
+      nextExpr: `new Dictionary<${keyType}, ${valueType}> { ["n"] = ${next} }`,
+      nullable: field.isNullable,
+      getsTest: convertTypes(`gets_${field.name}`),
+      setsTest: convertTypes(`sets_${field.name}`),
+      allowsNullTest: convertTypes(`allows_setting_${field.name}_to_null`),
+    };
+  }
+  if (field.kind === "primitive") {
+    const pair = samplesForNative(
+      convertSpecType(field.base),
+      field.base,
+    );
+    const elem = listElemType(field, convertTypes);
+    return {
+      ident,
+      sampleExpr: field.isArray
+        ? `new List<${elem}> { ${pair.sample} }`
+        : pair.sample,
+      nextExpr: field.isArray
+        ? `new List<${elem}> { ${pair.next} }`
+        : pair.next,
+      nullable: field.isNullable,
+      getsTest: convertTypes(`gets_${field.name}`),
+      setsTest: convertTypes(`sets_${field.name}`),
+      allowsNullTest: convertTypes(`allows_setting_${field.name}_to_null`),
+    };
+  }
+  const cls = convertTypes(field.base);
+  const obj = `new ${cls}()`;
+  return {
+    ident,
+    sampleExpr: field.isArray ? `new List<${cls}> { ${obj} }` : obj,
+    nextExpr: field.isArray ? `new List<${cls}> { ${obj} }` : obj,
+    nullable: field.isNullable,
+    getsTest: convertTypes(`gets_${field.name}`),
+    setsTest: convertTypes(`sets_${field.name}`),
+    allowsNullTest: convertTypes(`allows_setting_${field.name}_to_null`),
+  };
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    return viewTypesOf(deterministic).map((view) =>
+      this.tests(view, typesByName),
+    );
+  }
+
+  private tests(view: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const fields = view.fields.map((f) =>
+      fieldTokens(
+        f,
+        (text) => this.casing.convertTypes(text),
+        (name) => this.casing.convertFields(name),
+        typesByName,
+      ),
+    );
+    return content(
+      this.imports.test(this.imports.view(view.name), view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        className: this.casing.convertTypes(view.name),
+        testClassName: this.casing.testClassName(view.name),
+        isShaped: true,
+        isUnion: false,
+        needsList: view.fields.some((f) => f.isArray || f.isMap === true),
+        fields,
+        members: [],
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  );
+};

package/node_modules/@deterministic-code/csharp-generators/src/generate-view-types.ts

@@ -0,0 +1,118 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  fieldTypeOf,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  classParent,
+  declaredFields,
+  isUnionLike,
+  withClassParents,
+} from "./common/view-shape.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  typeHasTag,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import {
+  convertSpecType,
+  nativeDefaultExpr,
+} from "./deterministic-type-converter.ts";
+import { Emit } from "./emit.ts";
+import { typeTmpl } from "./resources/view-types.ts";
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    return withClassParents(
+      viewTypesOf(deterministic),
+      "view",
+      typesByName,
+    ).map((view) => this.view(view, typesByName));
+  }
+
+  private csPart(field: TypeField, typesByName: Map<string, Type>): string {
+    if (field.kind === "primitive") return convertSpecType(field.base);
+    const nested = typesByName.get(field.base);
+    return nested !== undefined && typeHasTag(nested, "view_type")
+      ? this.casing.convertTypes(field.base)
+      : this.imports.datasourceQual(field.base);
+  }
+
+  private csTypeFor(field: TypeField, typesByName: Map<string, Type>): string {
+    const dict = dictionaryOfField(field, typesByName);
+    const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+    let base: string;
+    if (entry !== undefined) {
+      base = `Dictionary<${this.csPart(entry.key, typesByName)}, ${this.csPart(entry.value, typesByName)}>`;
+    } else {
+      base = this.csPart(field, typesByName);
+      if (field.isArray) base = `List<${base}>`;
+    }
+    return field.isNullable ? `${base}?` : base;
+  }
+
+  private extendsType(parent: { name: string; lane: "view" | "datasource" }): string {
+    return parent.lane === "view"
+      ? this.casing.convertTypes(parent.name)
+      : this.imports.datasourceQual(parent.name);
+  }
+
+  private view(
+    view: Type,
+    typesByName: Map<string, Type>,
+  ): GenerateEntry {
+    const className = this.casing.convertTypes(view.name);
+    const isUnion = isUnionLike(view);
+    const parent = classParent(view, "view", typesByName);
+    const fields = declaredFields(view, "view", typesByName).map((f) => {
+      const initializer =
+        f.kind === "primitive"
+          ? nativeDefaultExpr(fieldTypeOf(f, typesByName), f)
+          : undefined;
+      return {
+        ident: this.casing.convertFields(f.name),
+        csType: this.csTypeFor(f, typesByName),
+        hasInitializer: initializer !== undefined,
+        initializer: initializer ?? "",
+      };
+    });
+    const needsList = fields.some(
+      (f) => f.csType.startsWith("List<") || f.csType.startsWith("Dictionary<"),
+    );
+    return content(
+      this.imports.view(view.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        needsList,
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        className,
+        datasourceType: view.inherits ?? "standard",
+        target: isUnion ? "UnionView" : "ShapedView",
+        fieldCount: String(fields.length),
+        hasExtends: parent !== undefined,
+        extendsType: parent === undefined ? "" : this.extendsType(parent),
+        fields,
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  );
+};

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

@@ -0,0 +1,266 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createImportGenerator } from "./import-generator.ts";
+
+const layered = () => createImportGenerator(".", {});
+const byFeature = (extra: Record<string, string> = {}) =>
+  createImportGenerator(".", {
+    "other.organize_by_feature": "true",
+    ...extra,
+  });
+const flat = (basePath: string, extra: Record<string, string> = {}) =>
+  createImportGenerator(basePath, extra);
+
+describe("CsharpImportGenerator layered (organize_by_feature unset)", () => {
+  it("emits Pascal files and Pascal type quals", () => {
+    const imports = layered();
+    assert.equal(imports.datasource("user"), "Types/Datasource/Generated/User.cs");
+    assert.equal(
+      imports.datasourceRel("user"),
+      "Types/Datasource/Generated/User.cs",
+    );
+    assert.equal(
+      imports.datasourceQual("user"),
+      "Backend.Types.Datasource.User",
+    );
+    assert.equal(
+      imports.datasourceValidator("user"),
+      "Types/Datasource/Generated/Validators/DatasourceUserValidator.cs",
+    );
+    assert.equal(
+      imports.datasourceValidatorRel("user"),
+      "Types/Datasource/Generated/Validators/DatasourceUserValidator.cs",
+    );
+    assert.equal(
+      imports.view("card_payment"),
+      "Types/View/Generated/CardPayment.cs",
+    );
+    assert.equal(
+      imports.viewRel("card_payment"),
+      "Types/View/Generated/CardPayment.cs",
+    );
+    assert.equal(imports.viewQual("card_payment"), "Backend.Types.View.CardPayment");
+    assert.equal(
+      imports.viewValidator("user"),
+      "Types/View/Generated/Validators/UserValidator.cs",
+    );
+    assert.equal(
+      imports.viewValidatorRel("user"),
+      "Types/View/Generated/Validators/UserValidator.cs",
+    );
+    assert.equal(imports.service("user"), "UserService.cs");
+    assert.equal(imports.serviceRel("user"), "UserService.cs");
+    assert.equal(imports.serviceCustom("ReportService"), "../custom/ReportService.cs");
+    assert.equal(
+      imports.serviceCustom("health-check-service"),
+      "../custom/HealthCheckService.cs",
+    );
+    assert.equal(
+      imports.serviceCustomRel("user"),
+      "../custom/User.cs",
+    );
+    assert.equal(imports.serviceTest("user"), "UserServiceTests.cs");
+    assert.equal(imports.serviceTestRel("user"), "UserServiceTests.cs");
+    assert.equal(imports.serviceIntegrationTest("user"), "UserServiceTests.cs");
+    assert.equal(
+      imports.serviceIntegrationTestRel("user"),
+      "UserServiceTests.cs",
+    );
+    assert.equal(imports.serviceUse("user", "UserService"), "");
+    assert.equal(imports.route("user"), "UsersRouter.cs");
+    assert.equal(imports.route("card_payment"), "CardPaymentsRouter.cs");
+    assert.equal(imports.routeRel("user"), "UsersRouter.cs");
+    assert.equal(imports.routeModule("user"), "UsersRouter");
+    assert.equal(
+      imports.routeCustom("get_health"),
+      "../custom/GetHealthRoute.cs",
+    );
+    assert.equal(imports.routeTest("user"), "UsersRouterTests.cs");
+    assert.equal(imports.enrichment("role"), "RoleNameEnrichment.cs");
+    assert.equal(imports.test("User.cs", "user"), "UserTests.cs");
+    assert.equal(
+      imports.test(imports.datasource("user"), "user"),
+      "Types/Datasource/Generated/UserTests.cs",
+    );
+    assert.equal(
+      imports.test(imports.viewValidator("user"), "user"),
+      "Types/View/Generated/Validators/UserValidatorTests.cs",
+    );
+    assert.equal(
+      imports.test("UserValidator.cs", "user"),
+      "UserValidatorTests.cs",
+    );
+    assert.equal(
+      imports.test("DatasourceUserValidator.cs", "user"),
+      "UserValidatorTests.cs",
+    );
+    assert.equal(imports.testSpec("User.cs", "user"), "");
+    assert.equal(imports.index("User.cs"), "");
+    assert.equal(imports.spec("UserService.cs", "User.cs"), "Backend.Types.Datasource");
+    assert.equal(imports.appWiring(), "");
+    assert.equal(imports.validatorFn("datasource", "user", "x"), "");
+    assert.equal(imports.validatorFn("view", "user", "x"), "");
+    assert.equal(imports.apiPath("card_payment"), "card-payment");
+    assert.equal(imports.frontend("src/App.cs"), "frontend/src/App.cs");
+  });
+
+  it("cases file names from settings for every lane", () => {
+    assert.equal(
+      layered().datasource("notification_type"),
+      "Types/Datasource/Generated/NotificationType.cs",
+    );
+    assert.equal(
+      layered().view("notification_type"),
+      "Types/View/Generated/NotificationType.cs",
+    );
+    assert.equal(
+      layered().service("notification_type"),
+      "NotificationTypeService.cs",
+    );
+    const pascal = createImportGenerator(".", {
+      "languages.csharp.casing.file_names": "Pascal",
+    });
+    assert.equal(
+      pascal.datasource("notification_type"),
+      "Types/Datasource/Generated/NotificationType.cs",
+    );
+    assert.equal(
+      pascal.view("notification_type"),
+      "Types/View/Generated/NotificationType.cs",
+    );
+    assert.equal(pascal.service("notification_type"), "NotificationTypeService.cs");
+    const snake = createImportGenerator(".", {
+      "languages.csharp.casing.file_names": "Snake",
+    });
+    assert.equal(
+      snake.datasource("notification_type"),
+      "Types/Datasource/Generated/notification_type.cs",
+    );
+  });
+
+  it("cases type quals from settings independently of files", () => {
+    const snakeTypes = createImportGenerator(".", {
+      "languages.csharp.casing.types": "Snake",
+    });
+    assert.equal(snakeTypes.view("user"), "Types/View/Generated/User.cs");
+    assert.equal(
+      snakeTypes.datasourceQual("notification_type"),
+      "Backend.Types.Datasource.notification_type",
+    );
+    assert.equal(snakeTypes.viewQual("user"), "Backend.Types.View.user");
+  });
+
+  it("treats organize_by_feature values other than true as layered", () => {
+    for (const value of ["", "false", "TRUE", "1"]) {
+      const imports = createImportGenerator(".", {
+        "other.organize_by_feature": value,
+      });
+      assert.equal(
+        imports.datasource("user"),
+        "Types/Datasource/Generated/User.cs",
+        value,
+      );
+      assert.equal(imports.serviceCustom("ReportService"), "../custom/ReportService.cs", value);
+    }
+  });
+});
+
+describe("CsharpImportGenerator by-feature", () => {
+  it("nests datasource files under Features/ and leaves view files layered", () => {
+    const imports = byFeature({
+      "languages.csharp.casing.file_names": "Pascal",
+      "languages.csharp.casing.directories": "Kebab",
+    });
+    assert.equal(
+      imports.datasource("notification_type"),
+      "Features/notification-type/NotificationType.cs",
+    );
+    assert.equal(
+      imports.datasourceRel("notification_type"),
+      "Features/notification-type/NotificationType.cs",
+    );
+    assert.equal(imports.view("user"), "User.cs");
+    assert.equal(imports.viewRel("user"), "User.cs");
+    assert.equal(imports.service("user"), "UserService.cs");
+  });
+
+  it("uses Pascal datasource files under a Pascal feature directory", () => {
+    const imports = byFeature();
+    assert.equal(
+      imports.datasource("notification_type"),
+      "Features/NotificationType/NotificationType.cs",
+    );
+    assert.equal(imports.datasource("user"), "Features/User/User.cs");
+    assert.equal(imports.frontend("Pages/Index.cshtml"), "frontend/Pages/Index.cshtml");
+  });
+
+  it("places custom stubs under Features/<dir>/custom/", () => {
+    const imports = byFeature({
+      "languages.csharp.casing.directories": "Kebab",
+    });
+    assert.equal(
+      imports.serviceCustom("user"),
+      "Features/user/custom/User.cs",
+    );
+    assert.equal(
+      imports.serviceCustom("create_card_payment"),
+      "Features/card-payment/custom/CreateCardPayment.cs",
+    );
+    assert.equal(
+      imports.serviceCustom("update_card_payment"),
+      "Features/card-payment/custom/UpdateCardPayment.cs",
+    );
+    assert.equal(
+      imports.serviceCustomRel("notification_type"),
+      "Features/notification-type/custom/NotificationType.cs",
+    );
+    assert.equal(
+      imports.routeCustom("get_health"),
+      "Features/get-health/custom/GetHealthRoute.cs",
+    );
+    assert.equal(
+      imports.routeCustom("create_card_payment"),
+      "Features/card-payment/custom/CreateCardPaymentRoute.cs",
+    );
+    assert.equal(
+      imports.serviceCustom("user", "./ignored/module"),
+      "Features/user/custom/User.cs",
+    );
+  });
+
+  it("uses Snake feature directories when casing.directories is Snake", () => {
+    const imports = byFeature({
+      "languages.csharp.casing.file_names": "Pascal",
+      "languages.csharp.casing.directories": "Snake",
+    });
+    assert.equal(
+      imports.datasource("notification_type"),
+      "Features/notification_type/NotificationType.cs",
+    );
+    assert.equal(
+      imports.serviceCustomRel("notification_type"),
+      "Features/notification_type/custom/NotificationType.cs",
+    );
+  });
+});
+
+describe("CsharpImportGenerator flat basePath", () => {
+  it("ignores organize_by_feature and prefixes the directory", () => {
+    const imports = flat("Backend/Types", {
+      "other.organize_by_feature": "true",
+      "languages.csharp.casing.file_names": "Pascal",
+    });
+    assert.equal(imports.datasource("user"), "Backend/Types/User.cs");
+    assert.equal(imports.view("user"), "Backend/Types/User.cs");
+    assert.equal(imports.serviceCustom("ReportService"), "Backend/Types/../custom/ReportService.cs");
+    assert.equal(imports.test("User.cs", "user"), "Backend/Types/UserTests.cs");
+  });
+
+  it("treats empty basePath as backend layout, not flat", () => {
+    const imports = createImportGenerator("", {
+      "other.organize_by_feature": "true",
+      "languages.csharp.casing.file_names": "Pascal",
+    });
+    assert.equal(imports.datasource("user"), "Features/User/User.cs");
+  });
+});