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

package/node_modules/@deterministic-code/rust-generators/src/common/default-casing.ts

@@ -0,0 +1,47 @@
+import {
+  createCasingStrategy,
+  type ICasingStrategy,
+} from "@deterministic-code/generators-common/casing-strategy";
+
+export const GENERATOR_LANGUAGE = "rust";
+
+const VARIANT_PREFIXES = ["update_", "create_"] as const;
+
+const featureEntity = (entity: string): string => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === undefined ? entity : entity.slice(prefix.length);
+};
+
+export type PackCasing = ICasingStrategy & {
+  fileBase: (stem: string) => string
+  directory: (entity: string) => string
+  filePath: (stem: string) => string
+  serviceClassName: (entity: string) => string
+  fnIdent: (stem: string) => string
+};
+
+/** Language defaults + settings overrides. Layout (by-feature) lives on ImportGenerator. */
+export const createCasing = (
+  settings: Record<string, string>,
+): PackCasing => {
+  const casing = createCasingStrategy(GENERATOR_LANGUAGE, settings);
+  const fileBase = (stem: string): string => casing.convertFileName(stem);
+  const directory = (entity: string): string =>
+    casing.convertDirectories(featureEntity(entity));
+  const filePath = (stem: string): string => `${fileBase(stem)}.rs`;
+  return {
+    convertFileName: (text: string) => casing.convertFileName(text),
+    convertTypes: (text: string) => casing.convertTypes(text),
+    convertFields: (text: string) => casing.convertFields(text),
+    convertDirectories: (text: string) => casing.convertDirectories(text),
+    fileBase,
+    directory,
+    filePath,
+    serviceClassName: (entity: string) => casing.convertTypes(`${entity}_service`),
+    fnIdent: (stem: string) => casing.convertFields(stem),
+  };
+};
+
+export const defaultCasing = (
+  settings: Record<string, string>,
+): ICasingStrategy => createCasing(settings);

package/node_modules/@deterministic-code/rust-generators/src/common/dictionary-candidate.ts

@@ -0,0 +1,4 @@
+/** Owned dictionaries are maps nested on an owner, not CRUD entities. */
+export const isDictionaryCandidate = (candidate: {
+  inherits?: string;
+}): boolean => candidate.inherits === "dictionary";

package/node_modules/@deterministic-code/rust-generators/src/common/test-samples.ts

@@ -0,0 +1,82 @@
+import { convertSpecType } from "../deterministic-type-converter.ts";
+
+export const rustString = (value: string): string =>
+  `String::from(${JSON.stringify(value)})`;
+
+const rustDatetime = (iso: string): string =>
+  `chrono::DateTime::parse_from_rfc3339(${JSON.stringify(iso)}).unwrap().with_timezone(&chrono::Utc)`;
+
+export const samplesForNative = (
+  native: string,
+  fieldType: string,
+): { sample: string; next: string } => {
+  switch (native) {
+    case "i64":
+      return { sample: "1i64", next: "2i64" };
+    case "i32":
+      return { sample: "1i32", next: "2i32" };
+    case "i16":
+      return { sample: "1i16", next: "2i16" };
+    case "u64":
+      return { sample: "1u64", next: "2u64" };
+    case "u32":
+      return { sample: "1u32", next: "2u32" };
+    case "u16":
+      return { sample: "1u16", next: "2u16" };
+    case "f64":
+      return { sample: "1.0f64", next: "2.0f64" };
+    case "bool":
+      return { sample: "false", next: "true" };
+    case "uuid::Uuid":
+      return {
+        sample: "uuid::Uuid::nil()",
+        next: "uuid::Uuid::from_u128(1)",
+      };
+    case "Vec<u8>":
+      return { sample: "Vec::<u8>::new()", next: "vec![1u8]" };
+    case "chrono::DateTime<chrono::Utc>":
+      return {
+        sample: rustDatetime("2024-01-01T00:00:00.000Z"),
+        next: rustDatetime("2024-01-02T00:00:00.000Z"),
+      };
+    case "String":
+      if (fieldType === "decimal") {
+        return { sample: rustString("0"), next: rustString("1") };
+      }
+      if (fieldType === "uuid") {
+        return {
+          sample: rustString("00000000-0000-0000-0000-000000000000"),
+          next: rustString("00000000-0000-0000-0000-000000000001"),
+        };
+      }
+      if (fieldType === "datetime") {
+        return {
+          sample: rustString("2024-01-01T00:00:00.000Z"),
+          next: rustString("2024-01-02T00:00:00.000Z"),
+        };
+      }
+      if (fieldType === "date") {
+        return {
+          sample: rustString("2024-01-01"),
+          next: rustString("2024-01-02"),
+        };
+      }
+      if (fieldType === "email") {
+        return {
+          sample: rustString("sample@example.com"),
+          next: rustString("next@example.com"),
+        };
+      }
+      return { sample: rustString("sample"), next: rustString("sample-next") };
+    default:
+      throw new Error(`Unknown rust native type: ${native}`);
+  }
+};
+
+export const wrapOption = (expr: string, nullable: boolean): string =>
+  nullable ? `Some(${expr})` : expr;
+
+export const sampleForField = (type: string, isNullable: boolean): string => {
+  const { sample } = samplesForNative(convertSpecType(type), type);
+  return wrapOption(sample, isNullable);
+};

