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

package/dist/wireRegister.js

@@ -0,0 +1,104 @@
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { csharpTarget } from "./detect.js";
+const posix = (path) => path.split(sep).join("/");
+const specFrom = (from, to) => {
+  const rel = posix(relative(dirname(from), to));
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+const hookPath = (cwd, dialect, src) => join(cwd, src ? "src" : ".", dialect === "typescript" ? "datasources-register.ts" : "datasources_register.rs");
+const hookContents = (dialect, hook, output) => dialect === "typescript" ? `import "${specFrom(hook, join(output, "typescript/repositories/repository-registry.ts"))}";
+` : `#[path = "${specFrom(hook, join(output, "rust/repositories/mod.rs"))}"]
+pub mod repositories;
+pub use repositories::repository_registry::Repositories;
+`;
+const cargoWithCtor = (cargo) => /^\s*ctor\s*=/m.test(cargo) ? void 0 : cargo.includes("[dependencies]") ? cargo.replace("[dependencies]", `[dependencies]
+ctor = "0.4"`) : `${cargo.trimEnd()}
+
+[dependencies]
+ctor = "0.4"
+`;
+const attached = (dialect, entry, entryPath, hook) => dialect === "typescript" ? entry.includes("datasources-register") ? void 0 : `import "${specFrom(entryPath, hook)}";
+${entry}` : entry.includes("datasources_register") ? void 0 : `mod datasources_register;
+use datasources_register::Repositories;
+
+${entry}`;
+const optional = async (fs, path) => {
+  try {
+    return await fs.readFile(path);
+  } catch {
+    return void 0;
+  }
+};
+const outputRoot = (cwd, output) => isAbsolute(output) ? output : join(cwd, output);
+const registryPath = (root, dialect) => dialect === "typescript" ? join(root, "typescript/repositories/repository-registry.ts") : join(root, "rust/repositories/mod.rs");
+const firstFile = async (fs, cwd, names) => {
+  for (const name of names) {
+    const path = join(cwd, name);
+    const text = await optional(fs, path);
+    if (text !== void 0) return { path, text };
+  }
+  return void 0;
+};
+const wireCsharp = async (cwd, output, dryRun, deps) => {
+  const entries = await deps.fs.readdir(cwd).catch(() => []);
+  const target = csharpTarget(entries);
+  if (!target.endsWith(".csproj")) return;
+  const csprojPath = join(cwd, target);
+  const generated = join(outputRoot(cwd, output), "csharp");
+  const rel = posix(relative(dirname(csprojPath), generated));
+  if (!rel.startsWith("..")) return;
+  const include = `${rel}/**/*.cs`;
+  const existing = await optional(deps.fs, csprojPath);
+  if (existing === void 0 || existing.includes(include)) return;
+  if (dryRun) {
+    deps.log(csprojPath);
+    return;
+  }
+  await deps.fs.writeFile(csprojPath, existing.replace("</Project>", `  <ItemGroup>
+    <Compile Include="${include}" />
+  </ItemGroup>
+</Project>`));
+  deps.log(csprojPath);
+};
+const wireRegister = async (cwd, output, dialect, dryRun, deps) => {
+  if (dialect === "csharp") return wireCsharp(cwd, output, dryRun, deps);
+  const root = outputRoot(cwd, output);
+  if (relative(cwd, root).startsWith("..")) return;
+  if (await optional(deps.fs, registryPath(root, dialect)) === void 0) return;
+  const entries = await deps.fs.readdir(cwd).catch(() => []);
+  const hook = hookPath(cwd, dialect, entries.includes("src"));
+  const text = hookContents(dialect, hook, root);
+  if (dryRun) {
+    deps.log(hook);
+    return;
+  }
+  await deps.fs.writeFile(hook, text);
+  deps.log(hook);
+  if (dialect === "rust") {
+    const cargoPath = join(cwd, "Cargo.toml");
+    const cargo = await optional(deps.fs, cargoPath);
+    const nextCargo = cargo === void 0 ? void 0 : cargoWithCtor(cargo);
+    if (nextCargo !== void 0) {
+      await deps.fs.writeFile(cargoPath, nextCargo);
+      deps.log(cargoPath);
+    }
+  }
+  const entry = await firstFile(
+    deps.fs,
+    cwd,
+    dialect === "typescript" ? ["src/index.ts", "src/main.ts", "index.ts", "main.ts"] : ["src/lib.rs", "src/main.rs"]
+  );
+  if (!entry) return;
+  const next = attached(dialect, entry.text, entry.path, hook);
+  if (next === void 0) return;
+  await deps.fs.writeFile(entry.path, next);
+  deps.log(entry.path);
+};
+export {
+  attached,
+  cargoWithCtor,
+  hookContents,
+  hookPath,
+  specFrom,
+  wireRegister
+};

package/node_modules/@deterministic-code/csharp-generators/dist/common/default-casing.js

@@ -0,0 +1,44 @@
+import {
+  createCasingStrategy
+} from "@deterministic-code/generators-common/casing-strategy";
+const GENERATOR_LANGUAGE = "csharp";
+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 createCasing = (settings) => {
+  const casing = createCasingStrategy(GENERATOR_LANGUAGE, settings);
+  const fileBase = (stem) => casing.convertFileName(stem);
+  const directory = (entity) => casing.convertDirectories(featureEntity(entity));
+  const filePath = (stem) => `${fileBase(stem)}.cs`;
+  return {
+    convertFileName: (text) => casing.convertFileName(text),
+    convertTypes: (text) => casing.convertTypes(text),
+    convertFields: (text) => casing.convertFields(text),
+    convertDirectories: (text) => casing.convertDirectories(text),
+    fileBase,
+    directory,
+    filePath,
+    serviceClassName: (entity) => casing.convertTypes(`${entity}_service`),
+    serviceInterfaceName: (entity) => casing.convertTypes(`i_${entity}_service`),
+    authoredInterfaceName: (name) => casing.convertTypes(`i_${name}`),
+    interfaceName: (stem) => casing.convertTypes(`i_${stem}`),
+    testClassName: (entity) => casing.convertTypes(`${entity}_tests`),
+    validatorTestClassName: (entity) => casing.convertTypes(`${entity}_validator_tests`),
+    getsTestName: (field) => casing.convertTypes(`gets_${field}`),
+    setsTestName: (field) => casing.convertTypes(`sets_${field}`),
+    allowsNullTestName: (field) => casing.convertTypes(`allows_setting_${field}_to_null`),
+    acceptsMemberTestName: (name) => casing.convertTypes(`accepts_${name}_member`),
+    nameSourceInterfaceName: (target) => casing.convertTypes(`i_${target}_name_source`),
+    nameRowTypeName: (target) => casing.convertTypes(`${target}_name_row`),
+    enrichItemsMethodName: (target) => casing.convertTypes(`enrich_items_with_${target}_name_async`),
+    enrichItemMethodName: (target) => casing.convertTypes(`enrich_item_with_${target}_name_async`)
+  };
+};
+const defaultCasing = (settings) => createCasing(settings);
+export {
+  GENERATOR_LANGUAGE,
+  createCasing,
+  defaultCasing
+};

package/node_modules/@deterministic-code/csharp-generators/dist/common/view-shape.js

@@ -0,0 +1,78 @@
+import {
+  columnFields,
+  persistedColumnFields
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  typeHasTag
+} from "../specification-parser.js";
+const BUILTIN_PARENTS = /* @__PURE__ */ new Set(["set", "dictionary", "file"]);
+const isUnionLike = (type) => type.kind === "union";
+const viewExtendsDatasource = (view) => typeHasTag(view, "datasource_type") && typeHasTag(view, "view_type");
+const covers = (child, parent) => {
+  const names = new Set(child.map((field) => field.name));
+  return parent.every((field) => names.has(field.name));
+};
+const visibleFields = (type, lane, typesByName) => lane === "datasource" ? typesByName !== void 0 ? persistedColumnFields(type, typesByName) : columnFields(type.fields) : type.fields;
+const classParent = (type, lane, typesByName) => {
+  if (lane === "view" && viewExtendsDatasource(type)) {
+    const parentFields = visibleFields(
+      typesByName.get(type.name) ?? type,
+      "datasource",
+      typesByName
+    );
+    if (!covers(visibleFields(type, "view", typesByName), parentFields)) {
+      return void 0;
+    }
+    return { name: type.name, lane: "datasource" };
+  }
+  const parentName = type.inherits;
+  if (parentName === void 0 || BUILTIN_PARENTS.has(parentName)) {
+    return void 0;
+  }
+  const parent = typesByName.get(parentName);
+  if (parent === void 0) return void 0;
+  const parentLane = lane === "view" && (typeHasTag(parent, "view_type") || !typeHasTag(parent, "datasource_type")) ? "view" : "datasource";
+  if (!covers(
+    visibleFields(type, lane, typesByName),
+    visibleFields(parent, parentLane, typesByName)
+  )) {
+    return void 0;
+  }
+  return { name: parentName, lane: parentLane };
+};
+const withClassParents = (types, lane, typesByName) => {
+  const seen = new Map(types.map((type) => [type.name, type]));
+  const visit = (type) => {
+    const parent = classParent(type, lane, typesByName);
+    if (parent === void 0 || parent.lane !== lane || seen.has(parent.name)) {
+      return;
+    }
+    const parentType = typesByName.get(parent.name);
+    if (parentType === void 0) return;
+    seen.set(parentType.name, parentType);
+    visit(parentType);
+  };
+  for (const type of types) visit(type);
+  return [...seen.values()];
+};
+const declaredFields = (type, lane, typesByName) => {
+  const fields = visibleFields(type, lane, typesByName);
+  const parent = classParent(type, lane, typesByName);
+  if (parent === void 0) return fields;
+  const parentType = typesByName.get(parent.name);
+  if (parentType === void 0) return fields;
+  const parentNames = new Set(
+    visibleFields(parentType, parent.lane, typesByName).map(
+      (field) => field.name
+    )
+  );
+  return fields.filter((field) => !parentNames.has(field.name));
+};
+export {
+  classParent,
+  declaredFields,
+  isUnionLike,
+  viewExtendsDatasource,
+  visibleFields,
+  withClassParents
+};

package/node_modules/@deterministic-code/csharp-generators/dist/deterministic-type-converter.js

@@ -0,0 +1,124 @@
+import {
+  DeterministicDefaultValueConverter
+} 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) => JSON.stringify(value);
+const token = (specToken, native, reverse) => ({ ...specToken, native, reverse });
+const quoted = token(spec.string.String, csString, /^"(.*)"$/);
+const numeric = (type) => {
+  const numericSpec = spec[type].Numeric;
+  return {
+    Numeric: token(numericSpec, (arg) => arg, numericSpec.spec),
+    String: token(numericSpec, (arg) => arg, numericSpec.spec)
+  };
+};
+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"
+});
+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: {}
+});
+const toNative = (specType) => typeConverter.convert(specType);
+const convertSpecType = toNative;
+const CS_NUMERIC = /* @__PURE__ */ new Set([
+  "long",
+  "uint",
+  "short",
+  "ushort",
+  "ulong",
+  "double"
+]);
+const isCsZero = (specType, expr) => {
+  const native = toNative(specType);
+  if (native === "bool") return expr === "false";
+  if (CS_NUMERIC.has(native)) return /^0(\.0+)?$/.test(expr);
+  return false;
+};
+const nativeDefaultExpr = (specType, field) => {
+  if (field.hasDefault !== true) return void 0;
+  const expr = defaultValueConverter.convert(
+    specType,
+    String(field.defaultValue)
+  );
+  if (expr === null) return void 0;
+  if (field.isNullable) return expr;
+  return isCsZero(specType, expr) ? void 0 : expr;
+};
+export {
+  convertSpecType,
+  defaultValueConverter,
+  nativeDefaultExpr,
+  toNative,
+  typeConverter
+};

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

