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

package/node_modules/@deterministic-code/csharp-generators/dist/generate-datasource-types-tests.js

@@ -0,0 +1,127 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { convertSpecType } from "./deterministic-type-converter.js";
+import { Emit } from "./emit.js";
+import { typeTestTmpl } from "./resources/datasource-types-tests.js";
+const samplesForNative = (native, fieldType) => {
+  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, convertFields, convertTypes, typesByName) => {
+  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) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return datasourceTypesOf(deterministic).map(
+      (table) => this.tests(table, typesByName)
+    );
+  }
+  tests(table, typesByName) {
+    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
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

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

@@ -0,0 +1,75 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  tableKind
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import {
+  classParent,
+  declaredFields,
+  withClassParents
+} from "./common/view-shape.js";
+import {
+  convertSpecType,
+  nativeDefaultExpr
+} from "./deterministic-type-converter.js";
+import { Emit } from "./emit.js";
+import { typeTmpl } from "./resources/datasource-types.js";
+const csTypeFor = (field, typesByName) => {
+  const t = convertSpecType(fieldTypeOf(field, typesByName));
+  return field.isNullable ? `${t}?` : t;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((type) => [type.name, type])
+    );
+    return withClassParents(
+      datasourceTypesOf(deterministic),
+      "datasource",
+      typesByName
+    ).map((table) => this.type(table, typesByName));
+  }
+  type(table, typesByName) {
+    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 !== void 0,
+        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 !== void 0,
+        extendsType: parent === void 0 ? "" : this.casing.convertTypes(parent.name),
+        fields
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/csharp-generators/dist/generate-routes-tests.js

@@ -0,0 +1,27 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { DeterministicParser, ROUTES_YAML } from "./specification-parser.js";
+import { Emit } from "./emit.js";
+import { genericTmpl } from "./resources/routes-tests.js";
+class Generator extends Emit {
+  from(deterministic) {
+    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 })
+      );
+    });
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/csharp-generators/dist/generate-routes.js

