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

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

@@ -0,0 +1,134 @@
+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 rustString = (value) => {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `String::from("${escaped}")`;
+};
+const token = (specToken, native, reverse) => ({ ...specToken, native, reverse });
+const quoted = token(spec.string.String, rustString, /^String::from\("(.*)"\)$/);
+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: "i64",
+  integer: "i32",
+  unsignedinteger: "u32",
+  smallinteger: "i16",
+  unsignedsmallinteger: "u16",
+  biginteger: "i64",
+  unsignedbiginteger: "u64",
+  float: "f64",
+  decimal: "String",
+  boolean: "bool",
+  datetime: "chrono::DateTime<chrono::Utc>",
+  binary: "Vec<u8>",
+  uuid: "String",
+  reference: "i64"
+});
+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, rustString, /^String::from\("(.*)"\)$/),
+    String: quoted
+  },
+  boolean: {
+    Boolean: token(
+      spec.boolean.Boolean,
+      (arg) => arg === "true" ? "true" : "false",
+      /^(true|false)$/
+    )
+  },
+  datetime: {
+    Now: token(
+      spec.datetime.Now,
+      () => "chrono::Utc::now()",
+      /^chrono::Utc::now\(\)$/
+    ),
+    UtcNow: token(
+      spec.datetime.UtcNow,
+      () => "chrono::Utc::now()",
+      /^chrono::Utc::now\(\)$/
+    ),
+    DateTime: token(
+      spec.datetime.DateTime,
+      (arg) => `"${arg}".parse::<chrono::DateTime<chrono::Utc>>().unwrap()`,
+      /^"(.*)"\.parse::<chrono::DateTime<chrono::Utc>>\(\)\.unwrap\(\)$/
+    )
+  },
+  binary: {
+    Hex: token(
+      spec.binary.Hex,
+      (arg) => `vec![${hexToBytes(arg).join(", ")}]`,
+      /^vec!\[.*\]$/
+    )
+  },
+  uuid: {
+    NewId: token(
+      spec.uuid.NewId,
+      () => "uuid::Uuid::new_v4().to_string()",
+      /^uuid::Uuid::new_v4\(\)\.to_string\(\)$/
+    ),
+    Empty: token(
+      spec.uuid.Empty,
+      () => "uuid::Uuid::nil().to_string()",
+      /^uuid::Uuid::nil\(\)\.to_string\(\)$/
+    ),
+    Uuid: token(spec.uuid.Uuid, rustString, /^String::from\("(.*)"\)$/)
+  },
+  reference: {}
+});
+const toNative = (specType) => typeConverter.convert(specType);
+const convertSpecType = toNative;
+const isRustZeroExpr = (expr) => expr === "false" || expr === "0" || expr === "0.0" || expr === "String::new()" || expr === 'String::from("")' || expr === "vec![]" || expr === "None";
+const rustSpecDefaultExpr = (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 `Some(${expr})`;
+  return isRustZeroExpr(expr) ? void 0 : expr;
+};
+const rustLanguageZero = (rustType) => {
+  if (rustType.startsWith("Option<")) return "None";
+  if (rustType.startsWith("Vec<")) return "vec![]";
+  if (rustType.startsWith("HashMap<")) return "HashMap::new()";
+  if (rustType === "bool") return "false";
+  if (rustType === "String") return "String::new()";
+  if (rustType === "chrono::DateTime<chrono::Utc>") {
+    return "chrono::DateTime::<chrono::Utc>::UNIX_EPOCH";
+  }
+  if (rustType === "f64") return "0.0";
+  if (rustType === "i16" || rustType === "i32" || rustType === "i64" || rustType === "u16" || rustType === "u32" || rustType === "u64") {
+    return "0";
+  }
+  return `${rustType}::default()`;
+};
+export {
+  convertSpecType,
+  defaultValueConverter,
+  rustLanguageZero,
+  rustSpecDefaultExpr,
+  toNative,
+  typeConverter
+};

