@drzl/validation-core 3.22.3 → 3.22.4

package/dist/index.cjs

@@ -153,7 +153,7 @@ function measureExpression(measure, variable) {
   }
 }
 function lengthCheckLabel(check) {
-  const fn = check.unit === "bytes" ? "octet_length" : "length";
+  const fn = check.fn ? check.fn === "char_length" ? "length" : check.fn : check.unit === "bytes" ? "octet_length" : "length";
   const rule = `${fn}(${check.column}) ${check.operator} ${check.value}`;
   return check.name ? `${check.name}: ${rule}` : rule;
 }
@@ -404,7 +404,13 @@ function foldDisjunctionToSet(branches, name) {
     sets: [{ column, values, kind, name }]
   };
 }
-function parseCheck(expression, name) {
+function lengthUnit(fn, dialect) {
+  const name = fn.toLowerCase();
+  if (name === "octet_length") return "bytes";
+  if (name === "char_length") return "characters";
+  return dialect === "mysql" ? "bytes" : "characters";
+}
+function parseCheck(expression, name, dialect) {
   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" };
@@ -481,11 +487,12 @@ function parseCheck(expression, name) {
   const lengthOf = expr.match(LENGTH_OF);
   if (lengthOf) {
     const op2 = lengthOf[3] === "!=" ? "<>" : lengthOf[3];
-    const unit = lengthOf[1].toLowerCase() === "octet_length" ? "bytes" : "characters";
+    const fn = lengthOf[1].toLowerCase();
+    const unit = lengthUnit(fn, dialect);
     return {
       ok: true,
       checks: [],
-      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, name }]
+      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, fn, name }]
     };
   }
   const cardinalityOf = expr.match(CARDINALITY_OF);
