@drzl/cli 4.13.0 → 4.13.1

package/dist/cli.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,282 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../generator-json-schema/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  JsonSchemaGenerator: () => JsonSchemaGenerator,
+  default: () => index_default,
+  tableSchemas: () => tableSchemas
+});
+function baseSchema(c, mode, target, checks, sets, lengths) {
+  const s = c.shape;
+  if (s) {
+    switch (s.kind) {
+      case "json":
+        return {};
+      case "custom":
+        return {};
+      case "buffer":
+        return { type: "string", contentEncoding: "base64" };
+      case "tuple":
+        return target === "openapi-3.0" ? { type: "array", items: { type: "number" }, minItems: s.length, maxItems: s.length } : {
+          type: "array",
+          prefixItems: Array.from({ length: s.length }, () => ({ type: "number" })),
+          minItems: s.length,
+          maxItems: s.length
+        };
+      case "numberVector":
+        return {
+          type: "array",
+          items: { type: "number" },
+          ...s.length ? { minItems: s.length, maxItems: s.length } : {}
+        };
+      case "bitstring":
+        return {
+          type: "string",
+          pattern: "^[01]*$",
+          ...s.length ? s.exact ? { minLength: s.length, maxLength: s.length } : { maxLength: s.length } : {}
+        };
+    }
+  }
+  const set = sets.find((x) => x.column === c.name);
+  if (set) return { enum: set.values.map((v) => set.kind === "string" ? v : Number(v)) };
+  if (c.enumValues && c.enumValues.length) return { enum: [...c.enumValues] };
+  const mine = c.arrayDimensions ? [] : checks.filter((k) => k.column === c.name);
+  const eq = mine.find((k) => k.operator === "=");
+  if (eq) return { const: eq.kind === "string" ? eq.value : Number(eq.value) };
+  switch (c.tsType) {
+    case "string": {
+      const out = { type: "string" };
+      if (c.format === "uuid") out.format = UUID_FORMAT;
+      else if (c.format && import_validation_core2.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core2.COLUMN_FORMATS[c.format];
+      if (c.maxLength !== void 0) out.maxLength = c.maxLength;
+      applyLengths(out, c, lengths);
+      return out;
+    }
+    case "number": {
+      const out = { type: (0, import_validation_core2.isIntegerColumn)(c) ? "integer" : "number" };
+      if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
+      return out;
+    }
+    case "bigint":
+      return { type: "string", pattern: "^-?\\d+$" };
+    case "boolean":
+      return { type: "boolean" };
+    case "Date":
+      return { type: "string", format: "date-time" };
+    case "Uint8Array":
+      return { type: "string", contentEncoding: "base64" };
+    default:
+      return {};
+  }
+}
+function applyLengths(out, c, lengths) {
+  for (const k of lengths.filter((x) => x.column === c.name)) {
+    const n = Number(k.value);
+    if (k.operator === ">=") out.minLength = Math.max(Number(out.minLength ?? 0), n);
+    else if (k.operator === ">") out.minLength = Math.max(Number(out.minLength ?? 0), n + 1);
+    else if (k.operator === "<=") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n);
+    else if (k.operator === "<") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n - 1);
+    else if (k.operator === "=") {
+      out.minLength = n;
+      out.maxLength = n;
+    }
+  }
+}
+function applyNumericBounds(out, c, checks, target) {
+  let min = c.min !== void 0 ? { value: Number(c.min), exclusive: false } : void 0;
+  let max = c.max !== void 0 ? { value: Number(c.max), exclusive: false } : void 0;
+  for (const k of checks.filter((x) => x.column === c.name && x.kind === "number")) {
+    if (k.operator === ">=") min = { value: Number(k.value), exclusive: false };
+    else if (k.operator === ">") min = { value: Number(k.value), exclusive: true };
+    else if (k.operator === "<=") max = { value: Number(k.value), exclusive: false };
+    else if (k.operator === "<") max = { value: Number(k.value), exclusive: true };
+  }
+  const old = target === "openapi-3.0";
+  if (min) {
+    if (min.exclusive && !old) out.exclusiveMinimum = min.value;
+    else {
+      out.minimum = min.value;
+      if (min.exclusive) out.exclusiveMinimum = true;
+    }
+  }
+  if (max) {
+    if (max.exclusive && !old) out.exclusiveMaximum = max.value;
+    else {
+      out.maximum = max.value;
+      if (max.exclusive) out.exclusiveMaximum = true;
+    }
+  }
+}
+function cardinalityBounds(c, cardinalities) {
+  if (!c.arrayDimensions) return {};
+  const out = {};
+  for (const k of cardinalities.filter((x) => x.column === c.name)) {
+    const n = Number(k.value);
+    if (k.operator === ">=") out.minItems = n;
+    else if (k.operator === ">") out.minItems = n + 1;
+    else if (k.operator === "<=") out.maxItems = n;
+    else if (k.operator === "<") out.maxItems = n - 1;
+    else if (k.operator === "=") {
+      out.minItems = n;
+      out.maxItems = n;
+    }
+  }
+  return out;
+}
+function makeNullable(s, target) {
+  if (target === "openapi-3.0") return { ...s, nullable: true };
+  if (s.type === void 0) {
+    if (Array.isArray(s.enum)) return { ...s, enum: [...s.enum, null] };
+    if ("const" in s) {
+      const { const: k, ...rest } = s;
+      return { ...rest, enum: [k, null] };
+    }
+    return s;
+  }
+  return { ...s, type: [s.type, "null"] };
+}
+function columnSchema(c, mode, target, checks, sets, lengths, cardinalities, applyDefault) {
+  let s = baseSchema(c, mode, target, checks, sets, lengths);
+  const dims = c.arrayDimensions ?? 0;
+  for (let i = 0; i < dims; i++) {
+    s = { type: "array", items: s, ...i === dims - 1 ? cardinalityBounds(c, cardinalities) : {} };
+  }
+  if (c.nullable) s = makeNullable(s, target);
+  if (mode === "insert" && applyDefault && c.defaultValue !== void 0) {
+    s = { ...s, default: c.defaultValue };
+  }
+  return s;
+}
+function rowDescription(rows, cols) {
+  const present = new Set(cols.map((c) => c.name));
+  const applicable = rows.filter((r) => present.has(r.left) && present.has(r.right));
+  if (!applicable.length) return void 0;
+  const list = applicable.map((r) => `${r.name ? `${r.name}: ` : ""}${r.left} ${r.operator} ${r.right}`).join("; ");
+  return `Row constraints not expressible in JSON Schema: ${list}`;
+}
+function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
+  const properties = {};
+  const required = [];
+  for (const c of cols) {
+    properties[c.name] = columnSchema(
+      c,
+      mode,
+      target,
+      parsed.checks,
+      parsed.sets,
+      parsed.lengths,
+      parsed.cardinalities,
+      applyDefaults
+    );
+    const supplied = c.hasDefault || mode === "insert" && applyDefaults && c.defaultValue !== void 0;
+    if (mode !== "update" && !supplied) required.push(c.name);
+  }
+  const desc = rowDescription(parsed.rows, cols);
+  return {
+    ...target === "draft-2020-12" ? { $schema: DRAFT } : {},
+    $id: `${table.tsName}.${mode}`,
+    title: `${mode} ${table.tsName}`,
+    ...desc ? { description: desc } : {},
+    type: "object",
+    properties,
+    ...required.length ? { required } : {},
+    additionalProperties: false
+  };
+}
+function collect(table) {
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core2.parseCheck)(k.expression, k.name));
+  return {
+    checks: parsed.flatMap((p) => p.ok ? p.checks : []),
+    sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
+    rows: parsed.flatMap((p) => p.ok ? p.rows ?? [] : []),
+    lengths: parsed.flatMap((p) => p.ok ? p.lengths ?? [] : []),
+    cardinalities: parsed.flatMap((p) => p.ok ? p.cardinalities ?? [] : [])
+  };
+}
+function tableSchemas(table, opts = {}) {
+  const target = opts.target ?? "draft-2020-12";
+  const parsed = collect(table);
+  const build = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
+  return {
+    insert: build((0, import_validation_core2.insertColumns)(table), "insert"),
+    update: build((0, import_validation_core2.updateColumns)(table), "update"),
+    select: build((0, import_validation_core2.selectColumns)(table), "select")
+  };
+}
+function renderTableModule(table, affix, target, applyDefaults) {
+  const T = table.tsName;
+  const schemas = tableSchemas(table, { target, applyDefaults });
+  const decl = (mode) => `export const ${(0, import_validation_core2.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+
+export type ${(0, import_validation_core2.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core2.schemaName)(mode, T, affix)};`;
+  return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
+}
+function buildHeader(h) {
+  if (h?.enabled === false) return "";
+  const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
+  return `${text}
+
+`;
+}
+var import_validation_core2, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default;
+var init_dist = __esm({
+  "../generator-json-schema/dist/index.js"() {
+    "use strict";
+    import_validation_core2 = require("@drzl/validation-core");
+    DEFAULT_FILE_SUFFIX = ".schema.ts";
+    DRAFT = "https://json-schema.org/draft/2020-12/schema";
+    UUID_FORMAT = "uuid";
+    JsonSchemaGenerator = class {
+      constructor(analysis) {
+        this.analysis = analysis;
+        this.library = "json-schema";
+      }
+      async generate(opts) {
+        const fs3 = await import("fs/promises");
+        const path5 = await import("path");
+        const out = path5.resolve(process.cwd(), opts.outDir);
+        const files = [];
+        await fs3.mkdir(out, { recursive: true });
+        const affix = (0, import_validation_core2.resolveAffix)(opts);
+        const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
+        const target = opts.target ?? "draft-2020-12";
+        for (const table of this.analysis.tables) {
+          const filePath = path5.join(out, (0, import_validation_core2.moduleFileName)(table.tsName, fileSuffix));
+          const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
+          const formatted = await (0, import_validation_core2.formatCode)(
+            buildHeader(opts.outputHeader) + code,
+            filePath,
+            opts.format
+          );
+          await fs3.writeFile(filePath, formatted, "utf8");
+          files.push(filePath);
+        }
+        const indexPath = path5.join(out, "index.ts");
+        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core2.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`).join("\n") + "\n";
+        const indexFormatted = await (0, import_validation_core2.formatCode)(
+          buildHeader(opts.outputHeader) + index,
+          indexPath,
+          opts.format
+        );
+        await fs3.writeFile(indexPath, indexFormatted, "utf8");
+        files.push(indexPath);
+        return files;
+      }
+      renderTable(table, opts) {
+        return renderTableModule(
+          table,
+          (0, import_validation_core2.resolveAffix)(opts),
+          opts?.target ?? "draft-2020-12",
+          !!opts?.applyDefaults
+        );
+      }
+    };
+    index_default = JsonSchemaGenerator;
+  }
+});
+
 // src/cli.ts
 var import_analyzer = require("@drzl/analyzer");
 var import_generator_orpc = require("@drzl/generator-orpc");
@@ -695,8 +978,8 @@ program.command("generate").description("Run configured generators (drzl.config.
         }
       } else if (g.kind === "json-schema") {
         try {
-          const { JsonSchemaGenerator } = await import("@drzl/generator-json-schema");
-          const gen = new JsonSchemaGenerator(analysis);
+          const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          const gen = new JsonSchemaGenerator2(analysis);
           const target = g.path ?? "src/validators/json-schema";
           const files = await gen.generate({
             // JSON Schema is data, so nothing here references a type from the schema module.
@@ -710,7 +993,11 @@ program.command("generate").description("Run configured generators (drzl.config.
           progress.stop();
           console.error(
             import_chalk2.default.red("JSON Schema generator missing."),
-            import_chalk2.default.yellow("\nInstall with: npm install @drzl/generator-json-schema")
+            import_chalk2.default.yellow("\nInstall with: npm install @drzl/generator-json-schema"),
+            // An optional dependency, unlike the other generators, until its npm trusted
+            // publisher exists. A missing optional dependency is skipped rather than failing
+            // the install, which is what keeps `npm i @drzl/cli` working meanwhile.
+            ""
           );
           console.error(import_chalk2.default.gray("Error details:"), e?.message ?? e);
           process.exit(1);