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

package/node_modules/@deterministic-code/typescript-generators/dist/common/fake-test-data.js

@@ -0,0 +1,88 @@
+import { patch } from "@deterministic-code/generators-common/generate-entry";
+const idExpr = (data, idType) => {
+  if (idType === "uuid") return data.uuid();
+  if (idType === "string") return data.string();
+  if (idType === "biginteger") return data.biginteger();
+  return data.integer();
+};
+const typescriptFakerTestData = {
+  target: "typescript",
+  strategy: "faker",
+  prelude: () => [`import { faker } from "@faker-js/faker";`],
+  uuid: () => "faker.string.uuid()",
+  string: (size) => size === void 0 ? "faker.string.alphanumeric({ length: 12 })" : `faker.string.alphanumeric({ length: ${size} })`,
+  integer: () => "faker.number.int({ min: 1 })",
+  biginteger: () => "faker.number.bigInt({ min: 1n })",
+  float: () => "faker.number.float()",
+  decimal: () => "faker.commerce.price()",
+  boolean: () => "faker.datatype.boolean()",
+  datetime: () => "faker.date.recent()",
+  date: () => "faker.date.recent().toISOString().slice(0, 10)",
+  email: () => "faker.internet.email()",
+  binary: () => "faker.string.alphanumeric({ length: 24 })",
+  id: (idType) => idExpr(typescriptFakerTestData, idType)
+};
+const fakeTestData = typescriptFakerTestData;
+const FAKER_DEV_DEPENDENCY = "^9.9.0";
+const fakerPackagePatch = (filename = "package.json") => patch(
+  filename,
+  JSON.stringify({
+    devDependencies: { "@faker-js/faker": FAKER_DEV_DEPENDENCY }
+  })
+);
+const withFakerPackagePatch = (entries, filename = "package.json") => entries.length === 0 ? entries : [...entries, fakerPackagePatch(filename)];
+const asIdType = (idType) => {
+  if (idType === "uuid" || idType === "string" || idType === "biginteger") {
+    return idType;
+  }
+  return "integer";
+};
+const preludeSource = (data) => {
+  const lines = data.prelude();
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+};
+const fieldExpr = (data, type, opts = {}) => {
+  if (opts.nativeType === "bigint") return data.biginteger();
+  switch (type) {
+    case "uuid":
+      return data.uuid();
+    case "string":
+    case "character":
+      return data.string(opts.size);
+    case "email":
+      return data.email();
+    case "binary":
+      return data.binary();
+    case "boolean":
+      return data.boolean();
+    case "decimal":
+      return data.decimal();
+    case "float":
+      return data.float();
+    case "datetime":
+      return data.datetime();
+    case "date":
+      return data.date();
+    case "number":
+    case "integer":
+    case "smallinteger":
+    case "biginteger":
+    case "unsignedinteger":
+    case "unsignedsmallinteger":
+    case "unsignedbiginteger":
+    case "reference":
+      return data.integer();
+    default:
+      return data.string(opts.size);
+  }
+};
+export {
+  FAKER_DEV_DEPENDENCY,
+  asIdType,
+  fakeTestData,
+  fakerPackagePatch,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch
+};

package/node_modules/@deterministic-code/typescript-generators/dist/common/http-path.js

@@ -0,0 +1,8 @@
+const camelIdent = (name) => name.replace(/_([a-z0-9])/gi, (_, ch) => ch.toUpperCase());
+const httpPathFromRoutesApi = (path) => path.split("/").map((segment) => {
+  const param = /^\{(.+)\}$/.exec(segment);
+  return param ? `{${camelIdent(param[1])}}` : segment.replace(/_/g, "-");
+}).join("/");
+export {
+  httpPathFromRoutesApi
+};

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