package/node_modules/@deterministic-code/rust-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/rust-generators/dist/generate-backend-app.js

@@ -0,0 +1,39 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import {
+  cargoToml,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  libRs,
+  mainRs
+} from "./resources/backend-app.js";
+const DEFAULT_APP_NAME = "generated-app";
+const crateIdentFromAppName = (appName) => {
+  const ident = appName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  const base = ident || "generated_app";
+  return /^[0-9]/.test(base) ? `app_${base}` : base;
+};
+const generate = async (ctx) => {
+  const crateIdent = crateIdentFromAppName(
+    ctx.settings.application_name || DEFAULT_APP_NAME
+  );
+  const named = { crateIdent };
+  return [
+    content("src/main.rs", fill(mainRs, named)),
+    patch("src/lib.rs", libRs),
+    patch("Cargo.toml", fill(cargoToml, named)),
+    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", "target")
+  ];
+};
+export {
+  generate
+};

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

@@ -0,0 +1,106 @@
+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 {
+  rustString,
+  samplesForNative,
+  wrapOption
+} from "./common/test-samples.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { convertSpecType } from "./deterministic-type-converter.js";
+import { typeTestTmpl } from "./resources/datasource-type-validators-tests.js";
+import { Emit } from "./emit.js";
+const fieldTok = (field, casing, typesByName) => {
+  const specType = fieldTypeOf(field, typesByName);
+  const native = convertSpecType(specType);
+  const { sample } = samplesForNative(native, specType);
+  return {
+    name: field.name,
+    ident: casing.convertFields(field.name),
+    sampleExpr: wrapOption(sample, field.isNullable),
+    isNullable: field.isNullable,
+    type: specType,
+    native
+  };
+};
+const structLiteral = (cls, fields) => `${cls} { ${fields.map((f) => `${f.ident}: ${f.expr}`).join(", ")} }`;
+const casesFor = (cls, fields) => {
+  const valid = structLiteral(
+    cls,
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr }))
+  );
+  const cases = [
+    { ident: "parses_a_valid_payload", fixture: valid, assertion: "is_ok()" }
+  ];
+  if (fields.some((f) => f.isNullable)) {
+    cases.push({
+      ident: "accepts_none_for_nullable_fields",
+      fixture: structLiteral(
+        cls,
+        fields.map((f) => ({
+          ident: f.ident,
+          expr: f.isNullable ? "None" : f.sampleExpr
+        }))
+      ),
+      assertion: "is_ok()"
+    });
+  }
+  for (const field of fields) {
+    if (field.type === "uuid" && field.native === "String") {
+      cases.push({
+        ident: `rejects_when_invalid_uuid_on_${field.ident}`,
+        fixture: structLiteral(
+          cls,
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === field.ident ? wrapOption(rustString("not-a-uuid"), f.isNullable) : f.sampleExpr
+          }))
+        ),
+        assertion: "is_err()"
+      });
+    }
+  }
+  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, this.casing, typesByName)
+    );
+    const cls = this.casing.convertTypes(table.name);
+    const src = this.imports.datasource(table.name);
+    return content(
+      this.imports.test(src, table.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        typeUse: this.imports.datasourceQual(table.name),
+        fnName: this.casing.convertFields(`validate_datasource_${table.name}`),
+        cases: casesFor(cls, 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/rust-generators/dist/generate-datasource-types-tests.js

@@ -0,0 +1,60 @@
+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 { samplesForNative, wrapOption } from "./common/test-samples.js";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import { convertSpecType } from "./deterministic-type-converter.js";
+import { typeTestTmpl } from "./resources/datasource-types-tests.js";
+import { Emit } from "./emit.js";
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return datasourceTypesOf(deterministic).map((table) => {
+      const fields = persistedColumnFields(table, typesByName).map((field) => {
+        const ident = this.casing.convertFields(field.name);
+        const specType = fieldTypeOf(field, typesByName);
+        const native = convertSpecType(specType);
+        const { sample, next } = samplesForNative(native, specType);
+        return {
+          ident,
+          sampleExpr: wrapOption(sample, field.isNullable),
+          nextExpr: wrapOption(next, field.isNullable),
+          nullable: field.isNullable,
+          getsTest: this.casing.fnIdent(`gets_${field.name}`),
+          setsTest: this.casing.fnIdent(`sets_${field.name}`),
+          allowsNoneTest: this.casing.fnIdent(
+            `allows_setting_${field.name}_to_none`
+          )
+        };
+      });
+      const src = this.imports.datasource(table.name);
+      return content(
+        this.imports.test(src, table.name),
+        fill(typeTestTmpl, {
+          schemaVersion: this.settings.schemaVersion,
+          structName: this.casing.convertTypes(table.name),
+          fileBase: this.casing.fileBase(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/rust-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/rust-generators/dist/generate-datasource-types.js

@@ -0,0 +1,70 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  tableKind
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import {
+  convertSpecType,
+  rustLanguageZero,
+  rustSpecDefaultExpr
+} from "./deterministic-type-converter.js";
+import { typesNeedingDefault } from "./struct-default.js";
+import { typeTmpl } from "./resources/datasource-types.js";
+import { Emit } from "./emit.js";
+const rustTypeFor = (field, typesByName) => {
+  const t = convertSpecType(fieldTypeOf(field, typesByName));
+  return field.isNullable ? `Option<${t}>` : t;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    const needingDefault = typesNeedingDefault(deterministic);
+    return datasourceTypesOf(deterministic).map(
+      (table) => this.type(table, typesByName, needingDefault)
+    );
+  }
+  type(table, typesByName, needingDefault) {
+    const implDefault = needingDefault.has(table.name);
+    const fields = persistedColumnFields(table, typesByName).map((f) => {
+      const rustType = rustTypeFor(f, typesByName);
+      const specExpr = rustSpecDefaultExpr(fieldTypeOf(f, typesByName), f);
+      return {
+        ident: this.casing.convertFields(f.name),
+        rustType,
+        defaultExpr: specExpr ?? rustLanguageZero(rustType)
+      };
+    });
+    const structName = this.casing.convertTypes(table.name);
+    return content(
+      this.imports.datasource(table.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        structName,
+        datasourceType: tableKind(table),
+        fieldCount: String(fields.length),
+        implDefault,
+        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/rust-generators/dist/generate-openapi.js

@@ -0,0 +1,32 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { generate as generateJson } from "@deterministic-code/generators-openapi/generate-openapi";
+import { conformanceTmpl, routerTmpl } from "./resources/openapi.js";
+const escapeRustStringLiteral = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+const generate = async (ctx) => {
+  const crateName = ctx.settings["languages.rust.crate_name"] ?? "consumer";
+  const [jsonEntry] = await generateJson(ctx);
+  if (jsonEntry === void 0 || jsonEntry.kind !== "content") {
+    throw new Error("openapi json lane did not emit openapi.json");
+  }
+  const spec = JSON.parse(jsonEntry.contents);
+  const expectedPaths = Object.keys(spec.paths ?? {}).sort().map((p) => `        ${JSON.stringify(p)},`).join("\n");
+  return [
+    content(
+      "openapi.rs",
+      fill(routerTmpl, {
+        specJson: escapeRustStringLiteral(jsonEntry.contents.trim())
+      })
+    ),
+    content(
+      "openapi_conformance.rs",
+      fill(conformanceTmpl, {
+        crateModule: crateName.replace(/-/g, "_"),
+        expectedPaths
+      })
+    )
+  ];
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-perf-e2e-tests.js

@@ -0,0 +1,6 @@
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { e2eTmpl } from "./resources/perf-e2e.js";
+const generate = async (_ctx) => [content("app_perf_client.rs", e2eTmpl)];
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-perf-server.js

@@ -0,0 +1,20 @@
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import { TYPES_YAML } from "./specification-parser.js";
+import { serverTmpl } from "./resources/perf-server.js";
+const generate = async (ctx) => {
+  if (!await ctx.reader.exists(TYPES_YAML)) {
+    throw new Error("generate-perf-server: types.yaml is required");
+  }
+  await ctx.reader.read(TYPES_YAML);
+  return [
+    content("src/bin/perf_server.rs", serverTmpl),
+    patch(
+      "Cargo.toml",
+      '[[bin]]\nname = "perf_server"\npath = "src/bin/perf_server.rs"',
+      "PERF_BIN"
+    )
+  ];
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-routes-e2e-test.js

@@ -0,0 +1,102 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  isManyToMany,
+  isReadonlyLookup,
+  pkName,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML
+} from "./specification-parser.js";
+import {
+  crudTestsTmpl,
+  fileTmpl,
+  readonlyTestsTmpl,
+  setupTmpl
+} from "./resources/routes-e2e.js";
+import { Emit } from "./emit.js";
+const jsonSample = (type) => {
+  switch (type) {
+    case "boolean":
+      return "true";
+    case "number":
+    case "integer":
+    case "smallinteger":
+    case "biginteger":
+    case "float":
+    case "reference":
+      return "1";
+    case "datetime":
+      return `"2020-01-01T00:00:00.000Z"`;
+    case "uuid":
+      return `"00000000-0000-0000-0000-000000000001"`;
+    default:
+      return `"x"`;
+  }
+};
+const samplePayload = (table) => {
+  const parts = table.fields.filter(
+    (f) => !f.isNullable && f.hasDefault !== true && f.references === void 0
+  ).map((f) => `"${f.name}":${jsonSample(f.type)}`);
+  return `{${parts.join(",")}}`;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const tables = tableByName(deterministic);
+    const types = datasourceTypesOf(deterministic).filter(
+      (t) => !isManyToMany(t)
+    );
+    const setups = types.map(
+      (t) => fill(setupTmpl, {
+        entity: t.name,
+        segment: this.imports.apiPath(t.name),
+        setupFn: this.casing.fnIdent(`setup_${t.name}_router`),
+        listRouteName: this.casing.fnIdent(`list_${t.name}`),
+        getByIdRouteName: this.casing.fnIdent(`get_${t.name}_by_id`),
+        createRouteName: this.casing.fnIdent(`create_${t.name}`),
+        deleteByIdRouteName: this.casing.fnIdent(`delete_${t.name}_by_id`)
+      }).trimEnd()
+    ).join("\n\n");
+    const tests = types.map((t) => {
+      const pk = pkName(t, tables.get(t.name));
+      const pkType = t.fields.find((f) => f.name === pk)?.type ?? "integer";
+      const tokens = {
+        entity: t.name,
+        pascal: this.casing.convertTypes(t.name),
+        segment: this.imports.apiPath(t.name),
+        setupFn: this.casing.fnIdent(`setup_${t.name}_router`),
+        listTest: this.casing.fnIdent(`${t.name}_list_returns_200`),
+        postTest: this.casing.fnIdent(`${t.name}_post_accepts_sample_payload`),
+        getMissingTest: this.casing.fnIdent(
+          `${t.name}_get_missing_returns_404`
+        ),
+        deleteMissingTest: this.casing.fnIdent(
+          `${t.name}_delete_missing_returns_non_5xx`
+        ),
+        missing: pkType === "uuid" ? "00000000-0000-0000-0000-000000000000" : "99999",
+        payload: samplePayload(t)
+      };
+      const tmpl = isReadonlyLookup(t) ? readonlyTestsTmpl : crudTestsTmpl;
+      return fill(tmpl, tokens).trimEnd();
+    }).join("\n\n");
+    return [
+      content(
+        "app_routes_e2e.rs",
+        fill(fileTmpl, { setups, tests })
+      )
+    ];
+  }
+}
+const generate = async (ctx) => {
+  if (!await ctx.reader.exists(TYPES_YAML)) return [];
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+export {
+  generate
+};