bank20baht-validator 0.4.1 → 0.4.3

package/dist/index.js

@@ -13,7 +13,7 @@
 // every value must have the shape the UI control could actually emit before
 // the authored validators run.
 // ---------------------------------------------------------------------------
-import { applyFlags, approvalFields, createScriptContext, defaultValue, evaluate, hasScripts, runScripts, getCatalog, normalizeTagsValue, parseDisabledEntry, parseIsoDate, parseIsoDateTime, resolveViewFields, setCatalog, setLocale, t, validateField, walkPath, normalizeLegacySchema, } from 'bank20baht-ui/engine';
+import { applyFlags, approvalFields, conditionRowRefs, createScriptContext, defaultValue, evaluate, hasScripts, runScripts, getCatalog, normalizeTagsValue, parseDisabledEntry, parseIsoDate, parseIsoDateTime, parseRowRef, resolveViewFields, setCatalog, setLocale, t, isUnsafePattern, validateField, walkPath, normalizeLegacySchema, } from 'bank20baht-ui/engine';
 /**
  * Run `fn` with the catalog switched to `locale`, restoring the previous
  * catalog after. The engine catalog is module-global; validation is fully
@@ -418,10 +418,24 @@ function workflowFieldIssues(form, field, derived, registry) {
     formData[field.key] = normalizeCanonicalValue(field, formData[field.key]);
     const required = state ? state.required : !!field.required;
     const descriptor = required === !!field.required ? field : { ...field, required };
-    return validateField(descriptor, formData[field.key], registry, formData).map((err) => ({
-        ref,
-        message: err.message,
-    }));
+    const rowStates = field.type === 'repeater' ? rowStatesOf(form, field, derived) : undefined;
+    return validateField(descriptor, formData[field.key], registry, formData, rowStates).map((err) => ({ ref: issueRef(form, field, err.key), message: err.message }));
+}
+/** A repeater's row errors keep their `key[i].sub` ref (spec 01 §10); the rest sit on the field. */
+function issueRef(form, field, errKey) {
+    return errKey.startsWith(`${field.key}[`)
+        ? `${form.form_name}.${errKey}`
+        : `${form.form_name}.${field.key}`;
+}
+/** The rule-derived states of one repeater's row sub-fields, keyed `key[i].sub` (spec 02 §2a). */
+function rowStatesOf(form, field, derived) {
+    const prefix = `${form.form_name}.${field.key}[`;
+    const states = {};
+    for (const [ref, state] of Object.entries(derived.fields)) {
+        if (ref.startsWith(prefix))
+            states[ref.slice(form.form_name.length + 1)] = state;
+    }
+    return states;
 }
 function formFieldIssues(form, derived, registry) {
     const issues = [];
@@ -600,7 +614,7 @@ function assertTransitions(wf, nameSet, refs) {
         if (tr.to !== 'end' && !nameSet.has(tr.to)) {
             throw new Error(`transition to unknown form ${JSON.stringify(tr.to)}`);
         }
-        assertValidCondition(tr.when, refs, `transition ${tr.from} -> ${tr.to}`);
+        assertValidCondition(tr.when, refs, `transition ${tr.from} -> ${tr.to}`, false);
     }
 }
 function assertValidWorkflow(parsed) {
@@ -626,10 +640,20 @@ function fieldRefs(wf) {
             if (field.type === 'label')
                 continue;
             refs.add(`${form.form_name}.${field.key}`);
+            for (const ref of rowRefsOf(form.form_name, field))
+                refs.add(ref);
         }
     }
     return refs;
 }
+/** `Form.repeater[].sub`: the same-row references rules may use (spec 02 §2a). */
+function rowRefsOf(form_name, field) {
+    if (field.type !== 'repeater')
+        return [];
+    return (field.fields ?? [])
+        .filter((sub) => sub.type !== 'label' && sub.type !== 'section' && sub.type !== 'repeater')
+        .map((sub) => `${form_name}.${field.key}[].${sub.key}`);
+}
 function assertSubFields(field, form_name) {
     if (field.fields === undefined)
         return;
@@ -660,25 +684,6 @@ function assertValidFields(form) {
         assertSubFields(field, form.form_name);
     }
 }
