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

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

@@ -0,0 +1,92 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  classParent,
+  declaredFields,
+  withClassParents
+} from "./common/view-shape.js";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  typeHasTag
+} from "./specification-parser.js";
+import { Emit } from "./emit.js";
+import { typeTmpl } from "./resources/view-type-validators.js";
+class Generator extends Emit {
+  viewValidator(name) {
+    return this.casing.convertTypes(`${name}_validator`);
+  }
+  datasourceValidator(name) {
+    return this.casing.convertTypes(`datasource_${name}_validator`);
+  }
+  nestedValidator(field, typesByName) {
+    const nested = typesByName.get(field.base);
+    return nested !== void 0 && typeHasTag(nested, "view_type") ? this.viewValidator(field.base) : this.datasourceValidator(field.base);
+  }
+  ruleLine(field, typesByName) {
+    const prop = this.casing.convertFields(field.name);
+    const notNull = field.isNullable ? "" : "\n            .NotNull()";
+    if (field.isArray) {
+      const each = field.kind === "primitive" ? "" : `
+            .ForEach(x => x.SetValidator(new ${this.nestedValidator(field, typesByName)}()))`;
+      return `        RuleFor(x => x.${prop})${notNull}${each};`;
+    }
+    const dict = dictionaryOfField(field, typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    if (entry !== void 0) {
+      if (entry.value.kind === "primitive") {
+        return `        RuleFor(x => x.${prop})${notNull};`;
+      }
+      return `        RuleForEach(x => x.${prop}.Values)${notNull}
+            .SetValidator(new ${this.nestedValidator(entry.value, typesByName)}());`;
+    }
+    if (field.kind === "primitive") {
+      return `        RuleFor(x => x.${prop})${notNull};`;
+    }
+    return `        RuleFor(x => x.${prop})${notNull}
+            .SetValidator(new ${this.nestedValidator(field, typesByName)}());`;
+  }
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return withClassParents(viewTypesOf(deterministic), "view", typesByName).map(
+      (view) => this.view(view, typesByName)
+    );
+  }
+  view(view, typesByName) {
+    const className = this.casing.convertTypes(view.name);
+    const validatorClass = this.viewValidator(view.name);
+    const parent = classParent(view, "view", typesByName);
+    const include = parent === void 0 ? null : parent.lane === "datasource" ? `        Include(new ${this.datasourceValidator(parent.name)}());` : `        Include(new ${this.viewValidator(parent.name)}());`;
+    const fieldRules = declaredFields(view, "view", typesByName).map(
+      (f) => this.ruleLine(f, typesByName)
+    );
+    const rules = [include, ...fieldRules].filter(
+      (x) => x !== null && x !== ""
+    );
+    return content(
+      this.imports.viewValidator(view.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        className,
+        validatorClass,
+        rules: rules.map((line) => ({ line }))
+      })
+    );
+  }
+}
+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-view-types-tests.js

@@ -0,0 +1,138 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  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-types-tests.js";
+const samplesForNative = (native, fieldType) => {
+  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, convertTypes) => field.kind === "primitive" ? convertSpecType(field.base) : convertTypes(field.base);
+const fieldTokens = (field, convertTypes, convertFields, typesByName) => {
+  const ident = convertFields(field.name);
+  const dict = dictionaryOfField(field, typesByName);
+  const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+  if (entry !== void 0) {
+    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) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return viewTypesOf(deterministic).map(
+      (view) => this.tests(view, typesByName)
+    );
+  }
+  tests(view, typesByName) {
+    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: []
+      })
+    );
+  }
+}
+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-view-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-view-types.js

