@drzl/validation-core 3.0.0 → 3.2.0

package/dist/index.d.cts

@@ -173,6 +173,56 @@ declare function typeName(mode: NameMode, tsName: string, affix: ResolvedAffix):
  */
 declare function validateAffix(affix?: AffixOptions, schemaSuffix?: string): AffixIssue[];
 
+/**
+ * Turning a SQL CHECK constraint into something a validator can enforce.
+ *
+ * No official Drizzle validator module does this. Verified against `drizzle-orm/zod` at
+ * 1.0.0-rc.4: a table with `check('age_adult', sql`${t.age} >= 18`)` produces an insert schema
+ * that accepts `{ age: 5 }`. The constraint is in the schema, the database will reject the row,
+ * and the validator says nothing.
+ *
+ * Only expressions whose meaning is unambiguous are translated. Everything else is reported and
+ * skipped, because a validator that quietly enforces a *guess* at your constraint is worse than
+ * one that enforces nothing: it rejects rows the database would have accepted.
+ *
+ * Two pieces of SQL semantics that a naive translation gets wrong:
+ *
+ * 1. **A CHECK passes when it evaluates to TRUE *or NULL*.** So `CHECK (age >= 18)` on a
+ *    nullable column accepts NULL. Emitting `.gte(18)` on the inner type and applying
+ *    `.nullable()` around it reproduces that exactly, which is why the constraint belongs on the
+ *    base expression rather than on the whole field.
+ * 2. **A multi-column check cannot live on a field.** `start_date < end_date` is a statement
+ *    about the row, so it is not returned here at all.
+ */
+/** A comparison of one column against one literal, which is the case worth translating. */
+interface ColumnCheck {
+    /** Column the constraint is about, as it appears in the expression. */
+    column: string;
+    operator: '>=' | '>' | '<=' | '<' | '=' | '<>';
+    /** The literal, still as text: a 64 bit bound must not pass through a JS number. */
+    value: string;
+    /** Whether the literal was quoted, which distinguishes `'5'` from `5`. */
+    kind: 'number' | 'string';
+    /** Constraint name, used to say which one failed. */
+    name?: string;
+}
+/** A check that was understood, or the reason it was not. */
+type ParsedCheck = {
+    ok: true;
+    checks: ColumnCheck[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Parse one check expression.
+ *
+ * Deliberately narrow. `BETWEEN` is included because it is common and means exactly two
+ * inclusive bounds; `AND` of arbitrary predicates is not, because getting its scope wrong would
+ * silently change what is enforced.
+ */
+declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+
 interface Table {
     name: string;
     tsName: string;
@@ -189,6 +239,31 @@ interface FormatOptions {
 }
 interface ValidationGenerateOptions {
     outDir: string;
+    /**
+     * Path to the Drizzle schema module, as written in the config.
+     *
+     * Only needed by `typedJson`, which has to import the table back in order to reference the
+     * type Drizzle inferred for a column.
+     */
+    schemaPath?: string;
+    /**
+     * Type `json` and `jsonb` columns from the schema instead of leaving them wide.
+     *
+     * `.$type<T>()` is a compile-time cast: Drizzle's implementation is literally
+     * `$type() { return this }`, so the type exists only in TypeScript and nothing about it
+     * survives to runtime. Every runtime-derived validator is therefore blind to it, and
+     * `drizzle-orm/zod` types a json column as its generic `Json` no matter what you declared.
+     *
+     * A generator can do better without resolving any types itself, because Drizzle already did
+     * the work: `typeof users.$inferSelect['prefs']` *is* the declared type, resolved by
+     * TypeScript at the point of use. So the emitted schema references that rather than trying to
+     * reconstruct it, which is why this works for generics, unions and imported interfaces alike,
+     * the cases that defeat source-parsing approaches.
+     *
+     * Off by default: it makes the generated file import your schema module, and that coupling
+     * should be a choice rather than a surprise.
+     */
+    typedJson?: boolean;
     format?: FormatOptions;
     /**
      * What every generated file is called after the Drizzle export name, e.g. `.zod.ts`
@@ -243,4 +318,4 @@ declare function updateColumns(table: Table): Column[];
 declare function selectColumns(table: Table): Column[];
 declare function formatCode(code: string, filePath: string, fmt?: FormatOptions): Promise<any>;
 
-export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, type ColumnCheck, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ParsedCheck, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.d.ts

@@ -173,6 +173,56 @@ declare function typeName(mode: NameMode, tsName: string, affix: ResolvedAffix):
  */
 declare function validateAffix(affix?: AffixOptions, schemaSuffix?: string): AffixIssue[];
 
+/**
+ * Turning a SQL CHECK constraint into something a validator can enforce.
+ *
+ * No official Drizzle validator module does this. Verified against `drizzle-orm/zod` at
+ * 1.0.0-rc.4: a table with `check('age_adult', sql`${t.age} >= 18`)` produces an insert schema
+ * that accepts `{ age: 5 }`. The constraint is in the schema, the database will reject the row,
+ * and the validator says nothing.
+ *
+ * Only expressions whose meaning is unambiguous are translated. Everything else is reported and
+ * skipped, because a validator that quietly enforces a *guess* at your constraint is worse than
+ * one that enforces nothing: it rejects rows the database would have accepted.
+ *
+ * Two pieces of SQL semantics that a naive translation gets wrong:
+ *
+ * 1. **A CHECK passes when it evaluates to TRUE *or NULL*.** So `CHECK (age >= 18)` on a
+ *    nullable column accepts NULL. Emitting `.gte(18)` on the inner type and applying
+ *    `.nullable()` around it reproduces that exactly, which is why the constraint belongs on the
+ *    base expression rather than on the whole field.
+ * 2. **A multi-column check cannot live on a field.** `start_date < end_date` is a statement
+ *    about the row, so it is not returned here at all.
+ */
+/** A comparison of one column against one literal, which is the case worth translating. */
+interface ColumnCheck {
+    /** Column the constraint is about, as it appears in the expression. */
+    column: string;
+    operator: '>=' | '>' | '<=' | '<' | '=' | '<>';
+    /** The literal, still as text: a 64 bit bound must not pass through a JS number. */
+    value: string;
+    /** Whether the literal was quoted, which distinguishes `'5'` from `5`. */
+    kind: 'number' | 'string';
+    /** Constraint name, used to say which one failed. */
+    name?: string;
+}
+/** A check that was understood, or the reason it was not. */
+type ParsedCheck = {
+    ok: true;
+    checks: ColumnCheck[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Parse one check expression.
+ *
+ * Deliberately narrow. `BETWEEN` is included because it is common and means exactly two
+ * inclusive bounds; `AND` of arbitrary predicates is not, because getting its scope wrong would
+ * silently change what is enforced.
+ */
+declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+
 interface Table {
     name: string;
     tsName: string;
@@ -189,6 +239,31 @@ interface FormatOptions {
 }
 interface ValidationGenerateOptions {
     outDir: string;
+    /**
+     * Path to the Drizzle schema module, as written in the config.
+     *
+     * Only needed by `typedJson`, which has to import the table back in order to reference the
+     * type Drizzle inferred for a column.
+     */
+    schemaPath?: string;
+    /**
+     * Type `json` and `jsonb` columns from the schema instead of leaving them wide.
+     *
+     * `.$type<T>()` is a compile-time cast: Drizzle's implementation is literally
+     * `$type() { return this }`, so the type exists only in TypeScript and nothing about it
+     * survives to runtime. Every runtime-derived validator is therefore blind to it, and
+     * `drizzle-orm/zod` types a json column as its generic `Json` no matter what you declared.
+     *
+     * A generator can do better without resolving any types itself, because Drizzle already did
+     * the work: `typeof users.$inferSelect['prefs']` *is* the declared type, resolved by
+     * TypeScript at the point of use. So the emitted schema references that rather than trying to
+     * reconstruct it, which is why this works for generics, unions and imported interfaces alike,
+     * the cases that defeat source-parsing approaches.
+     *
+     * Off by default: it makes the generated file import your schema module, and that coupling
+     * should be a choice rather than a surprise.
+     */
+    typedJson?: boolean;
     format?: FormatOptions;
     /**
      * What every generated file is called after the Drizzle export name, e.g. `.zod.ts`
@@ -243,4 +318,4 @@ declare function updateColumns(table: Table): Column[];
 declare function selectColumns(table: Table): Column[];
 declare function formatCode(code: string, filePath: string, fmt?: FormatOptions): Promise<any>;
 
-export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, type ColumnCheck, DEFAULT_IMPORT_EXTENSION, DEFAULT_MODE_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_TYPE_SUFFIX, type FormatOptions, IMPORT_EXTENSIONS, type ImportExtension, NAME_MODES, type NameMode, type ParsedCheck, type ResolvedAffix, type Table, type TableCase, type ValidationGenerateOptions, type ValidationLibrary, type ValidationRenderer, applyTableCase, formatCode, importSpecifier, insertColumns, isGeneratedColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.js

@@ -1,4 +1,42 @@
-import "./chunk-MKBO26DX.js";
+import "./chunk-ZZGILH5A.js";
+
+// src/checks.ts
+var COMPARISON = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|<>|!=|>|<|=)\s*(.+?)\s*$/;
+var BETWEEN = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+BETWEEN\s+(.+?)\s+AND\s+(.+?)\s*$/i;
+function literal(raw) {
+  const t = raw.trim();
+  if (/^-?\d+(\.\d+)?$/.test(t)) return { value: t, kind: "number" };
+  const m = t.match(/^'((?:[^']|'')*)'$/);
+  if (m) return { value: m[1].replace(/''/g, "'"), kind: "string" };
+  return void 0;
+}
+function parseCheck(expression, name) {
+  const expr = (expression ?? "").trim();
+  if (!expr) return { ok: false, reason: "empty expression" };
+  if (expr.includes("?")) return { ok: false, reason: "expression contains an unresolved value" };
+  const between = expr.match(BETWEEN);
+  if (between) {
+    const lo = literal(between[2]);
+    const hi = literal(between[3]);
+    if (!lo || !hi) return { ok: false, reason: "BETWEEN bounds are not literals" };
+    if (lo.kind !== hi.kind) return { ok: false, reason: "BETWEEN bounds are of mixed types" };
+    return {
+      ok: true,
+      checks: [
+        { column: between[1], operator: ">=", value: lo.value, kind: lo.kind, name },
+        { column: between[1], operator: "<=", value: hi.value, kind: hi.kind, name }
+      ]
+    };
+  }
+  const cmp = expr.match(COMPARISON);
+  if (!cmp) return { ok: false, reason: "not a single comparison this version understands" };
+  const value = literal(cmp[3]);
+  if (!value) {
+    return { ok: false, reason: "right side is not a literal" };
+  }
+  const op = cmp[2] === "!=" ? "<>" : cmp[2];
+  return { ok: true, checks: [{ column: cmp[1], operator: op, value: value.value, kind: value.kind, name }] };
+}
 
 // src/files.ts
 import nodeFs from "fs";
@@ -184,7 +222,7 @@ async function formatCode(code, filePath, fmt) {
   const engine = fmt?.engine ?? "auto";
   try {
     if (engine === "prettier" || engine === "auto") {
-      const prettier = await import("./prettier-Y62OQ7O7.js");
+      const prettier = await import("./prettier-LT6G5PW7.js");
       const cfgRef = fmt?.configPath ?? filePath;
       const cfg = await prettier.resolveConfig(cfgRef).catch(() => null);
       return prettier.format(code, { ...cfg ?? {}, parser: "typescript", filepath: filePath });
@@ -219,6 +257,7 @@ export {
   isGeneratedColumn,
   moduleFileName,
   moduleSpecifier,
+  parseCheck,
   pascalCase,
   resolveAffix,
   resolveConfiguredImport,