bank20baht-validator 0.3.6 → 0.4.0

package/README.md

@@ -46,7 +46,7 @@ POST /api/submissions {"id":"todo-form","data":{"title":"ab"}}
 
 ## Compatibility
 
-Peers on `bank20baht-ui` **>=0.5 <0.9** (the engine and the `FieldType` union come from there). In a workspace that also builds `bank20baht-ui`, keep the peer range in
+Peers on `bank20baht-ui` **>=0.11 <0.12** (the engine and the `FieldType` union come from there; see `peerDependencies`). In a workspace that also builds `bank20baht-ui`, keep the peer range in
 step with the core version or the validator's `tsc` build resolves a stale copy from npm.
 
 ## What it enforces

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, parseDisabledEntry, parseIsoDate, parseIsoDateTime, resolveViewFields, setCatalog, setLocale, t, validateField, walkPath, normalizeLegacySchema, } from 'bank20baht-ui/engine';
+import { applyFlags, approvalFields, createScriptContext, defaultValue, evaluate, hasScripts, runScripts, getCatalog, normalizeTagsValue, parseDisabledEntry, parseIsoDate, parseIsoDateTime, resolveViewFields, setCatalog, setLocale, t, 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
@@ -51,6 +51,7 @@ const FIELD_TYPES = new Set([
     'file',
     'label',
     'repeater',
+    'tags',
 ]);
 export function isWorkflowDefinition(schema) {
     return (isRecord(schema) &&
@@ -108,6 +109,24 @@ function multiChoiceIssue(value, optionKeys) {
         return t('pattern');
     return shapeMessage(!optionKeys || value.every((v) => optionKeys.includes(v)));
 }
+/**
+ * tags: an array of strings — free text, unlike dropdown/multiselect. Only
+ * `allow_new: false` restricts chips to the static `options` list, matched
+ * case-insensitively against the (already-trimmed) tag; `options_from` is
+ * skipped exactly like a dropdown's dynamic options (`optionKeys === null`
+ * here too — the server cannot resolve it, so it trusts the client that did).
+ */
+function tagsShapeIssue(field, value, optionKeys) {
+    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string'))
+        return t('pattern');
+    if (field.allow_new === false && optionKeys) {
+        const allowed = new Set(optionKeys.map((k) => k.toLowerCase()));
+        // judged on the canonical value: a blank entry is dropped, not "not allowed"
+        const bad = normalizeTagsValue(value).some((v) => !allowed.has(v.toLowerCase()));
+        return shapeMessage(!bad);
+    }
+    return null;
+}
 function fileIssue(field, value) {
     if (field.multiple)
         return shapeMessage(Array.isArray(value) && value.every(isRecord));
@@ -137,6 +156,8 @@ function typeIssue(field, value) {
             return choiceIssue(value, optionKeys);
         case 'multiselect':
             return multiChoiceIssue(value, optionKeys);
+        case 'tags':
+            return tagsShapeIssue(field, value, optionKeys);
         case 'file':
             return fileIssue(field, value);
         case 'repeater':
@@ -181,6 +202,85 @@ function shapeIssues(field, value, ref) {
 export function validateFormData(form, input, registry, locale) {
     return withLocale(locale, () => formDataResult(form, input, registry));
 }
+/**
+ * A tags value as the client emits it: trimmed, case-insensitive deduped
+ * (first spelling kept, a static option's key spelling when it matches one),
+ * `[]` for missing. A wrong-shaped value passes
+ * through untouched — `shapeIssues` owns rejecting it (and it runs AFTER
+ * rule evaluation, which also reads this).
+ */
+function canonicalTags(field, v) {
+    if (v === null || v === undefined)
+        return [];
+    if (!Array.isArray(v) || v.some((x) => typeof x !== 'string'))
+        return v;
+    // static options only: options_from can't be resolved here, so its
+    // suggestions keep the spelling the client sent (the client already mapped them)
+    return normalizeTagsValue(v, field.options_from ? undefined : field.options);
+}
+/**
+ * Canonical value for one field: `tags` via `canonicalTags` (the same
+ * transform `validateField` applies internally when checking it, applied
+ * here too so the persisted `data` matches byte-for-byte); `repeater`
+ * recurses one row deep to normalise any `tags` COLUMN the same way (a
+ * repeater never nests, spec 01 §10). Every other type passes through.
+ * Only own keys are ever assigned, so a `__proto__` key stays a plain
+ * data property.
+ */
+function normalizeCanonicalValue(field, raw) {
+    if (field.type === 'tags')
+        return canonicalTags(field, raw);
+    if (field.type !== 'repeater' || !Array.isArray(raw))
+        return raw;
+    return raw.map((row) => {
+        if (!isRecord(row))
+            return row;
+        const next = { ...row };
+        for (const sub of field.fields ?? []) {
+            if (sub.type === 'tags' && Object.hasOwn(next, sub.key)) {
+                next[sub.key] = canonicalTags(sub, next[sub.key]);
+            }
+        }
+        return next;
+    });
+}
+/**
+ * Copy of the workflow input with every tags value (and tags column)
+ * canonical — rules and transitions must read tags the way the client emits
+ * them, else `[" urgent "]` dodges a `contains "urgent"` rule.
+ */
+function withNormalizedTags(workflow, input) {
+    const out = { ...input };
+    for (const form of workflow.forms) {
+        const values = Object.hasOwn(input, form.form_name) ? input[form.form_name] : undefined;
+        if (!isRecord(values))
+            continue;
+        const next = { ...values };
+        for (const field of form.fields) {
+            if (Object.hasOwn(next, field.key)) {
+                next[field.key] = normalizeCanonicalValue(field, next[field.key]);
+            }
+        }
+        out[form.form_name] = next;
+    }
+    return out;
+}
+/**
+ * One field's shape check + canonical value + declarative/custom validators.
+ * Junk (wrong shape) never reaches canonical data — it resets to the
+ * descriptor default.
+ */
+function validatedFieldData(field, raw, registry, data) {
+    const shape = shapeIssues(field, raw, field.key);
+    if (shape.length > 0)
+        return { value: defaultValue(field), issues: shape };
+    const value = normalizeCanonicalValue(field, raw);
+    const issues = validateField(field, value, registry, data).map((err) => ({
+        ref: err.key,
+        message: err.message,
+    }));
+    return { value, issues };
+}
 function formDataResult(form, input, registry) {
     if (!isRecord(input)) {
         return { valid: false, issues: [{ ref: '$', message: 'data must be an object' }], data: {} };
@@ -204,15 +304,9 @@ function formDataResult(form, input, registry) {
         data[field.key] = Object.hasOwn(input, field.key) ? input[field.key] : defaultValue(field);
     }
     for (const field of fields) {
-        const shape = shapeIssues(field, data[field.key], field.key);
-        if (shape.length > 0) {
-            issues.push(...shape);
-            data[field.key] = defaultValue(field); // junk never reaches canonical data
-            continue;
-        }
-        for (const err of validateField(field, data[field.key], registry, data)) {
-            issues.push({ ref: err.key, message: err.message });
-        }
+        const { value, issues: fieldIssues } = validatedFieldData(field, data[field.key], registry, data);
+        data[field.key] = value;
+        issues.push(...fieldIssues);
     }
     issues.push(...submitScriptIssues(form, data, registry));
     return { valid: issues.length === 0, issues, data };
@@ -321,6 +415,7 @@ function workflowFieldIssues(form, field, derived, registry) {
         formData[field.key] = defaultValue(field); // junk never reaches canonical data
         return shape;
     }
+    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) => ({
@@ -360,7 +455,7 @@ function workflowDataResult(workflow, input, registry) {
     const rejection = workflowInputRejection(input);
     if (rejection)
         return rejection;
-    const derived = evaluate(workflow, input);
+    const derived = evaluate(workflow, withNormalizedTags(workflow, input));
     // Schema-integrity errors (unknown rule targets) belong at parseSchema /
     // store time — the client never surfaces them, so failing submissions on
     // them would reject data the client happily emits. Only data-dependent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-validator",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "type": "module",
   "description": "Runtime validation for bahtui form/workflow JSON \u2014 the exact engine rules the client runs, on the server.",
   "license": "MIT",
@@ -41,12 +41,12 @@
     "test:coverage": "vitest run --coverage"
   },
   "devDependencies": {
-    "bank20baht-ui": "^0.9.0",
+    "bank20baht-ui": "^0.11.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "bank20baht-ui": ">=0.5.0 <0.10.0"
+    "bank20baht-ui": ">=0.11.0 <0.12.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",