@@ -0,0 +1,99 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } 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.js";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  typeHasTag
+} from "./specification-parser.js";
+import {
+  convertSpecType,
+  nativeDefaultExpr
+} from "./deterministic-type-converter.js";
+import { Emit } from "./emit.js";
+import { typeTmpl } from "./resources/view-types.js";
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return withClassParents(
+      viewTypesOf(deterministic),
+      "view",
+      typesByName
+    ).map((view) => this.view(view, typesByName));
+  }
+  csPart(field, typesByName) {
+    if (field.kind === "primitive") return convertSpecType(field.base);
+    const nested = typesByName.get(field.base);
+    return nested !== void 0 && typeHasTag(nested, "view_type") ? this.casing.convertTypes(field.base) : this.imports.datasourceQual(field.base);
+  }
+  csTypeFor(field, typesByName) {
+    const dict = dictionaryOfField(field, typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    let base;
+    if (entry !== void 0) {
+      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;
+  }
+  extendsType(parent) {
+    return parent.lane === "view" ? this.casing.convertTypes(parent.name) : this.imports.datasourceQual(parent.name);
+  }
+  view(view, typesByName) {
+    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) : void 0;
+      return {
+        ident: this.casing.convertFields(f.name),
+        csType: this.csTypeFor(f, typesByName),
+        hasInitializer: initializer !== void 0,
+        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 !== void 0,
+        extendsType: parent === void 0 ? "" : this.extendsType(parent),
+        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/import-generator.js

@@ -0,0 +1,167 @@
+import pluralize from "pluralize";
+import { createCasing } from "./common/default-casing.js";
+const VARIANT_PREFIXES = ["update_", "create_"];
+const featureEntity = (entity) => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === void 0 ? entity : entity.slice(prefix.length);
+};
+const pluralSnake = (entity) => {
+  const parts = entity.split(/[_-]/);
+  parts[parts.length - 1] = pluralize.plural(parts[parts.length - 1]);
+  return parts.join("_");
+};
+const DATASOURCE_DIR = "Types/Datasource/Generated";
+const VIEW_DIR = "Types/View/Generated";
+const DATASOURCE_VALIDATOR_DIR = `${DATASOURCE_DIR}/Validators`;
+const VIEW_VALIDATOR_DIR = `${VIEW_DIR}/Validators`;
+class CsharpImportGenerator {
+  organizeByFeature;
+  flat;
+  basePath;
+  casing;
+  constructor(basePath, settings) {
+    this.basePath = basePath;
+    this.flat = basePath !== "" && basePath !== ".";
+    this.organizeByFeature = !this.flat && settings["other.organize_by_feature"] === "true";
+    this.casing = createCasing(settings);
+  }
+  datasource(entity) {
+    return this.underBase(this.rel(DATASOURCE_DIR, this.casedFile(entity)));
+  }
+  datasourceRel(entity) {
+    return this.datasource(entity);
+  }
+  datasourceQual(entity) {
+    return `Backend.Types.Datasource.${this.casing.convertTypes(entity)}`;
+  }
+  datasourceValidator(entity) {
+    return this.underBase(
+      this.rel(
+        DATASOURCE_VALIDATOR_DIR,
+        this.csFile(`datasource_${entity}_validator`)
+      )
+    );
+  }
+  datasourceValidatorRel(entity) {
+    return this.datasourceValidator(entity);
+  }
+  view(entity) {
+    return this.underBase(this.rel(VIEW_DIR, this.csFile(entity)));
+  }
+  viewRel(entity) {
+    return this.view(entity);
+  }
+  viewQual(entity) {
+    return `Backend.Types.View.${this.casing.convertTypes(entity)}`;
+  }
+  viewValidator(entity) {
+    return this.underBase(
+      this.rel(VIEW_VALIDATOR_DIR, this.csFile(`${entity}_validator`))
+    );
+  }
+  viewValidatorRel(entity) {
+    return this.viewValidator(entity);
+  }
+  service(entity) {
+    return this.underBase(this.csFile(`${entity}_service`));
+  }
+  serviceRel(entity) {
+    return this.service(entity);
+  }
+  serviceCustom(name, _module) {
+    const file = this.csFile(name);
+    return this.underBase(
+      this.organizeByFeature ? `Features/${this.casing.directory(featureEntity(name))}/custom/${file}` : `../custom/${file}`
+    );
+  }
+  serviceCustomRel(entity) {
+    const file = this.csFile(entity);
+    return this.organizeByFeature ? `Features/${this.casing.directory(entity)}/custom/${file}` : `../custom/${file}`;
+  }
+  serviceTest(entity) {
+    return this.underBase(this.csFile(`${entity}_service_tests`));
+  }
+  serviceTestRel(entity) {
+    return this.serviceTest(entity);
+  }
+  serviceIntegrationTest(entity) {
+    return this.serviceTest(entity);
+  }
+  serviceIntegrationTestRel(entity) {
+    return this.serviceIntegrationTest(entity);
+  }
+  serviceUse(_entity, _symbol) {
+    return "";
+  }
+  route(entity) {
+    return this.underBase(`${this.routeModule(entity)}.cs`);
+  }
+  routeRel(entity) {
+    return this.route(entity);
+  }
+  routeCustom(name, _module) {
+    const file = this.csFile(`${name}_route`);
+    return this.underBase(
+      this.organizeByFeature ? `Features/${this.casing.directory(featureEntity(name))}/custom/${file}` : `../custom/${file}`
+    );
+  }
+  routeTest(entity) {
+    return this.underBase(
+      this.csFile(`${pluralSnake(entity)}_router_tests`)
+    );
+  }
+  enrichment(targetTable) {
+    return this.underBase(this.csFile(`${targetTable}_name_enrichment`));
+  }
+  test(srcFile, fileBase) {
+    const stem = srcFile.includes("Validator") ? `${fileBase}_validator_tests` : `${fileBase}_tests`;
+    const file = this.csFile(stem);
+    const slash = srcFile.lastIndexOf("/");
+    if (slash === -1) return this.underBase(file);
+    return `${srcFile.slice(0, slash)}/${file}`;
+  }
+  testSpec(_srcFile, _fileBase) {
+    return "";
+  }
+  index(_beside) {
+    return "";
+  }
+  spec(_fromFile, _toFile) {
+    return "Backend.Types.Datasource";
+  }
+  routeModule(entity) {
+    return this.casing.fileBase(`${pluralSnake(entity)}_router`);
+  }
+  appWiring() {
+    return "";
+  }
+  validatorFn(_kind, _entity, _fn) {
+    return "";
+  }
+  apiPath(entity) {
+    return entity.replace(/_/g, "-");
+  }
+  frontend(relPath) {
+    return `frontend/${relPath}`;
+  }
+  csFile(stem) {
+    return `${this.casing.fileBase(stem)}.cs`;
+  }
+  casedFile(entity) {
+    const file = this.csFile(entity);
+    return this.organizeByFeature ? `Features/${this.casing.directory(entity)}/${file}` : file;
+  }
+  rel(prefix, file) {
+    if (this.organizeByFeature || this.flat) return file;
+    return `${prefix}/${file}`;
+  }
+  underBase(file) {
+    if (!this.flat) return file;
+    return `${this.basePath}/${file}`;
+  }
+}
+const createImportGenerator = (basePath, settings) => new CsharpImportGenerator(basePath, settings);
+export {
+  CsharpImportGenerator,
+  createImportGenerator
+};

package/node_modules/@deterministic-code/csharp-generators/dist/resources/backend-app.js

@@ -0,0 +1,34 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(new URL(`../templates/create-backend-app/${rel}`, import.meta.url), "utf8");
+const [
+  appCsproj,
+  programCs,
+  dockerfile,
+  appsettingsJson,
+  appsettingsDevelopmentJson,
+  entrypointSh,
+  dockerComposeYml,
+  envFile,
+  gitignore
+] = await Promise.all([
+  resource("csharp/App/App.csproj.tmpl"),
+  resource("csharp/App/Program.cs.tmpl"),
+  resource("Dockerfile.tmpl"),
+  resource("csharp/App/appsettings.json.tmpl"),
+  resource("csharp/App/appsettings.Development.json.tmpl"),
+  resource("entrypoint.sh"),
+  resource("docker-compose.yml.tmpl"),
+  resource("env.tmpl"),
+  resource("gitignore.tmpl")
+]);
+export {
+  appCsproj,
+  appsettingsDevelopmentJson,
+  appsettingsJson,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  programCs
+};

package/node_modules/@deterministic-code/csharp-generators/dist/resources/datasource-type-validators-tests.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(
+    `../templates/create-datasource-type-validators-tests/${rel}`,
+    import.meta.url
+  ),
+  "utf8"
+);
+const typeTestTmpl = await resource("type.tests.cs.tmpl");
+export {
+  typeTestTmpl
+};

package/node_modules/@deterministic-code/csharp-generators/dist/resources/datasource-type-validators.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(
+    `../templates/create-datasource-type-validators/${rel}`,
+    import.meta.url
+  ),
+  "utf8"
+);
+const typeTmpl = await resource("type.cs.tmpl");
+export {
+  typeTmpl
+};

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

