@drzl/validation-core 3.6.0 → 3.8.0

package/dist/index.cjs

@@ -84441,6 +84441,7 @@ ${codeblock}`, options7);
 var index_exports2 = {};
 __export(index_exports2, {
   AFFIX_PROBE_TABLE: () => AFFIX_PROBE_TABLE,
+  COLUMN_FORMATS: () => COLUMN_FORMATS,
   DEFAULT_IMPORT_EXTENSION: () => DEFAULT_IMPORT_EXTENSION,
   DEFAULT_MODE_PREFIX: () => DEFAULT_MODE_PREFIX,
   DEFAULT_SCHEMA_SUFFIX: () => DEFAULT_SCHEMA_SUFFIX,
@@ -84448,6 +84449,7 @@ __export(index_exports2, {
   IMPORT_EXTENSIONS: () => IMPORT_EXTENSIONS,
   NAME_MODES: () => NAME_MODES,
   applyTableCase: () => applyTableCase,
+  describeSet: () => describeSet,
   formatCode: () => formatCode,
   importSpecifier: () => importSpecifier,
   insertColumns: () => insertColumns,
@@ -84469,6 +84471,94 @@ module.exports = __toCommonJS(index_exports2);
 
 // src/checks.ts
 var COMPARISON = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|<>|!=|>|<|=)\s*(.+?)\s*$/;
+var IN_LIST = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.+)\)\s*$/i;
+function splitTopLevelAnd(expr) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < expr.length; i++) {
+    const c5 = expr[i];
+    if (inString) {
+      if (c5 === "'") {
+        if (expr[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c5 === "'") {
+      inString = true;
+      continue;
+    }
+    if (c5 === "(") depth++;
+    else if (c5 === ")") depth--;
+    else if (depth === 0 && /\s/.test(c5)) {
+      const m7 = /^\s+AND\s+/i.exec(expr.slice(i));
+      if (m7) {
+        parts.push(expr.slice(start, i));
+        i += m7[0].length - 1;
+        start = i + 1;
+      }
+    }
+  }
+  parts.push(expr.slice(start));
+  return parts;
+}
+function unwrap(expr) {
+  let e7 = expr.trim();
+  while (e7.startsWith("(") && e7.endsWith(")")) {
+    let depth = 0;
+    let inString = false;
+    let wrapsWhole = true;
+    for (let i = 0; i < e7.length; i++) {
+      const c5 = e7[i];
+      if (inString) {
+        if (c5 === "'") {
+          if (e7[i + 1] === "'") i++;
+          else inString = false;
+        }
+        continue;
+      }
+      if (c5 === "'") inString = true;
+      else if (c5 === "(") depth++;
+      else if (c5 === ")") {
+        depth--;
+        if (depth === 0 && i < e7.length - 1) {
+          wrapsWhole = false;
+          break;
+        }
+      }
+    }
+    if (!wrapsWhole) break;
+    e7 = e7.slice(1, -1).trim();
+  }
+  return e7;
+}
+function splitTopLevelCommas(list) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < list.length; i++) {
+    const c5 = list[i];
+    if (inString) {
+      if (c5 === "'") {
+        if (list[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c5 === "'") inString = true;
+    else if (c5 === "(") depth++;
+    else if (c5 === ")") depth--;
+    else if (c5 === "," && depth === 0) {
+      parts.push(list.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(list.slice(start));
+  return parts;
+}
 var BETWEEN = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+BETWEEN\s+(.+?)\s+AND\s+(.+?)\s*$/i;
 function literal(raw) {
   const t36 = raw.trim();
@@ -84478,9 +84568,11 @@ function literal(raw) {
   return void 0;
 }
 function parseCheck(expression, name) {
-  const expr = (expression ?? "").trim();
+  const expr = unwrap((expression ?? "").trim());
   if (!expr) return { ok: false, reason: "empty expression" };
   if (expr.includes("?")) return { ok: false, reason: "expression contains an unresolved value" };
+  if (/(^|[\s)])OR($|[\s(])/i.test(expr)) return { ok: false, reason: "contains OR" };
+  if (/(^|[\s(])NOT($|[\s(])/i.test(expr)) return { ok: false, reason: "contains NOT" };
   const between = expr.match(BETWEEN);
   if (between) {
     const lo6 = literal(between[2]);
@@ -84495,6 +84587,40 @@ function parseCheck(expression, name) {
       ]
     };
   }
+  const parts = splitTopLevelAnd(expr);
+  if (parts.length > 1) {
+    const checks = [];
+    const sets = [];
+    for (const part of parts) {
+      const parsed = parseCheck(part, name);
+      if (!parsed.ok)
+        return { ok: false, reason: `part of an AND was not understood: ${parsed.reason}` };
+      checks.push(...parsed.checks);
+      if (parsed.sets) sets.push(...parsed.sets);
+    }
+    return sets.length ? { ok: true, checks, sets } : { ok: true, checks };
+  }
+  const inList = expr.match(IN_LIST);
+  if (inList) {
+    const raw = splitTopLevelCommas(inList[2]);
+    const parsedValues = raw.map((r5) => literal(r5));
+    if (parsedValues.some((v5) => !v5)) return { ok: false, reason: "IN list holds a non-literal" };
+    const kinds = new Set(parsedValues.map((v5) => v5.kind));
+    if (kinds.size > 1) return { ok: false, reason: "IN list mixes types" };
+    if (!parsedValues.length) return { ok: false, reason: "IN list is empty" };
+    return {
+      ok: true,
+      checks: [],
+      sets: [
+        {
+          column: inList[1],
+          values: parsedValues.map((v5) => v5.value),
+          kind: parsedValues[0].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]);
@@ -84502,7 +84628,14 @@ function parseCheck(expression, name) {
     return { ok: false, reason: "right side is not a literal" };
   }
   const op3 = cmp[2] === "!=" ? "<>" : cmp[2];
-  return { ok: true, checks: [{ column: cmp[1], operator: op3, value: value.value, kind: value.kind, name }] };
+  return {
+    ok: true,
+    checks: [{ column: cmp[1], operator: op3, value: value.value, kind: value.kind, name }]
+  };
+}
+function describeSet(set) {
+  const shown = set.values.map((v5) => set.kind === "string" ? `'${v5}'` : v5).join(", ");
+  return `${set.name ? `${set.name}: ` : ""}${set.column} IN (${shown})`;
 }
 
 // src/files.ts
@@ -84674,6 +84807,12 @@ function validateAffix(affix, schemaSuffix) {
 function isGeneratedColumn(c5, _primaryKeyColumns = []) {
   return c5.isGenerated;
 }
+var COLUMN_FORMATS = {
+  // Sign, decimals, exponents, NaN/Infinity, surrounding whitespace, and the underscore digit
+  // separators and 0x/0o/0b integer literals Postgres 16 added. Agrees with Postgres on all 43
+  // probes, `1_000` and `0xDEAD_beef` through to `1__0`, `_1`, `0x` and `1e+`.
+  numeric: "^\\s*([+-]?(0[xX][0-9a-fA-F](_?[0-9a-fA-F])*|0[oO][0-7](_?[0-7])*|0[bB][01](_?[01])*)|[+-]?(\\d(_?\\d)*(\\.(\\d(_?\\d)*)?)?|\\.\\d(_?\\d)*)([eE][+-]?\\d(_?\\d)*)?|[+-]?(NaN|Infinity))\\s*$"
+};
 function isIntegerColumn(c5) {
   if (typeof c5.integer === "boolean") return c5.integer;
   return c5.dbType === "INTEGER" || c5.min !== void 0 && c5.max !== void 0;
@@ -84716,6 +84855,7 @@ async function formatCode(code, filePath, fmt) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AFFIX_PROBE_TABLE,
+  COLUMN_FORMATS,
   DEFAULT_IMPORT_EXTENSION,
   DEFAULT_MODE_PREFIX,
   DEFAULT_SCHEMA_SUFFIX,
@@ -84723,6 +84863,7 @@ async function formatCode(code, filePath, fmt) {
   IMPORT_EXTENSIONS,
   NAME_MODES,
   applyTableCase,
+  describeSet,
   formatCode,
   importSpecifier,
   insertColumns,

package/dist/index.d.cts

@@ -206,10 +206,23 @@ interface ColumnCheck {
     /** Constraint name, used to say which one failed. */
     name?: string;
 }
+/**
+ * A column constrained to a set of literals, from `col IN ('a', 'b')`.
+ *
+ * Kept separate from `ColumnCheck` rather than folded into it as another operator, so the
+ * existing shape is unchanged for anything already consuming it.
+ */
+interface ColumnSet {
+    column: string;
+    values: string[];
+    kind: 'number' | 'string';
+    name?: string;
+}
 /** A check that was understood, or the reason it was not. */
 type ParsedCheck = {
     ok: true;
     checks: ColumnCheck[];
+    sets?: ColumnSet[];
 } | {
     ok: false;
     reason: string;
@@ -222,6 +235,13 @@ type ParsedCheck = {
  * silently change what is enforced.
  */
 declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+/**
+ * A human-readable rendering of a set constraint, for an error message.
+ *
+ * Values are re-quoted the way SQL wrote them, so the message reads like the constraint in the
+ * schema rather than like its JavaScript translation.
+ */
+declare function describeSet(set: ColumnSet): string;
 
 interface Table {
     name: string;
@@ -338,10 +358,29 @@ declare function isGeneratedColumn(c: Column, _primaryKeyColumns?: string[]): bo
  * was true only while integers were the sole bounded type, so it is kept strictly for an
  * analysis produced before `Column.integer` existed, and never consulted when the flag is set.
  */
+/**
+ * Patterns for string columns whose contents the database constrains.
+ *
+ * Every entry was validated against Postgres through PGlite rather than reasoned about: the
+ * pattern and the database agree on a pool built to include the awkward *valid* forms, because
+ * the real hazard is over-rejection. A check that turns away something Postgres accepts breaks
+ * working code, which is worse than the bare `string` it replaces.
+ *
+ * That is why there is exactly one entry. Candidates for `date`, `timestamp`, `time`, `interval`,
+ * `inet`, `cidr` and `macaddr` were all built and all rejected, each by a value Postgres accepts
+ * and the pattern did not:
+ *
+ *   date      `today`, `January 8, 1999`, `20200101`, `01/02/2020`, `infinity`
+ *   time      `allballs`, `12:00:00+02`
+ *   macaddr   `2020-01-01`, which Postgres pads into `20:20:00:01:00:01`
+ *   inet      `10.1/16`, `::ffff:1.2.3.4`
+ *   cidr      parses as `inet` and then demands zero host bits, which no regex can state
+ */
+declare const COLUMN_FORMATS: Record<string, string>;
 declare function isIntegerColumn(c: Column): 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, 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, isIntegerColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, COLUMN_FORMATS, type ColumnCheck, type ColumnSet, 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, describeSet, formatCode, importSpecifier, insertColumns, isGeneratedColumn, isIntegerColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.d.ts

@@ -206,10 +206,23 @@ interface ColumnCheck {
     /** Constraint name, used to say which one failed. */
     name?: string;
 }
+/**
+ * A column constrained to a set of literals, from `col IN ('a', 'b')`.
+ *
+ * Kept separate from `ColumnCheck` rather than folded into it as another operator, so the
+ * existing shape is unchanged for anything already consuming it.
+ */
+interface ColumnSet {
+    column: string;
+    values: string[];
+    kind: 'number' | 'string';
+    name?: string;
+}
 /** A check that was understood, or the reason it was not. */
 type ParsedCheck = {
     ok: true;
     checks: ColumnCheck[];
+    sets?: ColumnSet[];
 } | {
     ok: false;
     reason: string;
@@ -222,6 +235,13 @@ type ParsedCheck = {
  * silently change what is enforced.
  */
 declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+/**
+ * A human-readable rendering of a set constraint, for an error message.
+ *
+ * Values are re-quoted the way SQL wrote them, so the message reads like the constraint in the
+ * schema rather than like its JavaScript translation.
+ */
+declare function describeSet(set: ColumnSet): string;
 
 interface Table {
     name: string;
@@ -338,10 +358,29 @@ declare function isGeneratedColumn(c: Column, _primaryKeyColumns?: string[]): bo
  * was true only while integers were the sole bounded type, so it is kept strictly for an
  * analysis produced before `Column.integer` existed, and never consulted when the flag is set.
  */
+/**
+ * Patterns for string columns whose contents the database constrains.
+ *
+ * Every entry was validated against Postgres through PGlite rather than reasoned about: the
+ * pattern and the database agree on a pool built to include the awkward *valid* forms, because
+ * the real hazard is over-rejection. A check that turns away something Postgres accepts breaks
+ * working code, which is worse than the bare `string` it replaces.
+ *
+ * That is why there is exactly one entry. Candidates for `date`, `timestamp`, `time`, `interval`,
+ * `inet`, `cidr` and `macaddr` were all built and all rejected, each by a value Postgres accepts
+ * and the pattern did not:
+ *
+ *   date      `today`, `January 8, 1999`, `20200101`, `01/02/2020`, `infinity`
+ *   time      `allballs`, `12:00:00+02`
+ *   macaddr   `2020-01-01`, which Postgres pads into `20:20:00:01:00:01`
+ *   inet      `10.1/16`, `::ffff:1.2.3.4`
+ *   cidr      parses as `inet` and then demands zero host bits, which no regex can state
+ */
+declare const COLUMN_FORMATS: Record<string, string>;
 declare function isIntegerColumn(c: Column): 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, 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, isIntegerColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };
+export { AFFIX_PROBE_TABLE, type AffixIssue, type AffixOptions, type AffixValue, COLUMN_FORMATS, type ColumnCheck, type ColumnSet, 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, describeSet, formatCode, importSpecifier, insertColumns, isGeneratedColumn, isIntegerColumn, moduleFileName, moduleSpecifier, parseCheck, pascalCase, resolveAffix, resolveConfiguredImport, schemaName, selectColumns, typeName, updateColumns, validateAffix };

package/dist/index.js

@@ -2,6 +2,94 @@ import "./chunk-ZZGILH5A.js";
 
 // src/checks.ts
 var COMPARISON = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|<>|!=|>|<|=)\s*(.+?)\s*$/;
+var IN_LIST = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s+IN\s*\((.+)\)\s*$/i;
+function splitTopLevelAnd(expr) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < expr.length; i++) {
+    const c = expr[i];
+    if (inString) {
+      if (c === "'") {
+        if (expr[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") {
+      inString = true;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (depth === 0 && /\s/.test(c)) {
+      const m = /^\s+AND\s+/i.exec(expr.slice(i));
+      if (m) {
+        parts.push(expr.slice(start, i));
+        i += m[0].length - 1;
+        start = i + 1;
+      }
+    }
+  }
+  parts.push(expr.slice(start));
+  return parts;
+}
+function unwrap(expr) {
+  let e = expr.trim();
+  while (e.startsWith("(") && e.endsWith(")")) {
+    let depth = 0;
+    let inString = false;
+    let wrapsWhole = true;
+    for (let i = 0; i < e.length; i++) {
+      const c = e[i];
+      if (inString) {
+        if (c === "'") {
+          if (e[i + 1] === "'") i++;
+          else inString = false;
+        }
+        continue;
+      }
+      if (c === "'") inString = true;
+      else if (c === "(") depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0 && i < e.length - 1) {
+          wrapsWhole = false;
+          break;
+        }
+      }
+    }
+    if (!wrapsWhole) break;
+    e = e.slice(1, -1).trim();
+  }
+  return e;
+}
+function splitTopLevelCommas(list) {
+  const parts = [];
+  let depth = 0;
+  let inString = false;
+  let start = 0;
+  for (let i = 0; i < list.length; i++) {
+    const c = list[i];
+    if (inString) {
+      if (c === "'") {
+        if (list[i + 1] === "'") i++;
+        else inString = false;
+      }
+      continue;
+    }
+    if (c === "'") inString = true;
+    else if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (c === "," && depth === 0) {
+      parts.push(list.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(list.slice(start));
+  return parts;
+}
 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();
@@ -11,9 +99,11 @@ function literal(raw) {
   return void 0;
 }
 function parseCheck(expression, name) {
-  const expr = (expression ?? "").trim();
+  const expr = unwrap((expression ?? "").trim());
   if (!expr) return { ok: false, reason: "empty expression" };
   if (expr.includes("?")) return { ok: false, reason: "expression contains an unresolved value" };
+  if (/(^|[\s)])OR($|[\s(])/i.test(expr)) return { ok: false, reason: "contains OR" };
+  if (/(^|[\s(])NOT($|[\s(])/i.test(expr)) return { ok: false, reason: "contains NOT" };
   const between = expr.match(BETWEEN);
   if (between) {
     const lo = literal(between[2]);
@@ -28,6 +118,40 @@ function parseCheck(expression, name) {
       ]
     };
   }
+  const parts = splitTopLevelAnd(expr);
+  if (parts.length > 1) {
+    const checks = [];
+    const sets = [];
+    for (const part of parts) {
+      const parsed = parseCheck(part, name);
+      if (!parsed.ok)
+        return { ok: false, reason: `part of an AND was not understood: ${parsed.reason}` };
+      checks.push(...parsed.checks);
+      if (parsed.sets) sets.push(...parsed.sets);
+    }
+    return sets.length ? { ok: true, checks, sets } : { ok: true, checks };
+  }
+  const inList = expr.match(IN_LIST);
+  if (inList) {
+    const raw = splitTopLevelCommas(inList[2]);
+    const parsedValues = raw.map((r) => literal(r));
+    if (parsedValues.some((v) => !v)) return { ok: false, reason: "IN list holds a non-literal" };
+    const kinds = new Set(parsedValues.map((v) => v.kind));
+    if (kinds.size > 1) return { ok: false, reason: "IN list mixes types" };
+    if (!parsedValues.length) return { ok: false, reason: "IN list is empty" };
+    return {
+      ok: true,
+      checks: [],
+      sets: [
+        {
+          column: inList[1],
+          values: parsedValues.map((v) => v.value),
+          kind: parsedValues[0].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]);
@@ -35,7 +159,14 @@ function parseCheck(expression, name) {
     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 }] };
+  return {
+    ok: true,
+    checks: [{ column: cmp[1], operator: op, value: value.value, kind: value.kind, name }]
+  };
+}
+function describeSet(set) {
+  const shown = set.values.map((v) => set.kind === "string" ? `'${v}'` : v).join(", ");
+  return `${set.name ? `${set.name}: ` : ""}${set.column} IN (${shown})`;
 }
 
 // src/files.ts
@@ -207,6 +338,12 @@ function validateAffix(affix, schemaSuffix) {
 function isGeneratedColumn(c, _primaryKeyColumns = []) {
   return c.isGenerated;
 }
+var COLUMN_FORMATS = {
+  // Sign, decimals, exponents, NaN/Infinity, surrounding whitespace, and the underscore digit
+  // separators and 0x/0o/0b integer literals Postgres 16 added. Agrees with Postgres on all 43
+  // probes, `1_000` and `0xDEAD_beef` through to `1__0`, `_1`, `0x` and `1e+`.
+  numeric: "^\\s*([+-]?(0[xX][0-9a-fA-F](_?[0-9a-fA-F])*|0[oO][0-7](_?[0-7])*|0[bB][01](_?[01])*)|[+-]?(\\d(_?\\d)*(\\.(\\d(_?\\d)*)?)?|\\.\\d(_?\\d)*)([eE][+-]?\\d(_?\\d)*)?|[+-]?(NaN|Infinity))\\s*$"
+};
 function isIntegerColumn(c) {
   if (typeof c.integer === "boolean") return c.integer;
   return c.dbType === "INTEGER" || c.min !== void 0 && c.max !== void 0;
@@ -248,6 +385,7 @@ async function formatCode(code, filePath, fmt) {
 }
 export {
   AFFIX_PROBE_TABLE,
+  COLUMN_FORMATS,
   DEFAULT_IMPORT_EXTENSION,
   DEFAULT_MODE_PREFIX,
   DEFAULT_SCHEMA_SUFFIX,
@@ -255,6 +393,7 @@ export {
   IMPORT_EXTENSIONS,
   NAME_MODES,
   applyTableCase,
+  describeSet,
   formatCode,
   importSpecifier,
   insertColumns,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/validation-core",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -11,7 +11,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@drzl/analyzer": "^1.8.0"
+    "@drzl/analyzer": "^1.9.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",