-/**
- * True for the textbook ReDoS shape: an unbounded quantifier (`* + {n,}`)
- * applied to a group whose ENTIRE body is one unboundedly-quantified atom —
- * `(a+)+`, `(\d*)*`, `(?:\w+){2,}`. That exact nesting is always either
- * redundant (matches the same language as a single quantifier) or exponential
- * to backtrack, so rejecting it has no legitimate false positives. It is
- * deliberately NARROW: longer bodies like `(abc+)+` are safe (the literal
- * prefix removes the cross-iteration ambiguity) and other catastrophic shapes
- * (e.g. overlapping alternation `(a|a)*`) are out of scope — patterns are
- * builder-authored, so the goal is catching the classic authoring mistake at
- * save time, not sandboxing hostile regexes.
- */
-function hasNestedUnboundedQuantifier(pattern) {
-    // Strip escaped chars and character classes first so `\+`, `[+]` etc.
-    // aren't mistaken for quantifiers or group delimiters.
-    const stripped = pattern.replace(/\\./g, 'x').replace(/\[[^\]]*\]/g, 'C');
-    const unbounded = '(?:[*+]|\\{\\d+,\\})';
-    return new RegExp(`\\((?:\\?:)?[^()|]${unbounded}\\??\\)${unbounded}`).test(stripped);
-}
 function assertFieldKey(field, form_name) {
     // labels are static blocks and may omit the key; everything else needs one
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard: value is untrusted JSON
@@ -701,7 +706,7 @@ function assertPatternValidator(v, where) {
     catch {
         throw new Error(`invalid pattern ${JSON.stringify(v.value)} on ${where}`);
     }
-    if (hasNestedUnboundedQuantifier(pattern)) {
+    if (isUnsafePattern(pattern)) {
         throw new Error(`pattern on ${where} nests unbounded quantifiers ` +
             `(e.g. "(a+)+") — this backtracks catastrophically on hostile input; ` +
             `an equivalent single quantifier matches the same strings`);
@@ -783,6 +788,9 @@ function assertRuleAction(rawAction, where, formNames, refs) {
         }
     }
     if (rawAction.action === 'setValue') {
+        if (parseRowRef(`${target.form}.${String(target.field)}`)) {
+            throw new Error(`${where}: setValue cannot target a repeater row field`);
+        }
         assertValidExpr(rawAction.value, refs, where);
     }
 }
@@ -804,13 +812,38 @@ function assertRule(raw, i, formNames, refs) {
         for (const rawAction of actions)
             assertRuleAction(rawAction, where, formNames, refs);
     }
+    assertSingleRowScope(rule, where);
+}
+/** A row-scoped rule is evaluated per row of ONE repeater (spec 02 §2a). */
+function assertSingleRowScope(rule, where) {
+    const scoped = new Set(conditionRowRefs(rule.when).map((r) => `${r.form}.${r.repeater}`));
+    for (const branch of [rule.then, rule.else]) {
+        for (const action of Array.isArray(branch) ? branch : []) {
+            const row = actionRowRef(action);
+            if (row)
+                scoped.add(`${row.form}.${row.repeater}`);
+        }
+    }
+    if (scoped.size > 1)
+        throw new Error(`${where}: a rule may be row-scoped to one repeater only`);
+}
+/** The row-scoped ref an action targets, if any. */
+function actionRowRef(action) {
+    const target = isRecord(action) && isRecord(action.target) ? action.target : undefined;
+    if (!target || typeof target.field !== 'string')
+        return null;
+    return parseRowRef(`${String(target.form)}.${target.field}`);
 }
 function assertValidRules(wf, formNames, refs) {
     wf.rules.forEach((raw, i) => {
         assertRule(raw, i, formNames, refs);
     });
 }
-function assertValidCondition(cond, refs, where) {
+/**
+ * `allowRow`: a row-scoped ref (`Form.repeater[].sub`) only means something in
+ * a rule's `when` (spec 02 §2a) — transitions and value expressions have no row.
+ */
+function assertValidCondition(cond, refs, where, allowRow = true) {
     if (cond === undefined)
         return; // omitted = always true
     if (!isRecord(cond))
@@ -820,28 +853,30 @@ function assertValidCondition(cond, refs, where) {
         if (!Array.isArray(list))
             throw new Error(`invalid condition in ${where}`);
         for (const c of list)
-            assertValidCondition(c, refs, where);
+            assertValidCondition(c, refs, where, allowRow);
         return;
     }
     if ('not' in cond) {
-        assertValidCondition(cond.not, refs, where);
+        assertValidCondition(cond.not, refs, where, allowRow);
         return;
     }
-    if (typeof cond.field !== 'string' || !refs.has(cond.field)) {
-        throw new Error(`${where} references unknown field ${JSON.stringify(cond.field)}`);
+    assertKnownRef(cond.field, refs, where, allowRow);
+    if (cond.value_field !== undefined)
+        assertKnownRef(cond.value_field, refs, where, allowRow);
+}
+function assertKnownRef(ref, refs, where, allowRow) {
+    if (typeof ref !== 'string' || !refs.has(ref)) {
+        throw new Error(`${where} references unknown field ${JSON.stringify(ref)}`);
     }
-    const value_field = cond.value_field;
-    if (value_field !== undefined && (typeof value_field !== 'string' || !refs.has(value_field))) {
-        throw new Error(`${where} references unknown field ${JSON.stringify(value_field)}`);
+    if (!allowRow && parseRowRef(ref)) {
+        throw new Error(`${where}: a row-scoped ref is only valid in a rule condition`);
     }
 }
 function assertValidExpr(expr, refs, where) {
     if (!isRecord(expr))
         throw new Error(`${where}: invalid value expression`);
     if ('ref' in expr) {
-        if (typeof expr.ref !== 'string' || !refs.has(expr.ref)) {
-            throw new Error(`${where} references unknown field ${JSON.stringify(expr.ref)}`);
-        }
+        assertKnownRef(expr.ref, refs, where, false);
         return;
     }
     if ('const' in expr)
@@ -859,7 +894,7 @@ function assertValidExpr(expr, refs, where) {
         if (!Array.isArray(triple) || triple.length !== 3) {
             throw new Error(`${where}: if expression needs [condition, then, else]`);
         }
-        assertValidCondition(triple[0], refs, where);
+        assertValidCondition(triple[0], refs, where, false);
         assertValidExpr(triple[1], refs, where);
         assertValidExpr(triple[2], refs, where);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-validator",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "description": "Runtime validation for bahtui form/workflow JSON \u2014 the exact engine rules the client runs, on the server.",
   "license": "MIT",
@@ -46,7 +46,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "bank20baht-ui": ">=0.11.0 <0.13.0"
+    "bank20baht-ui": ">=0.12.2 <0.13.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",