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

package/node_modules/@deterministic-code/typescript-generators/src/common/http-path.ts

@@ -0,0 +1,12 @@
+const camelIdent = (name: string): string =>
+  name.replace(/_([a-z0-9])/gi, (_, ch: string) => ch.toUpperCase());
+
+/** Map a routes-api path (snake segments, `{param}`) onto TS HTTP paths (kebab segments, camel params). */
+export const httpPathFromRoutesApi = (path: string): string =>
+  path
+    .split("/")
+    .map((segment) => {
+      const param = /^\{(.+)\}$/.exec(segment);
+      return param ? `{${camelIdent(param[1]!)}}` : segment.replace(/_/g, "-");
+    })
+    .join("/");

package/node_modules/@deterministic-code/typescript-generators/src/common/type-converters/native-to-zod.ts

@@ -0,0 +1,137 @@
+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 {
+  EMPTY_UUID,
+  GENERATIVE_TOKENS,
+  hexToBytes,
+} from "@deterministic-code/generators-common/default-token";
+
+const spec = DeterministicDefaultValueConverter.spec;
+
+const dq = (value: string): string => JSON.stringify(value);
+
+const token = (
+  specToken: SpecToken,
+  native: (arg: string) => string,
+  reverse: RegExp,
+): DefaultEntry => ({ ...specToken, native, reverse });
+
+const quoted = token(spec.string.String!, dq, /^"(.*)"$/);
+
+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: "z.string()",
+  character: "z.string()",
+  decimal: "z.string()",
+  number: "z.number()",
+  integer: "z.number()",
+  smallinteger: "z.number()",
+  unsignedinteger: "z.number()",
+  unsignedsmallinteger: "z.number()",
+  float: "z.number()",
+  reference: "z.number()",
+  biginteger: "z.number()",
+  unsignedbiginteger: "z.number()",
+  boolean: "z.boolean()",
+  binary: "z.string().base64()",
+  uuid: "z.string().uuid()",
+  datetime: "z.date()",
+});
+
+const hexNative = (arg: string): string => {
+  const bytes = hexToBytes(arg);
+  return bytes.length === 0
+    ? '""'
+    : `Buffer.from([${bytes.join(", ")}]).toString("base64")`;
+};
+
+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!, dq, /^"(.*)"$/),
+    String: quoted,
+  },
+  boolean: {
+    Boolean: token(
+      spec.boolean.Boolean!,
+      (arg) => (arg === "true" ? "true" : "false"),
+      /^(true|false)$/,
+    ),
+  },
+  datetime: {
+    Now: token(spec.datetime.Now!, () => "new Date()", /^new Date\(\)$/),
+    UtcNow: token(spec.datetime.UtcNow!, () => "new Date()", /^new Date\(\)$/),
+    DateTime: token(
+      spec.datetime.DateTime!,
+      (arg) => `new Date(${dq(arg)})`,
+      /^new Date\("(.*)"\)$/,
+    ),
+  },
+  binary: {
+    Hex: token(spec.binary.Hex!, hexNative, /^.*$/),
+  },
+  uuid: {
+    NewId: token(
+      spec.uuid.NewId!,
+      () => "crypto.randomUUID()",
+      /^crypto\.randomUUID\(\)$/,
+    ),
+    Empty: token(
+      spec.uuid.Empty!,
+      () => dq(EMPTY_UUID),
+      new RegExp(
+        `^${JSON.stringify(EMPTY_UUID).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`,
+      ),
+    ),
+    Uuid: token(spec.uuid.Uuid!, dq, /^"(.*)"$/),
+  },
+  reference: {},
+});
+
+const ID_ZOD: Record<string, string> = {
+  integer: "z.number().int().nonnegative()",
+  biginteger: "z.bigint()",
+  uuid: "z.string().uuid()",
+  string: "z.string()",
+};
+
+export const toZod = (specType: string): string =>
+  typeConverter.convert(specType);
+
+export const idTypeToZod = (idType: string): string =>
+  ID_ZOD[idType] ?? ID_ZOD.integer;
+
+/** JS expression for a spec field's `{ type, value }` default — `"null"` when absent. */
+export const toZodDefault = (
+  type: string,
+  value: string | boolean | number | null | undefined | object,
+): string => {
+  if (value !== null && typeof value === "object") return JSON.stringify(value);
+  if (value === undefined || value === null) return "null";
+  const parsed = DeterministicDefaultValueConverter.parse(type, value);
+  const literal = defaultValueConverter.convert(type, String(value));
+  if (literal === null) {
+    throw new Error(`cannot render default token "${parsed.token}"`);
+  }
+  return GENERATIVE_TOKENS.has(parsed.token) ? `() => ${literal}` : literal;
+};

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

