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

package/node_modules/@deterministic-code/csharp-generators/src/generate-datasource-type-validators-tests.ts

@@ -0,0 +1,207 @@
+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 {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+} 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/datasource-type-validators-tests.ts";
+
+type FieldTok = {
+  name: string;
+  ident: string;
+  sampleExpr: string;
+  isNullable: boolean;
+  type: string;
+};
+
+type CaseTok = {
+  ident: string;
+  fixture: string;
+  assertion: string;
+};
+
+const samplesForNative = (
+  native: string,
+  fieldType: string,
+): { sample: string; next: string } => {
+  switch (native) {
+    case "int":
+      return { sample: "1", next: "2" };
+    case "long":
+      return { sample: "1L", next: "2L" };
+    case "short":
+      return { sample: "(short)1", next: "(short)2" };
+    case "uint":
+      return { sample: "1U", next: "2U" };
+    case "ulong":
+      return { sample: "1UL", next: "2UL" };
+    case "ushort":
+      return { sample: "(ushort)1", next: "(ushort)2" };
+    case "double":
+      return { sample: "1.0", next: "2.0" };
+    case "bool":
+      return { sample: "false", next: "true" };
+    case "System.Guid":
+      return {
+        sample: 'System.Guid.Parse("00000000-0000-0000-0000-000000000000")',
+        next: 'System.Guid.Parse("00000000-0000-0000-0000-000000000001")',
+      };
+    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")',
+      };
+    case "string":
+      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"' };
+    default:
+      throw new Error(`Unknown csharp native type: ${native}`);
+  }
+};
+
+const fieldTok = (
+  field: TypeField,
+  convertFields: (name: string) => string,
+  typesByName: ReadonlyMap<string, Type>,
+): FieldTok => {
+  const specType = fieldTypeOf(field, typesByName);
+  const { sample } = samplesForNative(
+    convertSpecType(specType),
+    specType,
+  );
+  return {
+    name: field.name,
+    ident: convertFields(field.name),
+    sampleExpr: sample,
+    isNullable: field.isNullable,
+    type: specType,
+  };
+};
+
+const objectLiteral = (
+  cls: string,
+  fields: Array<{ ident: string; expr: string }>,
+): string =>
+  `new ${cls} { ${fields.map((f) => `${f.ident} = ${f.expr}`).join(", ")} }`;
+
+const casesFor = (
+  cls: string,
+  fields: FieldTok[],
+  convertTypes: (text: string) => string,
+): CaseTok[] => {
+  const valid = objectLiteral(
+    cls,
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr })),
+  );
+  const cases: CaseTok[] = [
+    { ident: "ParsesAValidPayload", fixture: valid, assertion: "True" },
+  ];
+  if (fields.some((f) => f.isNullable)) {
+    cases.push({
+      ident: "AcceptsNullForNullableFields",
+      fixture: objectLiteral(
+        cls,
+        fields.map((f) => ({
+          ident: f.ident,
+          expr: f.isNullable ? "null" : f.sampleExpr,
+        })),
+      ),
+      assertion: "True",
+    });
+  }
+  for (const field of fields) {
+    if (!field.isNullable && field.type === "string") {
+      cases.push({
+        ident: convertTypes(`rejects_null_for_${field.name}`),
+        fixture: objectLiteral(
+          cls,
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === field.ident ? "null" : f.sampleExpr,
+          })),
+        ),
+        assertion: "False",
+      });
+    }
+    if (field.type === "uuid") {
+      cases.push({
+        ident: convertTypes(`rejects_when_invalid_uuid_on_${field.name}`),
+        fixture: objectLiteral(
+          cls,
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === field.ident ? '"not-a-uuid"' : f.sampleExpr,
+          })),
+        ),
+        assertion: "False",
+      });
+    }
+  }
+  return cases;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    return datasourceTypesOf(deterministic).map((table) =>
+      this.tests(table, typesByName),
+    );
+  }
+
+  private tests(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const fields = persistedColumnFields(table, typesByName).map((f) =>
+      fieldTok(f, (name) => this.casing.convertFields(name), typesByName),
+    );
+    const className = this.casing.convertTypes(table.name);
+    return content(
+      this.imports.test(this.imports.datasourceValidator(table.name), table.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        className,
+        testClassName: this.casing.validatorTestClassName(table.name),
+        validatorClass: this.casing.convertTypes(
+          `datasource_${table.name}_validator`,
+        ),
+        cases: casesFor(className, fields, (text) =>
+          this.casing.convertTypes(text),
+        ),
+      }),
+    );
+  }
+}
+
+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-datasource-type-validators.ts