package/node_modules/@deterministic-code/rust-generators/src/common/view-shape.ts

@@ -0,0 +1,46 @@
+import { isCollectionField } from "@deterministic-code/generators-common/spec-types";
+import { typeHasTag, type Type, type TypeField } from "../specification-parser.ts";
+
+export const isAlias = (view: Type): boolean =>
+  typeHasTag(view, "datasource_type");
+
+export const isUnionEnum = (view: Type): boolean =>
+  view.kind === "union" && (view.union?.length ?? 0) > 0;
+
+export const wrapsInheritedDatasource = (
+  view: Type,
+  datasourceNames: Set<string>,
+): boolean =>
+  !isAlias(view) &&
+  view.kind === "inherit" &&
+  view.inherits !== undefined &&
+  datasourceNames.has(view.inherits) &&
+  (view.removeFields?.length ?? 0) === 0;
+
+export const emitViewFields = (
+  view: Type,
+  expanded: Type | undefined,
+  datasourceNames: Set<string>,
+): TypeField[] => {
+  if (isAlias(view)) {
+    return (expanded?.fields ?? view.fields).filter(isCollectionField);
+  }
+  if (wrapsInheritedDatasource(view, datasourceNames)) return view.fields;
+  return expanded?.fields ?? view.fields;
+};
+
+export const fieldRefKind = (
+  field: TypeField,
+  typesByName: Map<string, Type>,
+): "primitive" | "datasource" | "view" => {
+  if (field.kind === "primitive") return "primitive";
+  const referenced = typesByName.get(field.base);
+  if (referenced === undefined) return "view";
+  if (
+    typeHasTag(referenced, "view_type") &&
+    !typeHasTag(referenced, "datasource_type")
+  ) {
+    return "view";
+  }
+  return "datasource";
+};

package/node_modules/@deterministic-code/rust-generators/src/common/view-test-fixtures.ts

