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

package/node_modules/@deterministic-code/csharp-generators/src/common/default-casing.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createCasing } from "./default-casing.ts";
+
+const NAME = "notification_type";
+
+describe("createCasing Auto defaults", () => {
+  it("uses Pascal file names and Pascal types and fields", () => {
+    const casing = createCasing({});
+    assert.equal(casing.convertFileName(NAME), "NotificationType");
+    assert.equal(casing.convertTypes(NAME), "NotificationType");
+    assert.equal(casing.convertFields(NAME), "NotificationType");
+    assert.equal(casing.convertDirectories(NAME), "NotificationType");
+    assert.equal(casing.filePath(NAME), "NotificationType.cs");
+    assert.equal(casing.serviceClassName("user"), "UserService");
+    assert.equal(casing.serviceInterfaceName("contact"), "IContactService");
+    assert.equal(
+      casing.authoredInterfaceName("ContactImportService"),
+      "IContactImportService",
+    );
+    assert.equal(casing.interfaceName("usersRouter"), "IUsersRouter");
+    assert.equal(casing.nameSourceInterfaceName("role"), "IRoleNameSource");
+    assert.equal(casing.testClassName("user"), "UserTests");
+    assert.equal(casing.getsTestName("nick_name"), "GetsNickName");
+  });
+});
+
+describe("createCasing overrides", () => {
+  it("pascals file names", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.file_names": "Pascal",
+    });
+    assert.equal(casing.filePath(NAME), "NotificationType.cs");
+  });
+
+  it("snakes file names", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.file_names": "Snake",
+    });
+    assert.equal(casing.filePath(NAME), "notification_type.cs");
+  });
+
+  it("camels fields", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.fields": "Camel",
+    });
+    assert.equal(casing.convertFields("role_id"), "roleId");
+  });
+
+  it("snakes fields", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.fields": "Snake",
+    });
+    assert.equal(casing.convertFields("RoleId"), "role_id");
+  });
+
+  it("snakes authored interface names from the i_ stem", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.types": "Snake",
+    });
+    assert.equal(
+      casing.authoredInterfaceName("ContactImportService"),
+      "i_contact_import_service",
+    );
+  });
+
+  it("kebabs directories", () => {
+    const casing = createCasing({
+      "languages.csharp.casing.directories": "Kebab",
+    });
+    assert.equal(casing.directory(NAME), "notification-type");
+  });
+});

package/node_modules/@deterministic-code/csharp-generators/src/common/default-casing.ts

@@ -0,0 +1,79 @@
+import {
+  createCasingStrategy,
+  type ICasingStrategy,
+} from "@deterministic-code/generators-common/casing-strategy";
+
+export const GENERATOR_LANGUAGE = "csharp";
+
+const VARIANT_PREFIXES = ["update_", "create_"] as const;
+
+const featureEntity = (entity: string): string => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === undefined ? entity : entity.slice(prefix.length);
+};
+
+export type PackCasing = ICasingStrategy & {
+  fileBase: (stem: string) => string
+  directory: (entity: string) => string
+  filePath: (stem: string) => string
+  serviceClassName: (entity: string) => string
+  serviceInterfaceName: (entity: string) => string
+  authoredInterfaceName: (name: string) => string
+  interfaceName: (stem: string) => string
+  testClassName: (entity: string) => string
+  validatorTestClassName: (entity: string) => string
+  getsTestName: (field: string) => string
+  setsTestName: (field: string) => string
+  allowsNullTestName: (field: string) => string
+  acceptsMemberTestName: (name: string) => string
+  nameSourceInterfaceName: (target: string) => string
+  nameRowTypeName: (target: string) => string
+  enrichItemsMethodName: (target: string) => string
+  enrichItemMethodName: (target: string) => string
+};
+
+/** Language defaults + settings overrides. Layout (by-feature) lives on ImportGenerator. */
+export const createCasing = (
+  settings: Record<string, string>,
+): PackCasing => {
+  const casing = createCasingStrategy(GENERATOR_LANGUAGE, settings);
+  const fileBase = (stem: string): string => casing.convertFileName(stem);
+  const directory = (entity: string): string =>
+    casing.convertDirectories(featureEntity(entity));
+  const filePath = (stem: string): string => `${fileBase(stem)}.cs`;
+  return {
+    convertFileName: (text: string) => casing.convertFileName(text),
+    convertTypes: (text: string) => casing.convertTypes(text),
+    convertFields: (text: string) => casing.convertFields(text),
+    convertDirectories: (text: string) => casing.convertDirectories(text),
+    fileBase,
+    directory,
+    filePath,
+    serviceClassName: (entity: string) => casing.convertTypes(`${entity}_service`),
+    serviceInterfaceName: (entity: string) =>
+      casing.convertTypes(`i_${entity}_service`),
+    authoredInterfaceName: (name: string) => casing.convertTypes(`i_${name}`),
+    interfaceName: (stem: string) => casing.convertTypes(`i_${stem}`),
+    testClassName: (entity: string) => casing.convertTypes(`${entity}_tests`),
+    validatorTestClassName: (entity: string) =>
+      casing.convertTypes(`${entity}_validator_tests`),
+    getsTestName: (field: string) => casing.convertTypes(`gets_${field}`),
+    setsTestName: (field: string) => casing.convertTypes(`sets_${field}`),
+    allowsNullTestName: (field: string) =>
+      casing.convertTypes(`allows_setting_${field}_to_null`),
+    acceptsMemberTestName: (name: string) =>
+      casing.convertTypes(`accepts_${name}_member`),
+    nameSourceInterfaceName: (target: string) =>
+      casing.convertTypes(`i_${target}_name_source`),
+    nameRowTypeName: (target: string) =>
+      casing.convertTypes(`${target}_name_row`),
+    enrichItemsMethodName: (target: string) =>
+      casing.convertTypes(`enrich_items_with_${target}_name_async`),
+    enrichItemMethodName: (target: string) =>
+      casing.convertTypes(`enrich_item_with_${target}_name_async`),
+  };
+};
+
+export const defaultCasing = (
+  settings: Record<string, string>,
+): ICasingStrategy => createCasing(settings);