@@ -0,0 +1,227 @@
+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 {
+  datasourceTypesOf,
+  fieldTypeOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  classParent,
+  declaredFields,
+  withClassParents,
+} from "./common/view-shape.ts";
+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 { typeTmpl } from "./resources/datasource-type-validators.ts";
+
+type FieldShape = {
+  name: string;
+  type: string;
+  isNullable: boolean;
+  references?: TypeField["references"];
+  minSize?: number;
+  size?: TypeField["size"];
+};
+
+const STANDARD_COLUMN_NAMES = new Set(["id", "uuid", "created", "updated"]);
+
+const UUID_PATTERN =
+  "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+
+const numericLiteralForNative = (
+  native: string,
+  value: number,
+): string | null => {
+  switch (native) {
+    case "int":
+      return String(value);
+    case "long":
+      return `${value}L`;
+    case "short":
+      return `(short)${value}`;
+    case "uint":
+      return `${value}U`;
+    case "ulong":
+      return `${value}UL`;
+    case "ushort":
+      return `(ushort)${value}`;
+    case "double":
+      return Number.isInteger(value) ? `${value}.0` : String(value);
+    default:
+      return null;
+  }
+};
+
+const numericLiteral = (fieldType: string, value: number): string => {
+  const native = convertSpecType(fieldType);
+  return numericLiteralForNative(native, value) ?? String(value);
+};
+
+const tightenString = (field: FieldShape): string[] => {
+  const rules: string[] = [];
+  if (field.minSize !== undefined && field.minSize >= 0) {
+    rules.push(`MinimumLength(${field.minSize})`);
+  }
+  if (typeof field.size === "number" && field.size >= 0) {
+    rules.push(`MaximumLength(${field.size})`);
+  }
+  return rules;
+};
+
+const tightenNumber = (field: FieldShape): string[] => {
+  const rules: string[] = [];
+  const lit = (v: number) => numericLiteral(field.type, v);
+  const isFk =
+    typeof field.references === "string" && field.references.length > 0;
+  const isIdLike = field.name === "id" || field.name.endsWith("_id");
+  if (isFk || isIdLike) {
+    rules.push(`GreaterThanOrEqualTo(${lit(0)})`);
+  } else if (field.minSize !== undefined) {
+    rules.push(`GreaterThanOrEqualTo(${lit(field.minSize)})`);
+  }
+  if (typeof field.size === "number") {
+    rules.push(`LessThanOrEqualTo(${lit(field.size)})`);
+  }
+  return rules;
+};
+
+const tightenFloat = (field: FieldShape): string[] => {
+  const rules: string[] = [];
+  if (field.minSize !== undefined) {
+    rules.push(
+      `GreaterThanOrEqualTo(${numericLiteral(field.type, field.minSize)})`,
+    );
+  }
+  if (typeof field.size === "number") {
+    rules.push(
+      `LessThanOrEqualTo(${numericLiteral(field.type, field.size)})`,
+    );
+  }
+  return rules;
+};
+
+const tightenedRulesFor = (field: FieldShape): string[] => {
+  switch (field.type) {
+    case "string":
+    case "character":
+      return tightenString(field);
+    case "uuid":
+      return [`Matches("${UUID_PATTERN}")`];
+    case "number":
+    case "integer":
+    case "smallinteger":
+    case "biginteger":
+    case "reference":
+      return tightenNumber(field);
+    case "float":
+      return tightenFloat(field);
+    default:
+      return [];
+  }
+};
+
+const ruleLine = (
+  field: FieldShape,
+  convertFields: (name: string) => string,
+): string => {
+  const prop = convertFields(field.name);
+  const tightened = tightenedRulesFor(field);
+  const parts: string[] = [];
+  if (!field.isNullable) parts.push("NotNull()");
+  for (const r of tightened) parts.push(r);
+  if (parts.length === 0) {
+    return `        RuleFor(x => x.${prop});`;
+  }
+  const head = `        RuleFor(x => x.${prop})`;
+  const chain = parts.map((p) => `            .${p}`).join("\n");
+  if (field.isNullable && tightened.length > 0) {
+    return `${head}\n${chain}\n            .When(x => x.${prop} != null);`;
+  }
+  return `${head}\n${chain};`;
+};
+
+const standardRuleLine = (
+  name: string,
+  idType: string,
+  convertFields: (name: string) => string,
+): string => {
+  const prop = convertFields(name);
+  if (name === "id") {
+    const bound = numericLiteralForNative(
+      convertSpecType(idType),
+      0,
+    );
+    const numeric = bound
+      ? `\n            .GreaterThanOrEqualTo(${bound})`
+      : "";
+    return `        RuleFor(x => x.${prop})\n            .NotNull()${numeric};`;
+  }
+  return `        RuleFor(x => x.${prop})\n            .NotNull();`;
+};
+
+class Generator extends Emit {
+  private readonly namespace = "Backend.Validators.Datasource";
+  private readonly typesNamespace = "Backend.Types.Datasource";
+
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((type) => [type.name, type]),
+    );
+    return withClassParents(
+      datasourceTypesOf(deterministic),
+      "datasource",
+      typesByName,
+    ).map((table) => this.validator(table, typesByName));
+  }
+
+  private validator(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const className = this.casing.convertTypes(table.name);
+    const convertFields = (name: string): string =>
+      this.casing.convertFields(name);
+    const parent = classParent(table, "datasource", typesByName);
+    const include =
+      parent === undefined
+        ? null
+        : `        Include(new ${this.casing.convertTypes(`datasource_${parent.name}_validator`)}());`;
+    const fieldRules = declaredFields(table, "datasource", typesByName).map(
+      (field: TypeField) => {
+        const resolved = { ...field, type: fieldTypeOf(field, typesByName) };
+        return STANDARD_COLUMN_NAMES.has(field.name)
+          ? standardRuleLine(field.name, resolved.type, convertFields)
+          : ruleLine(resolved, convertFields);
+      },
+    );
+    const rules = [include, ...fieldRules].filter(
+      (line): line is string => line !== null && line !== "",
+    );
+    return content(
+      this.imports.datasourceValidator(table.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        namespace: this.namespace,
+        typesNamespace: this.typesNamespace,
+        className,
+        validatorClass: this.casing.convertTypes(
+          `datasource_${table.name}_validator`,
+        ),
+        rules: rules.map((line) => ({ line })),
+      }),
+    );
+  }
+}
+
+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-datasource-types-tests.ts