@@ -0,0 +1,162 @@
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  isCollectionField,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource,
+} from "./view-shape.ts";
+import { sampleForField, samplesForNative } from "./test-samples.ts";
+import { convertSpecType } from "../deterministic-type-converter.ts";
+import type { PackCasing } from "./default-casing.ts";
+import type { RustImportGenerator } from "../import-generator.ts";
+import type { Type, TypeField } from "../specification-parser.ts";
+import { fieldRefKind } from "./view-shape.ts";
+
+export type ViewTestOpts = {
+  casing: PackCasing;
+  imports: RustImportGenerator;
+  tables: Map<string, Type>;
+  views: Map<string, Type>;
+  expandedViews: Map<string, Type>;
+  typesByName: Map<string, Type>;
+  datasourceNames: Set<string>;
+};
+
+export type FieldTok = {
+  ident: string;
+  sampleExpr: string;
+  nextExpr: string;
+  nullable: boolean;
+  getsTest: string;
+  setsTest: string;
+  allowsNoneTest: string;
+};
+
+export const renderDs = (name: string, opts: ViewTestOpts): string => {
+  const table = opts.tables.get(name);
+  const cls = opts.imports.datasourceQual(name);
+  if (table === undefined) return `${cls} {}`;
+  if (table.fields.length === 0) return `${cls} {}`;
+  const body = table.fields
+    .map(
+      (f) =>
+        `${opts.casing.convertFields(f.name)}: ${sampleForField(f.type, f.isNullable)}`,
+    )
+    .join(", ");
+  return `${cls} { ${body} }`;
+};
+
+const wrapValue = (
+  expr: string,
+  field: { isArray: boolean; isMap?: boolean; isNullable: boolean },
+): string => {
+  const inner = field.isMap === true
+    ? `HashMap::from([(String::from("k"), ${expr})])`
+    : field.isArray
+      ? `vec![${expr}]`
+      : expr;
+  return field.isNullable ? `Some(${inner})` : inner;
+};
+
+const viewFieldTok = (
+  field: TypeField,
+  opts: ViewTestOpts,
+  visited: Set<string>,
+): FieldTok => {
+  let pair: { sample: string; next: string };
+  const dict = dictionaryOfField(field, opts.typesByName);
+  const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+  const target = entry?.value ?? field;
+  const refKind = fieldRefKind(target, opts.typesByName);
+  if (refKind === "primitive") {
+    pair = samplesForNative(convertSpecType(target.base), target.base);
+  } else {
+    const expr =
+      refKind === "datasource"
+        ? renderDs(target.base, opts)
+        : viewExpr(target.base, opts, visited);
+    pair = { sample: expr, next: expr };
+  }
+  return {
+    ident: opts.casing.convertFields(field.name),
+    sampleExpr: wrapValue(pair.sample, field),
+    nextExpr: wrapValue(pair.next, field),
+    nullable: field.isNullable,
+    getsTest: opts.casing.fnIdent(`gets_${field.name}`),
+    setsTest: opts.casing.fnIdent(`sets_${field.name}`),
+    allowsNoneTest: opts.casing.fnIdent(
+      `allows_setting_${field.name}_to_none`,
+    ),
+  };
+};
+
+const baseTok = (
+  ident: string,
+  expr: string,
+  opts: ViewTestOpts,
+): FieldTok => ({
+  ident,
+  sampleExpr: expr,
+  nextExpr: expr,
+  nullable: false,
+  getsTest: opts.casing.fnIdent(`gets_${ident}`),
+  setsTest: opts.casing.fnIdent(`sets_${ident}`),
+  allowsNoneTest: opts.casing.fnIdent(`allows_setting_${ident}_to_none`),
+});
+
+export const shapedToks = (
+  view: Type,
+  opts: ViewTestOpts,
+  visited: Set<string>,
+): FieldTok[] => {
+  const expanded = opts.expandedViews.get(view.name);
+  if (isAlias(view)) {
+    const extras = (expanded ?? view).fields
+      .filter(isCollectionField)
+      .map((f) => viewFieldTok(f, opts, visited));
+    if (extras.length === 0) {
+      return (expanded ?? view).fields.map((f) => viewFieldTok(f, opts, visited));
+    }
+    return [baseTok("base", renderDs(view.name, opts), opts), ...extras];
+  }
+  const source = wrapsInheritedDatasource(view, opts.datasourceNames)
+    ? view
+    : (expanded ?? view);
+  const fields = source.fields.map((f) => viewFieldTok(f, opts, visited));
+  if (wrapsInheritedDatasource(view, opts.datasourceNames) && view.inherits) {
+    return [baseTok("base", renderDs(view.inherits, opts), opts), ...fields];
+  }
+  return fields;
+};
+
+export const viewExpr = (
+  name: string,
+  opts: ViewTestOpts,
+  visited: Set<string>,
+): string => {
+  if (visited.has(name)) {
+    throw new Error(`cyclic view reference: ${name}`);
+  }
+  const view = opts.views.get(name);
+  if (view === undefined) {
+    throw new Error(`unknown view: ${name}`);
+  }
+  const next = new Set(visited).add(name);
+  const cls = opts.imports.viewQual(name);
+  if (isUnionEnum(view)) {
+    const first = view.union![0]!;
+    return `${cls}::${opts.casing.convertTypes(first)}(${viewExpr(first, opts, next)})`;
+  }
+  if (isAlias(view)) {
+    const extras = (opts.expandedViews.get(view.name) ?? view).fields.filter(
+      isCollectionField,
+    );
+    if (extras.length === 0) return renderDs(view.name, opts);
+  }
+  const fields = shapedToks(view, opts, next);
+  if (fields.length === 0) return `${cls} {}`;
+  return `${cls} { ${fields.map((f) => `${f.ident}: ${f.sampleExpr}`).join(", ")} }`;
+};