@@ -0,0 +1,57 @@
+import { typeHasTag } from "@deterministic-code/generators-common/spec-types";
+import type {
+  Type,
+  TypeField,
+} from "@deterministic-code/deterministic-generators-common/parser";
+
+export const isAlias = (view: Type): boolean =>
+  typeHasTag(view, "datasource_type") && typeHasTag(view, "view_type");
+
+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 &&
+  view.fields.length === 0;
+
+/** Fields on the expanded view that are not columns of the inherited parent (union mapping, collections). */
+export const fieldsBeyondParent = (
+  fields: TypeField[],
+  parent: Type | undefined,
+): TypeField[] => {
+  if (parent === undefined) return fields;
+  const parentNames = new Set(parent.fields.map((f) => f.name));
+  return fields.filter((f) => !parentNames.has(f.name));
+};
+
+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";
+};
+
+export const fieldSize = (field: {
+  size?: TypeField["size"];
+}): number | undefined =>
+  typeof field.size === "number" ? field.size : undefined;
+
+export const refParent = (field: TypeField): string | undefined => {
+  if (field.references === undefined) return undefined;
+  return Array.isArray(field.references)
+    ? field.references[0]
+    : field.references.split(".")[0];
+};

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

@@ -0,0 +1,354 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import {
+  type Type,
+  type TypeField,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  persistedColumnFields,
+} from "@deterministic-code/generators-common/spec-types";
+import { toNative } from "../deterministic-type-converter.ts";
+import { valueTmpl } from "../resources/view-types-tests.ts";
+import { fakeTestData, fieldExpr } from "./fake-test-data.ts";
+import type { PackCasing } from "./default-casing.ts";
+import { fieldSize } from "./view-shape.ts";
+
+export type ShapeOpts = {
+  tables: Map<string, Type>;
+  views: Map<string, Type>;
+  typesByName: Map<string, Type>;
+  referenceBackendType: boolean;
+  casing: PackCasing;
+};
+
+export type ShapeNode = {
+  name: string;
+  ident: string;
+  access: string;
+  path: string;
+  testName: string;
+  type: string;
+  nullable: boolean;
+  hasDefault: boolean;
+  isArray: boolean;
+  isObject: boolean;
+  isPrimitive: boolean;
+  isRoot: boolean;
+  /** Sample dictionary key. An empty record is valid, so presence checks do not apply. */
+  mapEntry: boolean;
+  expr: string;
+  nested: ShapeNode[];
+};
+
+export const escapeTestName = (name: string): string =>
+  name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+
+const fieldAccess = (ident: string): string =>
+  ident.startsWith('"') ? `[${ident}]` : `.${ident}`;
+
+const primitiveExpr = (type: string, size?: number): string =>
+  fieldExpr(fakeTestData, type, {
+    nativeType: toNative(type),
+    size,
+  });
+
+const nestedTokens = (
+  nested: ShapeNode[],
+): Array<{ ident: string; value: string; last: boolean }> =>
+  nested.map((child, i, all) => ({
+    ident: child.ident,
+    value: renderValue(child),
+    last: i === all.length - 1,
+  }));
+
+export const renderValue = (
+  node: Pick<
+    ShapeNode,
+    "isArray" | "isObject" | "isPrimitive" | "expr" | "nested"
+  >,
+): string =>
+  fill(valueTmpl, {
+    isArray: node.isArray,
+    isObject: node.isObject,
+    isPrimitive: node.isPrimitive,
+    expr: node.expr,
+    nested: nestedTokens(node.nested),
+  }).trimEnd();
+
+export const renderObject = (fields: ShapeNode[]): string =>
+  fill(valueTmpl, {
+    isArray: false,
+    isObject: true,
+    isPrimitive: false,
+    expr: "",
+    nested: nestedTokens(fields),
+  }).trimEnd();
+
+const scalarNode = (
+  field: {
+    name: string;
+    type: string;
+    isNullable: boolean;
+    hasDefault?: boolean;
+    size?: TypeField["size"];
+  },
+  accessPrefix: string,
+  pathPrefix: string,
+  isRoot: boolean,
+  casing: PackCasing,
+): ShapeNode => {
+  const ident = casing.fieldIdent(field.name);
+  const path = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+  return {
+    name: field.name,
+    ident,
+    access: `${accessPrefix}${fieldAccess(ident)}`,
+    path,
+    testName: escapeTestName(path),
+    type: field.type,
+    nullable: field.isNullable,
+    hasDefault: field.hasDefault === true,
+    isArray: false,
+    isObject: false,
+    isPrimitive: true,
+    isRoot,
+    mapEntry: false,
+    expr: primitiveExpr(field.type, fieldSize(field)),
+    nested: [],
+  };
+};
+
+const dsNodes = (
+  name: string,
+  opts: ShapeOpts,
+  accessPrefix: string,
+  pathPrefix: string,
+): ShapeNode[] => {
+  const table = opts.tables.get(name);
+  if (table === undefined) return [];
+  return persistedColumnFields(table, opts.typesByName).map((f) =>
+    scalarNode(f, accessPrefix, pathPrefix, false, opts.casing),
+  );
+};
+
+const childNodes = (
+  base: string,
+  opts: ShapeOpts,
+  visited: Set<string>,
+  accessPrefix: string,
+  pathPrefix: string,
+): ShapeNode[] => {
+  const isView = opts.views.has(base);
+  return isView && !(opts.referenceBackendType && opts.tables.has(base))
+    ? viewNodes(base, opts, visited, accessPrefix, pathPrefix)
+    : dsNodes(base, opts, accessPrefix, pathPrefix);
+};
+
+const mapValueNode = (
+  value: TypeField,
+  opts: ShapeOpts,
+  visited: Set<string>,
+  access: string,
+  path: string,
+): ShapeNode => {
+  const ident = opts.casing.fieldIdent("k");
+  if (value.kind === "primitive") {
+    return {
+      name: "k",
+      ident,
+      access,
+      path,
+      testName: escapeTestName(path),
+      type: value.base,
+      nullable: value.isNullable,
+      hasDefault: value.hasDefault === true,
+      isArray: false,
+      isObject: false,
+      isPrimitive: true,
+      isRoot: false,
+      mapEntry: true,
+      expr: primitiveExpr(value.base, fieldSize(value)),
+      nested: [],
+    };
+  }
+  return {
+    name: "k",
+    ident,
+    access,
+    path,
+    testName: escapeTestName(path),
+    type: value.type,
+    nullable: value.isNullable,
+    hasDefault: false,
+    isArray: false,
+    isObject: true,
+    isPrimitive: false,
+    isRoot: false,
+    mapEntry: true,
+    expr: "",
+    nested: childNodes(value.base, opts, visited, access, path),
+  };
+};
+
+const viewFieldNode = (
+  field: TypeField,
+  opts: ShapeOpts,
+  visited: Set<string>,
+  accessPrefix: string,
+  pathPrefix: string,
+  isRoot: boolean,
+): ShapeNode => {
+  const dict = dictionaryOfField(field, opts.typesByName);
+  const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+  if (entry !== undefined) {
+    const ident = opts.casing.fieldIdent(field.name);
+    const path = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+    const access = `${accessPrefix}${fieldAccess(ident)}`;
+    return {
+      name: field.name,
+      ident,
+      access,
+      path,
+      testName: escapeTestName(path),
+      type: field.type,
+      nullable: field.isNullable,
+      hasDefault: false,
+      isArray: false,
+      isObject: true,
+      isPrimitive: false,
+      isRoot,
+      mapEntry: false,
+      expr: "",
+      nested: [
+        mapValueNode(
+          entry.value,
+          opts,
+          visited,
+          `${access}["k"]`,
+          `${path}.k`,
+        ),
+      ],
+    };
+  }
+  if (field.kind === "primitive") {
+    const ident = opts.casing.fieldIdent(field.name);
+    const path = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+    return {
+      name: field.name,
+      ident,
+      access: `${accessPrefix}${fieldAccess(ident)}`,
+      path,
+      testName: escapeTestName(path),
+      type: field.base,
+      nullable: field.isNullable,
+      hasDefault: field.hasDefault === true,
+      isArray: field.isArray,
+      isObject: false,
+      isPrimitive: true,
+      isRoot,
+      mapEntry: false,
+      expr: primitiveExpr(field.base, fieldSize(field)),
+      nested: [],
+    };
+  }
+  const ident = opts.casing.fieldIdent(field.name);
+  const path = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+  const access = `${accessPrefix}${fieldAccess(ident)}`;
+  const childPrefix = field.isArray ? `${access}[0]` : access;
+  return {
+    name: field.name,
+    ident,
+    access,
+    path,
+    testName: escapeTestName(path),
+    type: field.type,
+    nullable: field.isNullable,
+    hasDefault: false,
+    isArray: field.isArray,
+    isObject: true,
+    isPrimitive: false,
+    isRoot,
+    mapEntry: false,
+    expr: "",
+    nested: childNodes(field.base, opts, visited, childPrefix, path),
+  };
+};
+
+const shapedNodes = (
+  view: Type,
+  opts: ShapeOpts,
+  visited: Set<string>,
+  accessPrefix: string,
+  pathPrefix: string,
+  isRoot: boolean,
+): ShapeNode[] =>
+  view.fields.map((f) =>
+    viewFieldNode(f, opts, visited, accessPrefix, pathPrefix, isRoot),
+  );
+
+export const viewNodes = (
+  name: string,
+  opts: ShapeOpts,
+  visited: Set<string>,
+  accessPrefix = "",
+  pathPrefix = "",
+  isRoot = false,
+): ShapeNode[] => {
+  if (visited.has(name)) return [];
+  const view = opts.views.get(name);
+  if (view === undefined) return [];
+  const next = new Set(visited).add(name);
+  return shapedNodes(view, opts, next, accessPrefix, pathPrefix, isRoot);
+};
+
+export const shapedViewNodes = (
+  view: Type,
+  opts: ShapeOpts,
+): ShapeNode[] =>
+  shapedNodes(view, opts, new Set([view.name]), "", "", true);
+
+export const flattenNodes = (nodes: ShapeNode[]): ShapeNode[] =>
+  nodes.flatMap((node) => [node, ...flattenNodes(node.nested)]);
+
+export const renderMutatedObject = (
+  roots: ShapeNode[],
+  target: ShapeNode,
+  replacement: "omit" | "null" | string,
+): string => {
+  const children = (
+    nodes: ShapeNode[],
+  ): Array<{ ident: string; value: string; last: boolean }> => {
+    const kept = nodes.filter(
+      (node) => !(node === target && replacement === "omit"),
+    );
+    return kept.map((node, i, all) => {
+      let value: string;
+      if (node === target) {
+        value = replacement === "null" ? "null" : replacement;
+      } else if (node.isObject) {
+        value = fill(valueTmpl, {
+          isArray: node.isArray,
+          isObject: true,
+          isPrimitive: false,
+          expr: "",
+          nested: children(node.nested),
+        }).trimEnd();
+      } else {
+        value = renderValue(node);
+      }
+      return {
+        ident: node.ident,
+        value,
+        last: i === all.length - 1,
+      };
+    });
+  };
+  return fill(valueTmpl, {
+    isArray: false,
+    isObject: true,
+    isPrimitive: false,
+    expr: "",
+    nested: children(roots),
+  }).trimEnd();
+};

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

