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

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

@@ -0,0 +1,142 @@
+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 type { PackCasing } from "./common/default-casing.ts";
+import {
+  rustString,
+  samplesForNative,
+  wrapOption,
+} from "./common/test-samples.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import { convertSpecType } from "./deterministic-type-converter.ts";
+import { typeTestTmpl } from "./resources/datasource-type-validators-tests.ts";
+import { Emit } from "./emit.ts";
+
+type FieldTok = {
+  name: string;
+  ident: string;
+  sampleExpr: string;
+  isNullable: boolean;
+  type: string;
+  native: string;
+};
+
+type CaseTok = {
+  ident: string;
+  fixture: string;
+  assertion: string;
+};
+
+const fieldTok = (
+  field: TypeField,
+  casing: PackCasing,
+  typesByName: ReadonlyMap<string, Type>,
+): FieldTok => {
+  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: string,
+  fields: Array<{ ident: string; expr: string }>,
+): string =>
+  `${cls} { ${fields.map((f) => `${f.ident}: ${f.expr}`).join(", ")} }`;
+
+const casesFor = (cls: string, fields: FieldTok[]): CaseTok[] => {
+  const valid = structLiteral(
+    cls,
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr })),
+  );
+  const cases: CaseTok[] = [
+    { 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: 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, 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),
+      }),
+    );
+  }
+}
+
+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/rust-generators/src/generate-datasource-type-validators.ts

@@ -0,0 +1,182 @@
+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 {
+  columnFields,
+  datasourceTypesOf,
+  fieldTypeOf,
+  isPkField,
+} from "@deterministic-code/generators-common/spec-types";
+import type { PackCasing } from "./common/default-casing.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import { convertSpecType } from "./deterministic-type-converter.ts";
+import { typeTmpl } from "./resources/datasource-type-validators.ts";
+import { Emit } from "./emit.ts";
+
+const errIf = (cond: string, msg: string): string =>
+  `if ${cond} { errors.push("${msg}".to_string()); }`;
+
+const guard = (rows: Array<[boolean, string, string]>): string[] =>
+  rows.flatMap(([ok, cond, msg]) => (ok ? [errIf(cond, msg)] : []));
+
+const floatLit = (n: number): string => {
+  const s = String(n);
+  return s.includes(".") ? `${s}f64` : `${s}.0f64`;
+};
+
+const uuidChecks = (prop: string, ref: string): string[] => [
+  `let hex_dashes = ${ref}.len() == 36 && ${ref}.chars().enumerate().all(|(i, c)| if i == 8 || i == 13 || i == 18 || i == 23 { c == '-' } else { c.is_ascii_hexdigit() });`,
+  `if !hex_dashes { errors.push("${prop}: must be a uuid".to_string()); }`,
+];
+
+const rawChecks = (
+  field: TypeField,
+  prop: string,
+  ref: string,
+): string[] => {
+  const { type, name, minSize, size, references } = field;
+  const max = typeof size === "number" ? size : undefined;
+  switch (type) {
+    case "string":
+    case "character":
+      return guard([
+        [
+          minSize !== undefined && minSize >= 0,
+          `${ref}.chars().count() < ${minSize}`,
+          `${prop}: must be at least ${minSize} chars`,
+        ],
+        [
+          max !== undefined && max >= 0,
+          `${ref}.chars().count() > ${max}`,
+          `${prop}: exceeds ${max} chars`,
+        ],
+      ]);
+    case "uuid":
+      return uuidChecks(prop, ref);
+    case "number":
+    case "integer":
+    case "smallinteger":
+    case "biginteger":
+    case "reference": {
+      const suffix = convertSpecType(type);
+      const idLike =
+        name === "id" ||
+        name.endsWith("_id") ||
+        (typeof references === "string" && references.length > 0);
+      return guard([
+        [idLike, `${ref} < 0${suffix}`, `${prop}: must be nonnegative`],
+        [
+          !idLike && minSize !== undefined,
+          `${ref} < ${minSize}${suffix}`,
+          `${prop}: must be at least ${minSize}`,
+        ],
+        [
+          max !== undefined,
+          `${ref} > ${max}${suffix}`,
+          `${prop}: exceeds ${max}`,
+        ],
+      ]);
+    }
+    case "float":
+      return guard([
+        [
+          minSize !== undefined,
+          `${ref} < ${floatLit(minSize!)}`,
+          `${prop}: must be at least ${minSize}`,
+        ],
+        [
+          max !== undefined,
+          `${ref} > ${floatLit(max ?? 0)}`,
+          `${prop}: exceeds ${max}`,
+        ],
+      ]);
+    default:
+      return [];
+  }
+};
+
+const pad = (n: number, line: string): string => `${"    ".repeat(n)}${line}`;
+
+const checksForField = (
+  field: TypeField,
+  casing: PackCasing,
+  isStandardId: boolean,
+): string[] => {
+  const prop = casing.convertFields(field.name);
+  if (isStandardId) {
+    if (field.type === "string") return [];
+    if (field.type === "uuid") {
+      return uuidChecks(prop, `obj.${prop}.to_string()`).map((l) => pad(1, l));
+    }
+    return [
+      pad(
+        1,
+        errIf(
+          `obj.${prop} < 0${convertSpecType(field.type)}`,
+          `${prop}: must be nonnegative`,
+        ),
+      ),
+    ];
+  }
+  const stringLike = field.type === "string" || field.type === "uuid";
+  const ref = field.isNullable ? (stringLike ? "v" : "*v") : `obj.${prop}`;
+  const inner = rawChecks(field, prop, ref);
+  if (inner.length === 0) return [];
+  if (!field.isNullable) return inner.map((l) => pad(1, l));
+  return [
+    pad(1, `if let Some(v) = &obj.${prop} {`),
+    ...inner.map((l) => pad(2, l)),
+    pad(1, `}`),
+  ];
+};
+
+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.validator(table, typesByName),
+    );
+  }
+
+  private validator(
+    table: Type,
+    typesByName: ReadonlyMap<string, Type>,
+  ): GenerateEntry {
+    const lines = columnFields(table.fields).flatMap((field) =>
+      checksForField(
+        { ...field, type: fieldTypeOf(field, typesByName) },
+        this.casing,
+        isPkField(field, table),
+      ),
+    );
+    const has = lines.length > 0;
+    return content(
+      this.imports.datasourceValidator(table.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        fnName: this.casing.convertFields(`validate_datasource_${table.name}`),
+        paramName: has ? "obj" : "_obj",
+        typePath: this.imports.datasourceQual(table.name),
+        declared: has ? "let mut errors" : "let errors",
+        checks: lines.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/rust-generators/src/generate-datasource-types-tests.ts

@@ -0,0 +1,63 @@
+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 { samplesForNative, wrapOption } from "./common/test-samples.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+} from "./specification-parser.ts";
+import { convertSpecType } from "./deterministic-type-converter.ts";
+import { typeTestTmpl } from "./resources/datasource-types-tests.ts";
+import { Emit } from "./emit.ts";
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    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,
+        }),
+      );
+    });
+  }
+}
+
+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/rust-generators/src/generate-datasource-types.ts