package/node_modules/@deterministic-code/rust-generators/src/deterministic-type-converter.ts

@@ -0,0 +1,168 @@
+import {
+  DeterministicDefaultValueConverter,
+  type DefaultEntry,
+  type SpecToken,
+} 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: string): string => {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `String::from("${escaped}")`;
+};
+
+const token = (
+  specToken: SpecToken,
+  native: (arg: string) => string,
+  reverse: RegExp,
+): DefaultEntry => ({ ...specToken, native, reverse });
+
+const quoted = token(spec.string.String!, rustString, /^String::from\("(.*)"\)$/);
+
+const numeric = (type: string): Record<string, DefaultEntry> => {
+  const numericSpec = spec[type]!.Numeric!;
+  return {
+    Numeric: token(numericSpec, (arg) => arg, numericSpec.spec),
+    String: token(numericSpec, (arg) => arg, numericSpec.spec),
+  };
+};
+
+export 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",
+});
+
+export 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: {},
+});
+
+export const toNative = (specType: string): string =>
+  typeConverter.convert(specType);
+
+export const convertSpecType = toNative;
+
+const isRustZeroExpr = (expr: string): boolean =>
+  expr === "false" ||
+  expr === "0" ||
+  expr === "0.0" ||
+  expr === "String::new()" ||
+  expr === 'String::from("")' ||
+  expr === "vec![]" ||
+  expr === "None";
+
+/** Spec default expression, or `undefined` when absent or the language zero. */
+export const rustSpecDefaultExpr = (
+  specType: string,
+  field: {
+    hasDefault?: boolean;
+    defaultValue?: string | number | boolean | null;
+    isNullable: boolean;
+  },
+): string | undefined => {
+  if (field.hasDefault !== true) return undefined;
+  const expr = defaultValueConverter.convert(
+    specType,
+    String(field.defaultValue),
+  );
+  if (expr === null) return undefined;
+  if (field.isNullable) return `Some(${expr})`;
+  return isRustZeroExpr(expr) ? undefined : expr;
+};
+
+export const rustLanguageZero = (rustType: string): string => {
+  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()`;
+};

package/node_modules/@deterministic-code/rust-generators/src/emit.ts

@@ -0,0 +1,22 @@
+import {
+  fromSettings,
+  type ISettings,
+} from "@deterministic-code/generators-common/settings";
+import { createCasing, type PackCasing } from "./common/default-casing.ts";
+import {
+  createImportGenerator,
+  type RustImportGenerator,
+} from "./import-generator.ts";
+
+/** Settings plus a pack import generator created once; lanes use `this.imports`. */
+export class Emit {
+  readonly settings: ISettings;
+  readonly casing: PackCasing;
+  readonly imports: RustImportGenerator;
+
+  constructor(raw: Record<string, string>, basePath = ".") {
+    this.settings = fromSettings(raw);
+    this.casing = createCasing(raw);
+    this.imports = createImportGenerator(basePath, raw);
+  }
+}

package/node_modules/@deterministic-code/rust-generators/src/generate-backend-app.ts

@@ -0,0 +1,45 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  cargoToml,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  libRs,
+  mainRs,
+} from "./resources/backend-app.ts";
+
+const DEFAULT_APP_NAME = "generated-app";
+
+const crateIdentFromAppName = (appName: string): string => {
+  const ident = appName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  const base = ident || "generated_app";
+  return /^[0-9]/.test(base) ? `app_${base}` : base;
+};
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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"),
+  ];
+};

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

@@ -0,0 +1 @@
+export type { GenerateContext } from "@deterministic-code/generators-common/generate-context";