@@ -0,0 +1,143 @@
+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 {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+} 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/datasource-types-tests.ts";
+
+const samplesForNative = (
+  native: string,
+  fieldType: string,
+): { sample: string; next: string } => {
+  switch (native) {
+    case "int":
+      return { sample: "1", next: "2" };
+    case "long":
+      return { sample: "1L", next: "2L" };
+    case "short":
+      return { sample: "(short)1", next: "(short)2" };
+    case "uint":
+      return { sample: "1U", next: "2U" };
+    case "ulong":
+      return { sample: "1UL", next: "2UL" };
+    case "ushort":
+      return { sample: "(ushort)1", next: "(ushort)2" };
+    case "double":
+      return { sample: "1.0", next: "2.0" };
+    case "bool":
+      return { sample: "false", next: "true" };
+    case "System.Guid":
+      return {
+        sample: 'System.Guid.Parse("00000000-0000-0000-0000-000000000000")',
+        next: 'System.Guid.Parse("00000000-0000-0000-0000-000000000001")',
+      };
+    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")',
+      };
+    case "string":
+      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"',
+        };
+      }
+      if (fieldType === "date") {
+        return { sample: '"2024-01-01"', next: '"2024-01-02"' };
+      }
+      if (fieldType === "email") {
+        return {
+          sample: '"sample@example.com"',
+          next: '"next@example.com"',
+        };
+      }
+      return { sample: '"sample"', next: '"sample-next"' };
+    default:
+      throw new Error(`Unknown csharp native type: ${native}`);
+  }
+};
+
+const fieldTokens = (
+  field: TypeField,
+  convertFields: (name: string) => string,
+  convertTypes: (name: string) => string,
+  typesByName: ReadonlyMap<string, Type>,
+) => {
+  const ident = convertFields(field.name);
+  const specType = fieldTypeOf(field, typesByName);
+  const native = convertSpecType(specType);
+  const { sample, next } = samplesForNative(native, specType);
+  return {
+    ident,
+    sampleExpr: sample,
+    nextExpr: next,
+    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 datasourceTypesOf(deterministic).map((table) =>
+      this.tests(table, typesByName),
+    );
+  }
+
+  private tests(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const fields = persistedColumnFields(table, typesByName).map((f) =>
+      fieldTokens(
+        f,
+        (name) => this.casing.convertFields(name),
+        (name) => this.casing.convertTypes(name),
+        typesByName,
+      ),
+    );
+    return content(
+      this.imports.test(this.imports.datasource(table.name), table.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        className: this.casing.convertTypes(table.name),
+        testClassName: this.casing.testClassName(table.name),
+        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/generate-datasource-types.ts

@@ -0,0 +1,86 @@
+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 {
+  datasourceTypesOf,
+  fieldTypeOf,
+  tableKind,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import {
+  classParent,
+  declaredFields,
+  withClassParents,
+} from "./common/view-shape.ts";
+import {
+  convertSpecType,
+  nativeDefaultExpr,
+} from "./deterministic-type-converter.ts";
+import { Emit } from "./emit.ts";
+import { typeTmpl } from "./resources/datasource-types.ts";
+
+const csTypeFor = (
+  field: TypeField,
+  typesByName: ReadonlyMap<string, Type>,
+): string => {
+  const t = convertSpecType(fieldTypeOf(field, typesByName));
+  return field.isNullable ? `${t}?` : t;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((type) => [type.name, type]),
+    );
+    return withClassParents(
+      datasourceTypesOf(deterministic),
+      "datasource",
+      typesByName,
+    ).map((table) => this.type(table, typesByName));
+  }
+
+  private type(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    const { schemaVersion, simpleDoc, descriptionDoc } = this.settings;
+    const parent = classParent(table, "datasource", typesByName);
+    const fields = declaredFields(table, "datasource", typesByName).map((f) => {
+      const initializer = nativeDefaultExpr(fieldTypeOf(f, typesByName), f);
+      return {
+        ident: this.casing.convertFields(f.name),
+        csType: csTypeFor(f, typesByName),
+        hasInitializer: initializer !== undefined,
+        initializer: initializer ?? "",
+      };
+    });
+    const className = this.casing.convertTypes(table.name);
+    return content(
+      this.imports.datasource(table.name),
+      fill(typeTmpl, {
+        schemaVersion,
+        simpleDoc,
+        descriptionDoc,
+        className,
+        datasourceType: tableKind(table),
+        fieldCount: String(fields.length),
+        hasExtends: parent !== undefined,
+        extendsType:
+          parent === undefined ? "" : this.casing.convertTypes(parent.name),
+        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/generate-routes-tests.ts

@@ -0,0 +1,29 @@
+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 { DeterministicParser, ROUTES_YAML, type IDeterministic } from "./specification-parser.ts";
+import { Emit } from "./emit.ts";
+import { genericTmpl } from "./resources/routes-tests.ts";
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    return deterministic.routes.candidates.map((c) => {
+      const testClass = this.casing.convertTypes(
+        `${this.imports.routeModule(c.name)}_tests`,
+      );
+      return content(
+        this.imports.routeTest(c.name),
+        fill(genericTmpl, { testClass }),
+      );
+    });
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(ROUTES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  );
+};