package/node_modules/@deterministic-code/csharp-generators/src/common/view-shape.ts

@@ -0,0 +1,124 @@
+import {
+  columnFields,
+  persistedColumnFields,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  typeHasTag,
+  type Type,
+  type TypeField,
+} from "../specification-parser.ts";
+
+const BUILTIN_PARENTS = new Set(["set", "dictionary", "file"]);
+
+export const isUnionLike = (type: Type): boolean => type.kind === "union";
+
+/** Dual-tagged types emit a view class that extends the datasource class. */
+export const viewExtendsDatasource = (view: Type): boolean =>
+  typeHasTag(view, "datasource_type") && typeHasTag(view, "view_type");
+
+export type ClassParent = {
+  name: string;
+  lane: "view" | "datasource";
+};
+
+const covers = (child: TypeField[], parent: TypeField[]): boolean => {
+  const names = new Set(child.map((field) => field.name));
+  return parent.every((field) => names.has(field.name));
+};
+
+/** Properties the generated class exposes. Datasource classes omit collection fields. */
+export const visibleFields = (
+  type: Type,
+  lane: "view" | "datasource",
+  typesByName?: Map<string, Type>,
+): TypeField[] =>
+  lane === "datasource"
+    ? typesByName !== undefined
+      ? persistedColumnFields(type, typesByName)
+      : columnFields(type.fields)
+    : type.fields;
+
+/**
+ * C# base class when `inherits` names a class and the child still has every
+ * parent property. `remove_fields` that drops a parent property stays a flat
+ * class, because C# cannot omit an inherited member. `set`, `dictionary`, and
+ * `file` are not classes. An untagged parent that exists in the spec is still
+ * a class. A dual-tagged view extends its datasource class.
+ */
+export const classParent = (
+  type: Type,
+  lane: "view" | "datasource",
+  typesByName: Map<string, Type>,
+): ClassParent | undefined => {
+  if (lane === "view" && viewExtendsDatasource(type)) {
+    const parentFields = visibleFields(
+      typesByName.get(type.name) ?? type,
+      "datasource",
+      typesByName,
+    );
+    if (!covers(visibleFields(type, "view", typesByName), parentFields)) {
+      return undefined;
+    }
+    return { name: type.name, lane: "datasource" };
+  }
+  const parentName = type.inherits;
+  if (parentName === undefined || BUILTIN_PARENTS.has(parentName)) {
+    return undefined;
+  }
+  const parent = typesByName.get(parentName);
+  if (parent === undefined) return undefined;
+  const parentLane: "view" | "datasource" =
+    lane === "view" &&
+    (typeHasTag(parent, "view_type") || !typeHasTag(parent, "datasource_type"))
+      ? "view"
+      : "datasource";
+  if (
+    !covers(
+      visibleFields(type, lane, typesByName),
+      visibleFields(parent, parentLane, typesByName),
+    )
+  ) {
+    return undefined;
+  }
+  return { name: parentName, lane: parentLane };
+};
+
+/** Tagged types plus class parents that this lane must emit (untagged bases). */
+export const withClassParents = (
+  types: readonly Type[],
+  lane: "view" | "datasource",
+  typesByName: Map<string, Type>,
+): Type[] => {
+  const seen = new Map(types.map((type) => [type.name, type]));
+  const visit = (type: Type): void => {
+    const parent = classParent(type, lane, typesByName);
+    if (parent === undefined || parent.lane !== lane || seen.has(parent.name)) {
+      return;
+    }
+    const parentType = typesByName.get(parent.name);
+    if (parentType === undefined) return;
+    seen.set(parentType.name, parentType);
+    visit(parentType);
+  };
+  for (const type of types) visit(type);
+  return [...seen.values()];
+};
+
+/** Fields declared on this class. Parent properties stay on the base class. */
+export const declaredFields = (
+  type: Type,
+  lane: "view" | "datasource",
+  typesByName: Map<string, Type>,
+): TypeField[] => {
+  const fields = visibleFields(type, lane, typesByName);
+  const parent = classParent(type, lane, typesByName);
+  if (parent === undefined) return fields;
+  const parentType = typesByName.get(parent.name);
+  if (parentType === undefined) return fields;
+  const parentNames = new Set(
+    visibleFields(parentType, parent.lane, typesByName).map(
+      (field) => field.name,
+    ),
+  );
+  return fields.filter((field) => !parentNames.has(field.name));
+};

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

