@drzl/validation-core 2.1.0 → 3.1.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;
@@ -223,10 +273,24 @@ interface ValidationRenderer<TOptions extends ValidationGenerateOptions = Valida
     renderIndex?(analysis: Analysis, opts?: TOptions): string;
     generate(opts: TOptions): Promise<string[]>;
 }
-declare function isGeneratedColumn(c: Column, primaryKeyColumns: string[]): boolean;
+/**
+ * Whether the database generates this column's value, so it cannot be written.
+ *
+ * `primaryKeyColumns` is accepted for backwards compatibility and no longer consulted. It used
+ * to make every primary key count as generated, which dropped it from the insert schema whether
+ * or not the database supplied it. Right for a MySQL autoincrement column; wrong for a Postgres
+ * `integer('id').primaryKey()`, which Postgres does not generate, and for any natural key such
+ * as `text('slug').primaryKey()`. Those inserts became impossible to express: the required
+ * column was simply absent, with no way to provide it.
+ *
+ * Being a key says nothing about who supplies the value. `isGenerated` marks a column that
+ * cannot be written; `hasDefault` marks one that need not be, and those stay in the schema as
+ * optional.
+ */
+declare function isGeneratedColumn(c: Column, _primaryKeyColumns?: string[]): boolean;
 declare function insertColumns(table: Table): Column[];
 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;
@@ -223,10 +273,24 @@ interface ValidationRenderer<TOptions extends ValidationGenerateOptions = Valida
     renderIndex?(analysis: Analysis, opts?: TOptions): string;
     generate(opts: TOptions): Promise<string[]>;
 }
-declare function isGeneratedColumn(c: Column, primaryKeyColumns: string[]): boolean;
+/**
+ * Whether the database generates this column's value, so it cannot be written.
+ *
+ * `primaryKeyColumns` is accepted for backwards compatibility and no longer consulted. It used
+ * to make every primary key count as generated, which dropped it from the insert schema whether
+ * or not the database supplied it. Right for a MySQL autoincrement column; wrong for a Postgres
+ * `integer('id').primaryKey()`, which Postgres does not generate, and for any natural key such
+ * as `text('slug').primaryKey()`. Those inserts became impossible to express: the required
+ * column was simply absent, with no way to provide it.
+ *
+ * Being a key says nothing about who supplies the value. `isGenerated` marks a column that
+ * cannot be written; `hasDefault` marks one that need not be, and those stay in the schema as
+ * optional.
+ */
+declare function isGeneratedColumn(c: Column, _primaryKeyColumns?: string[]): boolean;
 declare function insertColumns(table: Table): Column[];
 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";
@@ -166,12 +204,11 @@ function validateAffix(affix, schemaSuffix) {
 }
 
 // src/index.ts
-function isGeneratedColumn(c, primaryKeyColumns) {
-  return c.isGenerated || primaryKeyColumns.includes(c.name);
+function isGeneratedColumn(c, _primaryKeyColumns = []) {
+  return c.isGenerated;
 }
 function insertColumns(table) {
-  const pkCols = table.primaryKey?.columns ?? [];
-  return table.columns.filter((c) => !isGeneratedColumn(c, pkCols));
+  return table.columns.filter((c) => !isGeneratedColumn(c));
 }
 function updateColumns(table) {
   const pkCols = table.primaryKey?.columns ?? [];
@@ -185,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 });
@@ -220,6 +257,7 @@ export {
   isGeneratedColumn,
   moduleFileName,
   moduleSpecifier,
+  parseCheck,
   pascalCase,
   resolveAffix,
   resolveConfiguredImport,