@@ -992,7 +999,7 @@ function classifyTableChecks(table) {
   const out = [];
   for (const k of table.checks ?? []) {
     const expression = (k.expression ?? "").trim();
-    const parsed = parseCheck(k.expression, k.name);
+    const parsed = parseCheck(k.expression, k.name, table.dialect);
     if (!parsed.ok) {
       out.push({
         ...k.name ? { name: k.name } : {},

package/dist/index.d.cts

@@ -452,6 +452,15 @@ interface LengthCheck {
      * a given column.
      */
     unit?: 'characters' | 'bytes';
+    /**
+     * The function as written, before the engine decided what it counts.
+     *
+     * `unit` used to imply this, because the two were the same question: `octet_length` meant bytes
+     * and everything else meant characters. On MySQL `length()` also means bytes, so deriving the
+     * name back from the unit relabelled a user's `length(name) <= 5` as `octet_length(name) <= 5`,
+     * which is a constraint they did not write. The label the ledger matches on has to be theirs.
+     */
+    fn?: 'length' | 'char_length' | 'octet_length';
     name?: string;
 }
 /**
@@ -587,21 +596,11 @@ type ParsedCheck = {
     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.
- *
- * **The order below is load bearing, in both directions.** `BETWEEN` is matched before the `AND`
- * split because it *holds* an `AND`; splitting first turned every `BETWEEN` into an unparseable
- * pair and dropped a constraint that had been enforced. The unary `IS` predicates are matched
- * *after* the splits for the mirror-image reason: none of them holds an `AND` or an `OR`, and
- * their trailing operand is greedy, so matching first would let `a IS DISTINCT FROM 5 AND b > 0`
- * swallow the second predicate. `OR` is split before `AND` because SQL binds `AND` tighter, and
- * no SQL operator spells an `OR` inside itself the way `BETWEEN` spells an `AND`.
+ * `dialect` decides what `length()` counts, and nothing else in this parser. Optional, and absent
+ * means the Postgres reading, which is what every caller got before it existed: a caller that does
+ * not know its dialect keeps the answer it already had rather than being given a new one.
  */
-declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+declare function parseCheck(expression: string | undefined, name?: string, dialect?: string): ParsedCheck;
 /**
  * A number-kind literal, spelled for the wire type of the column it constrains.
  *

package/dist/index.d.ts

@@ -452,6 +452,15 @@ interface LengthCheck {
      * a given column.
      */
     unit?: 'characters' | 'bytes';
+    /**
+     * The function as written, before the engine decided what it counts.
+     *
+     * `unit` used to imply this, because the two were the same question: `octet_length` meant bytes
+     * and everything else meant characters. On MySQL `length()` also means bytes, so deriving the
+     * name back from the unit relabelled a user's `length(name) <= 5` as `octet_length(name) <= 5`,
+     * which is a constraint they did not write. The label the ledger matches on has to be theirs.
+     */
+    fn?: 'length' | 'char_length' | 'octet_length';
     name?: string;
 }
 /**
@@ -587,21 +596,11 @@ type ParsedCheck = {
     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.
- *
- * **The order below is load bearing, in both directions.** `BETWEEN` is matched before the `AND`
- * split because it *holds* an `AND`; splitting first turned every `BETWEEN` into an unparseable
- * pair and dropped a constraint that had been enforced. The unary `IS` predicates are matched
- * *after* the splits for the mirror-image reason: none of them holds an `AND` or an `OR`, and
- * their trailing operand is greedy, so matching first would let `a IS DISTINCT FROM 5 AND b > 0`
- * swallow the second predicate. `OR` is split before `AND` because SQL binds `AND` tighter, and
- * no SQL operator spells an `OR` inside itself the way `BETWEEN` spells an `AND`.
+ * `dialect` decides what `length()` counts, and nothing else in this parser. Optional, and absent
+ * means the Postgres reading, which is what every caller got before it existed: a caller that does
+ * not know its dialect keeps the answer it already had rather than being given a new one.
  */
-declare function parseCheck(expression: string | undefined, name?: string): ParsedCheck;
+declare function parseCheck(expression: string | undefined, name?: string, dialect?: string): ParsedCheck;
 /**
  * A number-kind literal, spelled for the wire type of the column it constrains.
  *

package/dist/index.js

@@ -52,7 +52,7 @@ function measureExpression(measure, variable) {
   }
 }
 function lengthCheckLabel(check) {
-  const fn = check.unit === "bytes" ? "octet_length" : "length";
+  const fn = check.fn ? check.fn === "char_length" ? "length" : check.fn : check.unit === "bytes" ? "octet_length" : "length";
   const rule = `${fn}(${check.column}) ${check.operator} ${check.value}`;
   return check.name ? `${check.name}: ${rule}` : rule;
 }
@@ -303,7 +303,13 @@ function foldDisjunctionToSet(branches, name) {
     sets: [{ column, values, kind, name }]
   };
 }
-function parseCheck(expression, name) {
+function lengthUnit(fn, dialect) {
+  const name = fn.toLowerCase();
+  if (name === "octet_length") return "bytes";
+  if (name === "char_length") return "characters";
+  return dialect === "mysql" ? "bytes" : "characters";
+}
+function parseCheck(expression, name, dialect) {
   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" };
@@ -380,11 +386,12 @@ function parseCheck(expression, name) {
   const lengthOf = expr.match(LENGTH_OF);
   if (lengthOf) {
     const op2 = lengthOf[3] === "!=" ? "<>" : lengthOf[3];
-    const unit = lengthOf[1].toLowerCase() === "octet_length" ? "bytes" : "characters";
+    const fn = lengthOf[1].toLowerCase();
+    const unit = lengthUnit(fn, dialect);
     return {
       ok: true,
       checks: [],
-      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, name }]
+      lengths: [{ column: lengthOf[2], operator: op2, value: lengthOf[4], unit, fn, name }]
     };
   }
   const cardinalityOf = expr.match(CARDINALITY_OF);
@@ -891,7 +898,7 @@ function classifyTableChecks(table) {
   const out = [];
   for (const k of table.checks ?? []) {
     const expression = (k.expression ?? "").trim();
-    const parsed = parseCheck(k.expression, k.name);
+    const parsed = parseCheck(k.expression, k.name, table.dialect);
     if (!parsed.ok) {
       out.push({
         ...k.name ? { name: k.name } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drzl/validation-core",
-  "version": "3.22.3",
+  "version": "3.22.4",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -24,7 +24,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@drzl/analyzer": "^1.21.3"
+    "@drzl/analyzer": "^1.21.4"
   },
   "peerDependencies": {
     "prettier": ">=3"