@@ -0,0 +1,144 @@
+import {
+  DeterministicDefaultValueConverter,
+  type DefaultEntry,
+  type SpecToken,
+} from "@deterministic-code/generators-common/deterministic-default-value-converter";
+import { DeterministicTypeConverter } from "@deterministic-code/generators-common/deterministic-type-converter";
+import { hexToBytes } from "@deterministic-code/generators-common/default-token";
+
+const spec = DeterministicDefaultValueConverter.spec;
+
+const csString = (value: string): string => JSON.stringify(value);
+
+const token = (
+  specToken: SpecToken,
+  native: (arg: string) => string,
+  reverse: RegExp,
+): DefaultEntry => ({ ...specToken, native, reverse });
+
+const quoted = token(spec.string.String!, csString, /^"(.*)"$/);
+
+const numeric = (type: string): Record<string, DefaultEntry> => {
+  const numericSpec = spec[type]!.Numeric!;
+  return {
+    Numeric: token(numericSpec, (arg) => arg, numericSpec.spec),
+    String: token(numericSpec, (arg) => arg, numericSpec.spec),
+  };
+};
+
+export const typeConverter = new DeterministicTypeConverter({
+  string: "string",
+  character: "string",
+  number: "long",
+  integer: "long",
+  unsignedinteger: "uint",
+  smallinteger: "short",
+  unsignedsmallinteger: "ushort",
+  biginteger: "long",
+  unsignedbiginteger: "ulong",
+  float: "double",
+  decimal: "string",
+  boolean: "bool",
+  datetime: "System.DateTime",
+  binary: "byte[]",
+  uuid: "string",
+  reference: "long",
+});
+
+export const defaultValueConverter = new DeterministicDefaultValueConverter({
+  string: { String: quoted, Numeric: quoted },
+  character: { String: quoted, Numeric: quoted },
+  number: numeric("number"),
+  integer: numeric("integer"),
+  unsignedinteger: numeric("unsignedinteger"),
+  smallinteger: numeric("smallinteger"),
+  unsignedsmallinteger: numeric("unsignedsmallinteger"),
+  biginteger: numeric("biginteger"),
+  unsignedbiginteger: numeric("unsignedbiginteger"),
+  float: numeric("float"),
+  decimal: {
+    Numeric: token(spec.decimal.Numeric!, csString, /^"(.*)"$/),
+    String: quoted,
+  },
+  boolean: {
+    Boolean: token(
+      spec.boolean.Boolean!,
+      (arg) => (arg === "true" ? "true" : "false"),
+      /^(true|false)$/,
+    ),
+  },
+  datetime: {
+    Now: token(spec.datetime.Now!, () => "DateTime.Now", /^DateTime\.Now$/),
+    UtcNow: token(
+      spec.datetime.UtcNow!,
+      () => "DateTime.UtcNow",
+      /^DateTime\.UtcNow$/,
+    ),
+    DateTime: token(
+      spec.datetime.DateTime!,
+      (arg) => `DateTime.Parse(${csString(arg)})`,
+      /^DateTime\.Parse\("(.*)"\)$/,
+    ),
+  },
+  binary: {
+    Hex: token(
+      spec.binary.Hex!,
+      (arg) => `new byte[] { ${hexToBytes(arg).join(", ")} }`,
+      /^new byte\[\] \{ .* \}$/,
+    ),
+  },
+  uuid: {
+    NewId: token(
+      spec.uuid.NewId!,
+      () => "Guid.NewGuid().ToString()",
+      /^Guid\.NewGuid\(\)\.ToString\(\)$/,
+    ),
+    Empty: token(
+      spec.uuid.Empty!,
+      () => "Guid.Empty.ToString()",
+      /^Guid\.Empty\.ToString\(\)$/,
+    ),
+    Uuid: token(spec.uuid.Uuid!, csString, /^"(.*)"$/),
+  },
+  reference: {},
+});
+
+export const toNative = (specType: string): string =>
+  typeConverter.convert(specType);
+
+export const convertSpecType = toNative;
+
+const CS_NUMERIC = new Set([
+  "long",
+  "uint",
+  "short",
+  "ushort",
+  "ulong",
+  "double",
+]);
+
+const isCsZero = (specType: string, expr: string): boolean => {
+  const native = toNative(specType);
+  if (native === "bool") return expr === "false";
+  if (CS_NUMERIC.has(native)) return /^0(\.0+)?$/.test(expr);
+  return false;
+};
+
+/** Native initializer, or `undefined` when absent or the language zero. */
+export const nativeDefaultExpr = (
+  specType: string,
+  field: {
+    hasDefault?: boolean;
+    defaultValue?: string | number | boolean | null;
+    isNullable: boolean;
+  },
+): string | undefined => {
+  if (field.hasDefault !== true) return undefined;
+  const expr = defaultValueConverter.convert(
+    specType,
+    String(field.defaultValue),
+  );
+  if (expr === null) return undefined;
+  if (field.isNullable) return expr;
+  return isCsZero(specType, expr) ? undefined : expr;
+};