@@ -0,0 +1,118 @@
+import {
+  DeterministicDefaultValueConverter
+} 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) => JSON.stringify(value);
+const token = (specToken, native, reverse) => ({ ...specToken, native, reverse });
+const quoted = token(spec.string.String, dq, /^"(.*)"$/);
+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: "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) => {
+  const bytes = hexToBytes(arg);
+  return bytes.length === 0 ? '""' : `Buffer.from([${bytes.join(", ")}]).toString("base64")`;
+};
+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 = {
+  integer: "z.number().int().nonnegative()",
+  biginteger: "z.bigint()",
+  uuid: "z.string().uuid()",
+  string: "z.string()"
+};
+const toZod = (specType) => typeConverter.convert(specType);
+const idTypeToZod = (idType) => ID_ZOD[idType] ?? ID_ZOD.integer;
+const toZodDefault = (type, value) => {
+  if (value !== null && typeof value === "object") return JSON.stringify(value);
+  if (value === void 0 || 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;
+};
+export {
+  defaultValueConverter,
+  idTypeToZod,
+  toZod,
+  toZodDefault,
+  typeConverter
+};

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

@@ -0,0 +1,30 @@
+import { typeHasTag } from "@deterministic-code/generators-common/spec-types";
+const isAlias = (view) => typeHasTag(view, "datasource_type") && typeHasTag(view, "view_type");
+const wrapsInheritedDatasource = (view, datasourceNames) => !isAlias(view) && view.kind === "inherit" && view.inherits !== void 0 && datasourceNames.has(view.inherits) && (view.removeFields?.length ?? 0) === 0 && view.fields.length === 0;
+const fieldsBeyondParent = (fields, parent) => {
+  if (parent === void 0) return fields;
+  const parentNames = new Set(parent.fields.map((f) => f.name));
+  return fields.filter((f) => !parentNames.has(f.name));
+};
+const fieldRefKind = (field, typesByName) => {
+  if (field.kind === "primitive") return "primitive";
+  const referenced = typesByName.get(field.base);
+  if (referenced === void 0) return "view";
+  if (typeHasTag(referenced, "view_type") && !typeHasTag(referenced, "datasource_type")) {
+    return "view";
+  }
+  return "datasource";
+};
+const fieldSize = (field) => typeof field.size === "number" ? field.size : void 0;
+const refParent = (field) => {
+  if (field.references === void 0) return void 0;
+  return Array.isArray(field.references) ? field.references[0] : field.references.split(".")[0];
+};
+export {
+  fieldRefKind,
+  fieldSize,
+  fieldsBeyondParent,
+  isAlias,
+  refParent,
+  wrapsInheritedDatasource
+};

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

@@ -0,0 +1,238 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import {
+  dictionaryEntryFields,
+  dictionaryOfField,
+  persistedColumnFields
+} from "@deterministic-code/generators-common/spec-types";
+import { toNative } from "../deterministic-type-converter.js";
+import { valueTmpl } from "../resources/view-types-tests.js";
+import { fakeTestData, fieldExpr } from "./fake-test-data.js";
+import { fieldSize } from "./view-shape.js";
+const escapeTestName = (name) => name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+const fieldAccess = (ident) => ident.startsWith('"') ? `[${ident}]` : `.${ident}`;
+const primitiveExpr = (type, size) => fieldExpr(fakeTestData, type, {
+  nativeType: toNative(type),
+  size
+});
+const nestedTokens = (nested) => nested.map((child, i, all) => ({
+  ident: child.ident,
+  value: renderValue(child),
+  last: i === all.length - 1
+}));
+const renderValue = (node) => fill(valueTmpl, {
+  isArray: node.isArray,
+  isObject: node.isObject,
+  isPrimitive: node.isPrimitive,
+  expr: node.expr,
+  nested: nestedTokens(node.nested)
+}).trimEnd();
+const renderObject = (fields) => fill(valueTmpl, {
+  isArray: false,
+  isObject: true,
+  isPrimitive: false,
+  expr: "",
+  nested: nestedTokens(fields)
+}).trimEnd();
+const scalarNode = (field, accessPrefix, pathPrefix, isRoot, casing) => {
+  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, opts, accessPrefix, pathPrefix) => {
+  const table = opts.tables.get(name);
+  if (table === void 0) return [];
+  return persistedColumnFields(table, opts.typesByName).map(
+    (f) => scalarNode(f, accessPrefix, pathPrefix, false, opts.casing)
+  );
+};
+const childNodes = (base, opts, visited, accessPrefix, pathPrefix) => {
+  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, opts, visited, access, path) => {
+  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, opts, visited, accessPrefix, pathPrefix, isRoot) => {
+  const dict = dictionaryOfField(field, opts.typesByName);
+  const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+  if (entry !== void 0) {
+    const ident2 = opts.casing.fieldIdent(field.name);
+    const path2 = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+    const access2 = `${accessPrefix}${fieldAccess(ident2)}`;
+    return {
+      name: field.name,
+      ident: ident2,
+      access: access2,
+      path: path2,
+      testName: escapeTestName(path2),
+      type: field.type,
+      nullable: field.isNullable,
+      hasDefault: false,
+      isArray: false,
+      isObject: true,
+      isPrimitive: false,
+      isRoot,
+      mapEntry: false,
+      expr: "",
+      nested: [
+        mapValueNode(
+          entry.value,
+          opts,
+          visited,
+          `${access2}["k"]`,
+          `${path2}.k`
+        )
+      ]
+    };
+  }
+  if (field.kind === "primitive") {
+    const ident2 = opts.casing.fieldIdent(field.name);
+    const path2 = pathPrefix === "" ? field.name : `${pathPrefix}.${field.name}`;
+    return {
+      name: field.name,
+      ident: ident2,
+      access: `${accessPrefix}${fieldAccess(ident2)}`,
+      path: path2,
+      testName: escapeTestName(path2),
+      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, opts, visited, accessPrefix, pathPrefix, isRoot) => view.fields.map(
+  (f) => viewFieldNode(f, opts, visited, accessPrefix, pathPrefix, isRoot)
+);
+const viewNodes = (name, opts, visited, accessPrefix = "", pathPrefix = "", isRoot = false) => {
+  if (visited.has(name)) return [];
+  const view = opts.views.get(name);
+  if (view === void 0) return [];
+  const next = new Set(visited).add(name);
+  return shapedNodes(view, opts, next, accessPrefix, pathPrefix, isRoot);
+};
+const shapedViewNodes = (view, opts) => shapedNodes(view, opts, /* @__PURE__ */ new Set([view.name]), "", "", true);
+const flattenNodes = (nodes) => nodes.flatMap((node) => [node, ...flattenNodes(node.nested)]);
+const renderMutatedObject = (roots, target, replacement) => {
+  const children = (nodes) => {
+    const kept = nodes.filter(
+      (node) => !(node === target && replacement === "omit")
+    );
+    return kept.map((node, i, all) => {
+      let value;
+      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();
+};
+export {
+  escapeTestName,
+  flattenNodes,
+  renderMutatedObject,
+  renderObject,
+  renderValue,
+  shapedViewNodes,
+  viewNodes
+};

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

@@ -0,0 +1,110 @@
+import {
+  DeterministicDefaultValueConverter
+} 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) => JSON.stringify(value);
+const token = (specToken, native, reverse) => ({ ...specToken, native, reverse });
+const quoted = token(spec.string.String, dq, /^"(.*)"$/);
+const exactQuoted = (value) => new RegExp(
+  `^${JSON.stringify(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`
+);
+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: "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"
+});
+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: {}
+});
+const toNative = (specType) => typeConverter.convert(specType);
+const isTsZeroExpr = (expr) => expr === "false" || expr === "0" || expr === '""';
+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 isTsZeroExpr(expr) ? void 0 : expr;
+};
+export {
+  defaultValueConverter,
+  nativeDefaultExpr,
+  toNative,
+  typeConverter
+};