@@ -0,0 +1,84 @@
+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,
+  tableKind,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import {
+  convertSpecType,
+  rustLanguageZero,
+  rustSpecDefaultExpr,
+} from "./deterministic-type-converter.ts";
+import { typesNeedingDefault } from "./struct-default.ts";
+import { typeTmpl } from "./resources/datasource-types.ts";
+import { Emit } from "./emit.ts";
+
+const rustTypeFor = (
+  field: TypeField,
+  typesByName: ReadonlyMap<string, Type>,
+): string => {
+  const t = convertSpecType(fieldTypeOf(field, typesByName));
+  return field.isNullable ? `Option<${t}>` : t;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    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),
+    );
+  }
+
+  private type(
+    table: Type,
+    typesByName: Map<string, Type>,
+    needingDefault: Set<string>,
+  ): GenerateEntry {
+    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,
+      }),
+    );
+  }
+}
+
+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/rust-generators/src/generate-openapi.ts

@@ -0,0 +1,40 @@
+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 { generate as generateJson } from "@deterministic-code/generators-openapi/generate-openapi";
+import { conformanceTmpl, routerTmpl } from "./resources/openapi.ts";
+
+const escapeRustStringLiteral = (s: string): string =>
+  s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const crateName = ctx.settings["languages.rust.crate_name"] ?? "consumer";
+  const [jsonEntry] = await generateJson(ctx);
+  if (jsonEntry === undefined || jsonEntry.kind !== "content") {
+    throw new Error("openapi json lane did not emit openapi.json");
+  }
+  const spec = JSON.parse(jsonEntry.contents) as {
+    paths?: Record<string, unknown>;
+  };
+  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,
+      }),
+    ),
+  ];
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-perf-e2e-tests.ts

@@ -0,0 +1,7 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { e2eTmpl } from "./resources/perf-e2e.ts";
+
+export const generate = async (
+  _ctx: GenerateContext,
+): Promise<GenerateEntry[]> => [content("app_perf_client.rs", e2eTmpl)];

package/node_modules/@deterministic-code/rust-generators/src/generate-perf-server.ts

@@ -0,0 +1,21 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { TYPES_YAML } from "./specification-parser.ts";
+import { serverTmpl } from "./resources/perf-server.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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",
+    ),
+  ];
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-routes-e2e-test.ts

@@ -0,0 +1,117 @@
+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,
+  isManyToMany,
+  isReadonlyLookup,
+  pkName,
+  tableByName,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+} from "./specification-parser.ts";
+import {
+  crudTestsTmpl,
+  fileTmpl,
+  readonlyTestsTmpl,
+  setupTmpl,
+} from "./resources/routes-e2e.ts";
+import { Emit } from "./emit.ts";
+
+const jsonSample = (type: string): string => {
+  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: Type): string => {
+  const parts = table.fields
+    .filter(
+      (f) =>
+        !f.isNullable &&
+        f.hasDefault !== true &&
+        f.references === undefined,
+    )
+    .map((f) => `"${f.name}":${jsonSample(f.type)}`);
+  return `{${parts.join(",")}}`;
+};
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    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 }),
+      ),
+    ];
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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),
+  );
+};