package/node_modules/@deterministic-code/csharp-generators/src/emit.ts

@@ -0,0 +1,22 @@
+import {
+  fromSettings,
+  type ISettings,
+} from "@deterministic-code/generators-common/settings";
+import { createCasing, type PackCasing } from "./common/default-casing.ts";
+import {
+  createImportGenerator,
+  type CsharpImportGenerator,
+} from "./import-generator.ts";
+
+/** Settings plus a pack import generator created once; lanes use `this.imports`. */
+export class Emit {
+  readonly settings: ISettings;
+  readonly casing: PackCasing;
+  readonly imports: CsharpImportGenerator;
+
+  constructor(raw: Record<string, string>, basePath = ".") {
+    this.settings = fromSettings(raw);
+    this.casing = createCasing(raw);
+    this.imports = createImportGenerator(basePath, raw);
+  }
+}

package/node_modules/@deterministic-code/csharp-generators/src/generate-backend-app.ts

@@ -0,0 +1,52 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  appCsproj,
+  appsettingsDevelopmentJson,
+  appsettingsJson,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  programCs,
+} from "./resources/backend-app.ts";
+
+const DEFAULT_APP_NAME = "generated-app";
+
+const projectNameFromAppName = (appName: string): string => {
+  const parts = appName
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .replace(/([0-9])([A-Za-z])/g, "$1 $2")
+    .replace(/([A-Za-z])([0-9])/g, "$1 $2")
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean);
+  if (parts.length === 0) return "App";
+  const pascal = parts
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase())
+    .join("");
+  return /^[A-Za-z]/.test(pascal) ? pascal : `App${pascal}`;
+};
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const projectName = projectNameFromAppName(
+    ctx.settings.application_name || DEFAULT_APP_NAME,
+  );
+  const named = { PROJECT_NAME: projectName };
+  return [
+    patch(`${projectName}.csproj`, fill(appCsproj, named)),
+    patch("Program.cs", programCs),
+    content("appsettings.json", appsettingsJson),
+    content("appsettings.Development.json", appsettingsDevelopmentJson),
+    patch("Dockerfile", fill(dockerfile, named)),
+    patch("scripts/entrypoint.sh", entrypointSh),
+    patch("docker-compose.yml", dockerComposeYml),
+    patch(".env", envFile),
+    patch(".env.example", envFile),
+    patch(".gitignore", gitignore),
+    patch(".dockerignore", "bin/\nobj/"),
+  ];
+};

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

@@ -0,0 +1 @@
+export type { GenerateContext } from "@deterministic-code/generators-common/generate-context";