@@ -0,0 +1,11 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-datasource-types-tests/${rel}`, import.meta.url),
+  "utf8"
+);
+const [typeTestTmpl] = await Promise.all([
+  resource("type.tests.cs.tmpl")
+]);
+export {
+  typeTestTmpl
+};

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

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-datasource-types/${rel}`, import.meta.url),
+  "utf8"
+);
+const typeTmpl = await resource("type.cs.tmpl");
+export {
+  typeTmpl
+};

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

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-routes-tests/${rel}`, import.meta.url),
+  "utf8"
+);
+const [genericTmpl] = await Promise.all([resource("generic.cs.tmpl")]);
+export {
+  genericTmpl
+};

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

@@ -0,0 +1,15 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-routes/${rel}`, import.meta.url),
+  "utf8"
+);
+const [routerTmpl, customStubTmpl, nameEnrichmentTmpl] = await Promise.all([
+  resource("router.cs.tmpl"),
+  resource("custom-stub.cs.tmpl"),
+  resource("name-enrichment.cs.tmpl")
+]);
+export {
+  customStubTmpl,
+  nameEnrichmentTmpl,
+  routerTmpl
+};

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

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-service-tests/${rel}`, import.meta.url),
+  "utf8"
+);
+const [genericTmpl] = await Promise.all([resource("generic.cs.tmpl")]);
+export {
+  genericTmpl
+};

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

@@ -0,0 +1,13 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-services/${rel}`, import.meta.url),
+  "utf8"
+);
+const [genericTmpl, customStubTmpl] = await Promise.all([
+  resource("generic.cs.tmpl"),
+  resource("custom-stub.cs.tmpl")
+]);
+export {
+  customStubTmpl,
+  genericTmpl
+};

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

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(
+    `../templates/create-view-type-validators-tests/${rel}`,
+    import.meta.url
+  ),
+  "utf8"
+);
+const typeTestTmpl = await resource("type.tests.cs.tmpl");
+export {
+  typeTestTmpl
+};

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

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-view-type-validators/${rel}`, import.meta.url),
+  "utf8"
+);
+const typeTmpl = await resource("type.cs.tmpl");
+export {
+  typeTmpl
+};

package/node_modules/@deterministic-code/csharp-generators/dist/resources/view-types-tests.js

@@ -0,0 +1,11 @@
+import { readFile } from "node:fs/promises";
+const resource = (rel) => readFile(
+  new URL(`../templates/create-view-types-tests/${rel}`, import.meta.url),
+  "utf8"
+);
+const [typeTestTmpl] = await Promise.all([
+  resource("type.tests.cs.tmpl")
+]);
+export {
+  typeTestTmpl
+};