@@ -0,0 +1,93 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { viewTypesOf } from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  ROUTES_YAML
+} from "./specification-parser.js";
+import { Emit } from "./emit.js";
+import {
+  customStubTmpl,
+  nameEnrichmentTmpl,
+  routerTmpl
+} from "./resources/routes.js";
+const refParent = (references) => {
+  if (typeof references !== "string") return void 0;
+  return references.split(".")[0];
+};
+const enrichmentTargets = (views, survivorNames) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const view of views) {
+    if (!survivorNames.has(view.name)) continue;
+    for (const field of view.fields) {
+      const target = refParent(field.references);
+      if (target === void 0 || seen.has(target)) continue;
+      seen.add(target);
+      out.push(target);
+    }
+  }
+  return out;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const { candidates, customs } = deterministic.routes;
+    const survivorNames = new Set(candidates.map((c) => c.name));
+    const targets = enrichmentTargets(
+      viewTypesOf(deterministic),
+      survivorNames
+    );
+    return [
+      ...candidates.map((c) => this.router(c)),
+      ...customs.map((c) => this.custom(c)),
+      ...targets.map((t) => this.enrichment(t))
+    ];
+  }
+  router(candidate) {
+    const moduleName = this.imports.routeModule(candidate.name);
+    const className = this.casing.convertTypes(moduleName);
+    return content(
+      this.imports.route(candidate.name),
+      fill(routerTmpl, {
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        className,
+        interfaceName: this.casing.interfaceName(moduleName)
+      })
+    );
+  }
+  custom(entry) {
+    const className = this.casing.convertTypes(`${entry.name}_route`);
+    return content(
+      this.imports.routeCustom(entry.name),
+      fill(customStubTmpl, {
+        interfaceName: this.casing.interfaceName(`${entry.name}_route`),
+        className
+      })
+    );
+  }
+  enrichment(targetTable) {
+    return content(
+      this.imports.enrichment(targetTable),
+      fill(nameEnrichmentTmpl, {
+        className: this.casing.convertTypes(`${targetTable}_name_enrichment`),
+        enrichItemsMethod: this.casing.enrichItemsMethodName(targetTable),
+        enrichItemMethod: this.casing.enrichItemMethodName(targetTable),
+        sourceInterfaceName: this.casing.nameSourceInterfaceName(targetTable),
+        rowTypeName: this.casing.nameRowTypeName(targetTable),
+        targetTable,
+        fkProp: this.casing.convertFields(`${targetTable}_id`),
+        nameProp: this.casing.convertFields(`${targetTable}_name`)
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/csharp-generators/dist/generate-service-tests.js

@@ -0,0 +1,29 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { DeterministicParser, SERVICES_YAML } from "./specification-parser.js";
+import { Emit } from "./emit.js";
+import { genericTmpl } from "./resources/service-tests.js";
+class Generator extends Emit {
+  from(deterministic) {
+    return deterministic.services.generics.map(
+      (c) => content(
+        this.imports.serviceTest(c.name),
+        fill(genericTmpl, {
+          testClass: this.casing.convertTypes(`${c.name}_service_tests`)
+        })
+      )
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity)
+    })
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/csharp-generators/dist/generate-services.js

@@ -0,0 +1,58 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { tableKind } from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  SERVICES_YAML
+} from "./specification-parser.js";
+import { Emit } from "./emit.js";
+import { customStubTmpl, genericTmpl } from "./resources/services.js";
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    const { generics, customs } = deterministic.services;
+    return [
+      ...generics.map((c) => this.generic(c, typesByName.get(c.name))),
+      ...customs.map((c) => this.custom(c))
+    ];
+  }
+  generic(candidate, type) {
+    const className = this.casing.serviceClassName(candidate.name);
+    return content(
+      this.imports.service(candidate.name),
+      fill(genericTmpl, {
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        className,
+        datasourceType: type === void 0 ? "standard" : tableKind(type)
+      })
+    );
+  }
+  custom(entry) {
+    const className = this.casing.convertTypes(entry.name);
+    const interfaceName = this.casing.interfaceName(entry.name);
+    return content(
+      this.imports.serviceCustom(entry.name, entry.module),
+      fill(customStubTmpl, {
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        interfaceName,
+        className
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity)
+    })
+  );
+};
+export {
+  generate
+};

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

@@ -0,0 +1,223 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { convertSpecType } from "./deterministic-type-converter.js";
+import { Emit } from "./emit.js";
+import { typeTestTmpl } from "./resources/view-type-validators-tests.js";
+const samplesForNative = (native, fieldType) => {
+  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 wrapValue = (expr, field, elemType, keyType = "string") => {
+  if (field.isMap === true) {
+    return `new Dictionary<${keyType}, ${elemType}> { ["k"] = ${expr} }`;
+  }
+  return field.isArray ? `new List<${elemType}> { ${expr} }` : expr;
+};
+const objectLiteral = (cls, fields) => `new ${cls} { ${fields.map((f) => `${f.ident} = ${f.expr}`).join(", ")} }`;
+class Generator extends Emit {
+  tables;
+  views;
+  typesByName;
+  constructor(raw, deterministic) {
+    super(raw);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t])
+    );
+    this.views = new Map(viewTypesOf(deterministic).map((v) => [v.name, v]));
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+  }
+  from() {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+  dsType(name) {
+    return this.imports.datasourceQual(name);
+  }
+  viewType(name) {
+    return this.imports.viewQual(name);
+  }
+  renderDs(name) {
+    const table = this.tables.get(name);
+    const cls = this.dsType(name);
+    if (table === void 0) return `new ${cls}()`;
+    return objectLiteral(
+      cls,
+      table.fields.map((f) => {
+        const { sample } = samplesForNative(convertSpecType(f.type), f.type);
+        return { ident: this.casing.convertFields(f.name), expr: sample };
+      })
+    );
+  }
+  viewFieldTok(field, visited) {
+    const ident = this.casing.convertFields(field.name);
+    const dict = dictionaryOfField(field, this.typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    const target = entry?.value ?? field;
+    let sample;
+    let elemType;
+    const keyType = entry === void 0 ? "string" : entry.key.kind === "primitive" ? convertSpecType(entry.key.base) : this.viewType(entry.key.base);
+    if (target.kind === "primitive") {
+      const native = convertSpecType(target.base);
+      sample = samplesForNative(native, target.base).sample;
+      elemType = native;
+    } else if (this.views.has(target.base)) {
+      sample = this.viewFixture(target.base, visited);
+      elemType = this.viewType(target.base);
+    } else {
+      sample = this.renderDs(target.base);
+      elemType = this.dsType(target.base);
+    }
+    return {
+      ident,
+      sampleExpr: wrapValue(sample, field, elemType, keyType),
+      nullable: field.isNullable
+    };
+  }
+  shapedToks(view, visited) {
+    return view.fields.map((f) => this.viewFieldTok(f, visited));
+  }
+  viewFixture(name, visited) {
+    const cls = this.viewType(name);
+    if (visited.has(name)) return `new ${cls}()`;
+    const view = this.views.get(name);
+    if (view === void 0) return `new ${cls}()`;
+    const next = new Set(visited).add(name);
+    return objectLiteral(
+      cls,
+      this.shapedToks(view, next).map((f) => ({
+        ident: f.ident,
+        expr: f.sampleExpr
+      }))
+    );
+  }
+  shapedCases(view) {
+    const fields = this.shapedToks(view, /* @__PURE__ */ new Set([view.name]));
+    const cls = this.viewType(view.name);
+    const cases = [
+      {
+        ident: "ParsesAValidPayload",
+        fixture: objectLiteral(
+          cls,
+          fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr }))
+        ),
+        assertion: "True"
+      }
+    ];
+    if (fields.some((f) => f.nullable)) {
+      cases.push({
+        ident: "AcceptsNullForNullableFields",
+        fixture: objectLiteral(
+          cls,
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.nullable ? "null" : f.sampleExpr
+          }))
+        ),
+        assertion: "True"
+      });
+    }
+    for (const field of view.fields) {
+      if (field.kind !== "primitive" || field.isNullable || field.isArray || field.isMap === true) {
+        continue;
+      }
+      const native = convertSpecType(field.base);
+      if (native !== "string") continue;
+      const ident = this.casing.convertFields(field.name);
+      cases.push({
+        ident: this.casing.convertTypes(`rejects_null_for_${field.name}`),
+        fixture: objectLiteral(
+          cls,
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === ident ? "null" : f.sampleExpr
+          }))
+        ),
+        assertion: "False"
+      });
+    }
+    return cases;
+  }
+  tests(view) {
+    const cases = this.shapedCases(view);
+    return content(
+      this.imports.test(this.imports.viewValidator(view.name), view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        className: this.casing.convertTypes(view.name),
+        testClassName: this.casing.validatorTestClassName(view.name),
+        validatorClass: this.casing.convertTypes(`${view.name}_validator`),
+        isUnion: false,
+        needsList: cases.some(
+          (c) => c.fixture.includes("new List<") || c.fixture.includes("new Dictionary<")
+        ),
+        cases
+      })
+    );
+  }
+}
+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();
+};
+export {
+  generate
+};