@@ -0,0 +1,20 @@
+import {
+  fromSettings
+} from "@deterministic-code/generators-common/settings";
+import { createCasing } from "./common/default-casing.js";
+import {
+  createImportGenerator
+} from "./import-generator.js";
+class Emit {
+  settings;
+  casing;
+  imports;
+  constructor(raw, basePath = ".") {
+    this.settings = fromSettings(raw);
+    this.casing = createCasing(raw);
+    this.imports = createImportGenerator(basePath, raw);
+  }
+}
+export {
+  Emit
+};

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

@@ -0,0 +1,42 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import {
+  appCsproj,
+  appsettingsDevelopmentJson,
+  appsettingsJson,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  programCs
+} from "./resources/backend-app.js";
+const DEFAULT_APP_NAME = "generated-app";
+const projectNameFromAppName = (appName) => {
+  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}`;
+};
+const generate = async (ctx) => {
+  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/")
+  ];
+};
+export {
+  generate
+};

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

@@ -0,0 +1,170 @@
+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-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 fieldTok = (field, convertFields, typesByName) => {
+  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, fields) => `new ${cls} { ${fields.map((f) => `${f.ident} = ${f.expr}`).join(", ")} }`;
+const casesFor = (cls, fields, convertTypes) => {
+  const valid = objectLiteral(
+    cls,
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr }))
+  );
+  const cases = [
+    { 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) {
+    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) => 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)
+        )
+      })
+    );
+  }
+}
+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
+};