@@ -0,0 +1,134 @@
+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 {
+  EMPTY_UUID,
+  hexToBytes,
+} from "@deterministic-code/generators-common/default-token";
+
+const spec = DeterministicDefaultValueConverter.spec;
+
+const dq = (value: string): string => JSON.stringify(value);
+
+const token = (
+  specToken: SpecToken,
+  native: (arg: string) => string,
+  reverse: RegExp,
+): DefaultEntry => ({ ...specToken, native, reverse });
+
+const quoted = token(spec.string.String!, dq, /^"(.*)"$/);
+
+const exactQuoted = (value: string): RegExp =>
+  new RegExp(
+    `^${JSON.stringify(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`,
+  );
+
+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: "number",
+  integer: "number",
+  unsignedinteger: "number",
+  smallinteger: "number",
+  unsignedsmallinteger: "number",
+  biginteger: "number",
+  unsignedbiginteger: "number",
+  float: "number",
+  decimal: "string",
+  boolean: "boolean",
+  datetime: "Date",
+  binary: "string",
+  uuid: "string",
+  reference: "number",
+});
+
+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!, dq, /^"(.*)"$/),
+    String: quoted,
+  },
+  boolean: {
+    Boolean: token(
+      spec.boolean.Boolean!,
+      (arg) => (arg === "true" ? "true" : "false"),
+      /^(true|false)$/,
+    ),
+  },
+  datetime: {
+    Now: token(spec.datetime.Now!, () => "new Date()", /^new Date\(\)$/),
+    UtcNow: token(spec.datetime.UtcNow!, () => "new Date()", /^new Date\(\)$/),
+    DateTime: token(
+      spec.datetime.DateTime!,
+      (arg) => `new Date(${dq(arg)})`,
+      /^new Date\("(.*)"\)$/,
+    ),
+  },
+  binary: {
+    Hex: token(
+      spec.binary.Hex!,
+      (arg) => {
+        const bytes = hexToBytes(arg);
+        return bytes.length === 0
+          ? '""'
+          : `Buffer.from([${bytes.join(", ")}]).toString("base64")`;
+      },
+      /^.*$/,
+    ),
+  },
+  uuid: {
+    NewId: token(
+      spec.uuid.NewId!,
+      () => "crypto.randomUUID()",
+      /^crypto\.randomUUID\(\)$/,
+    ),
+    Empty: token(spec.uuid.Empty!, () => dq(EMPTY_UUID), exactQuoted(EMPTY_UUID)),
+    Uuid: token(spec.uuid.Uuid!, dq, /^"(.*)"$/),
+  },
+  reference: {},
+});
+
+export const toNative = (specType: string): string =>
+  typeConverter.convert(specType);
+
+const isTsZeroExpr = (expr: string): boolean =>
+  expr === "false" || expr === "0" || expr === '""';
+
+/** Native initializer, or `undefined` when absent or the language zero. */
+export const nativeDefaultExpr = (
+  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 expr;
+  return isTsZeroExpr(expr) ? undefined : expr;
+};