@bygghammar/cms-platform 0.3.0 → 0.4.0

package/src/forms/conditions.ts

@@ -0,0 +1,350 @@
+/**
+ * Conditional logic + validation engine for managed forms.
+ *
+ * Pure and isomorphic on purpose: the exact same rules run in the browser
+ * (live show/hide + inline errors) and on the server (authoritative check),
+ * so a form can never be bypassed by disabling JavaScript.
+ */
+import type { LocalizedString } from "../i18n";
+import type { ConditionRule, FieldCondition, FormFieldDef } from "./field-sets";
+
+/* ------------------------------- conditions ------------------------------- */
+
+export const CONDITION_OPERATORS: {
+  value: FieldCondition["op"];
+  label: string;
+  /** Operators that do not need a comparison value. */
+  unary?: boolean;
+}[] = [
+  { value: "equals", label: "is" },
+  { value: "not_equals", label: "is not" },
+  { value: "contains", label: "contains" },
+  { value: "not_contains", label: "does not contain" },
+  { value: "starts_with", label: "starts with" },
+  { value: "gt", label: "is greater than" },
+  { value: "lt", label: "is less than" },
+  { value: "is_empty", label: "is empty", unary: true },
+  { value: "is_not_empty", label: "is answered", unary: true },
+  { value: "checked", label: "is checked", unary: true },
+  { value: "unchecked", label: "is not checked", unary: true },
+];
+
+const UNARY = new Set(CONDITION_OPERATORS.filter((o) => o.unary).map((o) => o.value));
+
+export const isUnaryOperator = (op: FieldCondition["op"]) => UNARY.has(op);
+
+const isTruthyCheckbox = (v: string) => ["true", "1", "on", "yes"].includes(v.trim().toLowerCase());
+
+const num = (v: string) => Number(String(v).replace(",", ".").trim());
+
+function testCondition(c: FieldCondition, values: Record<string, string>): boolean {
+  const raw = (values[c.field] ?? "").toString();
+  const a = raw.trim().toLowerCase();
+  const b = (c.value ?? "").toString().trim().toLowerCase();
+  switch (c.op) {
+    case "equals":
+      return a === b;
+    case "not_equals":
+      return a !== b;
+    case "contains":
+      return b !== "" && a.includes(b);
+    case "not_contains":
+      return b === "" || !a.includes(b);
+    case "starts_with":
+      return b !== "" && a.startsWith(b);
+    case "gt":
+      return Number.isFinite(num(raw)) && Number.isFinite(num(b)) && num(raw) > num(b);
+    case "lt":
+      return Number.isFinite(num(raw)) && Number.isFinite(num(b)) && num(raw) < num(b);
+    case "is_empty":
+      return a === "";
+    case "is_not_empty":
+      return a !== "";
+    case "checked":
+      return isTruthyCheckbox(raw);
+    case "unchecked":
+      return !isTruthyCheckbox(raw);
+    default:
+      return true;
+  }
+}
+
+/** An empty / missing rule always passes. */
+export function evaluateRule(
+  rule: ConditionRule | undefined | null,
+  values: Record<string, string>,
+): boolean {
+  const list = (rule?.conditions ?? []).filter((c) => c && c.field);
+  if (list.length === 0) return true;
+  return rule?.mode === "any"
+    ? list.some((c) => testCondition(c, values))
+    : list.every((c) => testCondition(c, values));
+}
+
+export const hasRule = (rule: ConditionRule | undefined | null) =>
+  (rule?.conditions ?? []).filter((c) => c && c.field).length > 0;
+
+/** A field renders when it is enabled and its show-rule passes. */
+export function isFieldVisible(f: FormFieldDef, values: Record<string, string>): boolean {
+  if (!f.enabled) return false;
+  return evaluateRule(f.showWhen, values);
+}
+
+/** Required either always, or because a require-rule matched. */
+export function isFieldRequired(f: FormFieldDef, values: Record<string, string>): boolean {
+  if (!isFieldVisible(f, values)) return false;
+  if (f.required) return true;
+  return hasRule(f.requireWhen) ? evaluateRule(f.requireWhen, values) : false;
+}
+
+/** Fields that are actually rendered for the current answers. */
+export function visibleFields(
+  fields: FormFieldDef[],
+  values: Record<string, string>,
+): FormFieldDef[] {
+  return fields.filter((f) => isFieldVisible(f, values));
+}
+
+/* ------------------------------- validation ------------------------------- */
+
+export type FieldFormat =
+  | "none"
+  | "email"
+  | "phone"
+  | "phone_se"
+  | "url"
+  | "digits"
+  | "letters"
+  | "alphanumeric"
+  | "postal_se"
+  | "orgnr_se"
+  | "custom";
+
+export const FIELD_FORMATS: { value: FieldFormat; label: string }[] = [
+  { value: "none", label: "No extra format check" },
+  { value: "email", label: "Email address" },
+  { value: "phone", label: "Phone (international)" },
+  { value: "phone_se", label: "Phone (Swedish)" },
+  { value: "url", label: "Web address" },
+  { value: "digits", label: "Digits only" },
+  { value: "letters", label: "Letters only" },
+  { value: "alphanumeric", label: "Letters and digits" },
+  { value: "postal_se", label: "Swedish postcode" },
+  { value: "orgnr_se", label: "Swedish org. number" },
+  { value: "custom", label: "Custom pattern (regex)" },
+];
+
+export const EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]{2,}$/;
+
+const FORMAT_RE: Record<Exclude<FieldFormat, "none" | "custom">, RegExp> = {
+  email: EMAIL_RE,
+  phone: /^\+?[0-9][0-9()\s./-]{4,29}$/,
+  phone_se: /^(\+46|0)[\s-]?7?[0-9][0-9\s-]{5,13}$/,
+  url: /^https?:\/\/[^\s.]+\.\S{2,}$/i,
+  digits: /^[0-9]+$/,
+  letters: /^[\p{L}\s'-]+$/u,
+  alphanumeric: /^[\p{L}0-9\s'-]+$/u,
+  postal_se: /^[0-9]{3}\s?[0-9]{2}$/,
+  orgnr_se: /^[0-9]{6}-?[0-9]{4}$/,
+};
+
+type Msgs = {
+  required: string;
+  requiredCheck: string;
+  min: string;
+  max: string;
+  minLength: string;
+  maxLength: string;
+  number: string;
+  date: string;
+  time: string;
+  choice: string;
+  format: Record<Exclude<FieldFormat, "none" | "custom">, string> & { custom: string };
+};
+
+const SV: Msgs = {
+  required: '"{label}" måste fyllas i.',
+  requiredCheck: '"{label}" måste kryssas i.',
+  min: '"{label}" måste vara minst {n}.',
+  max: '"{label}" får vara högst {n}.',
+  minLength: '"{label}" måste vara minst {n} tecken.',
+  maxLength: '"{label}" får vara högst {n} tecken.',
+  number: '"{label}" måste vara ett tal.',
+  date: '"{label}" måste vara ett giltigt datum.',
+  time: '"{label}" måste vara en giltig tid.',
+  choice: '"{label}" har ett ogiltigt val.',
+  format: {
+    email: '"{label}" måste vara en giltig e-postadress.',
+    phone: '"{label}" måste vara ett giltigt telefonnummer.',
+    phone_se: '"{label}" måste vara ett giltigt svenskt telefonnummer.',
+    url: '"{label}" måste vara en giltig webbadress.',
+    digits: '"{label}" får bara innehålla siffror.',
+    letters: '"{label}" får bara innehålla bokstäver.',
+    alphanumeric: '"{label}" får bara innehålla bokstäver och siffror.',
+    postal_se: '"{label}" måste vara ett giltigt postnummer, t.ex. 123 45.',
+    orgnr_se: '"{label}" måste vara ett giltigt organisationsnummer.',
+    custom: '"{label}" har fel format.',
+  },
+};
+
+const EN: Msgs = {
+  required: '"{label}" is required.',
+  requiredCheck: '"{label}" must be checked.',
+  min: '"{label}" must be at least {n}.',
+  max: '"{label}" must be at most {n}.',
+  minLength: '"{label}" must be at least {n} characters.',
+  maxLength: '"{label}" must be at most {n} characters.',
+  number: '"{label}" must be a number.',
+  date: '"{label}" must be a valid date.',
+  time: '"{label}" must be a valid time.',
+  choice: '"{label}" has an invalid choice.',
+  format: {
+    email: '"{label}" must be a valid email address.',
+    phone: '"{label}" must be a valid phone number.',
+    phone_se: '"{label}" must be a valid Swedish phone number.',
+    url: '"{label}" must be a valid web address.',
+    digits: '"{label}" may only contain digits.',
+    letters: '"{label}" may only contain letters.',
+    alphanumeric: '"{label}" may only contain letters and digits.',
+    postal_se: '"{label}" must be a valid postcode, e.g. 123 45.',
+    orgnr_se: '"{label}" must be a valid organisation number.',
+    custom: '"{label}" has an invalid format.',
+  },
+};
+
+const msgs = (locale: string): Msgs => (locale.startsWith("en") ? EN : SV);
+
+const fill = (tpl: string, label: string, n?: number | string) =>
+  tpl.replace(/\{label\}/g, label).replace(/\{n\}/g, String(n ?? ""));
+
+export function fieldLabel(f: FormFieldDef, locale = "sv"): string {
+  const l = f.label as Partial<LocalizedString>;
+  return (l?.[locale as keyof LocalizedString] ?? l?.sv ?? l?.en ?? f.key) as string;
+}
+
+function customMessage(f: FormFieldDef, locale: string): string | null {
+  const m = f.errorMessage as Partial<LocalizedString> | undefined;
+  const v = (m?.[locale as keyof LocalizedString] ?? m?.sv ?? m?.en ?? "") as string;
+  return v.trim() ? v.trim() : null;
+}
+
+/** Normalise a checkbox answer to a stable stored string. */
+export const normalizeCheckbox = (v: string) => (isTruthyCheckbox(v) ? "true" : "false");
+
+/**
+ * Validate one field against the whole answer set (so conditional
+ * requirements can be resolved). Returns an error message or `null`.
+ */
+export function validateField(
+  f: FormFieldDef,
+  values: Record<string, string>,
+  locale = "sv",
+): string | null {
+  if (!isFieldVisible(f, values)) return null;
+
+  const M = msgs(locale);
+  const label = fieldLabel(f, locale);
+  const raw = (values[f.key] ?? "").toString();
+  const v = raw.trim();
+  const required = isFieldRequired(f, values);
+  const custom = customMessage(f, locale);
+
+  if (f.type === "checkbox") {
+    if (required && !isTruthyCheckbox(v)) return custom ?? fill(M.requiredCheck, label);
+    return null;
+  }
+
+  if (!v) return required ? (custom ?? fill(M.required, label)) : null;
+
+  switch (f.type) {
+    case "number": {
+      const n = num(v);
+      if (!Number.isFinite(n)) return custom ?? fill(M.number, label);
+      if (f.min != null && n < f.min) return custom ?? fill(M.min, label, f.min);
+      if (f.max != null && n > f.max) return custom ?? fill(M.max, label, f.max);
+      break;
+    }
+    case "date": {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(v) || Number.isNaN(Date.parse(v)))
+        return custom ?? fill(M.date, label);
+      if (f.minDate && v < f.minDate) return custom ?? fill(M.min, label, f.minDate);
+      if (f.maxDate && v > f.maxDate) return custom ?? fill(M.max, label, f.maxDate);
+      break;
+    }
+    case "time":
+      if (!/^\d{2}:\d{2}(:\d{2})?$/.test(v)) return custom ?? fill(M.time, label);
+      break;
+    case "trip":
+    case "course":
+      // Choices come from the live Courses section; an answer captured before
+      // a course changed must never be rejected.
+      break;
+    case "select": {
+      const opts = (f.options ?? []).map((o) => o.value);
+      if (opts.length && !opts.includes(raw.trim())) return custom ?? fill(M.choice, label);
+      break;
+    }
+    case "email":
+      if (!EMAIL_RE.test(v)) return custom ?? fill(M.format.email, label);
+      break;
+    case "tel":
+      if (!FORMAT_RE.phone.test(v)) return custom ?? fill(M.format.phone, label);
+      break;
+    case "url":
+      if (!FORMAT_RE.url.test(v)) return custom ?? fill(M.format.url, label);
+      break;
+    default:
+      break;
+  }
+
+  if (f.minLength && v.length < f.minLength) return custom ?? fill(M.minLength, label, f.minLength);
+  if (f.maxLength && v.length > f.maxLength) return custom ?? fill(M.maxLength, label, f.maxLength);
+
+  const fmt = (f.format ?? "none") as FieldFormat;
+  if (fmt !== "none" && fmt !== "custom") {
+    const re = FORMAT_RE[fmt];
+    if (re && !re.test(v)) return custom ?? fill(M.format[fmt], label);
+  }
+  if (f.pattern) {
+    let re: RegExp | null = null;
+    try {
+      re = new RegExp(f.pattern);
+    } catch {
+      re = null; // an invalid saved pattern must never block a real customer
+    }
+    if (re && !re.test(v)) return custom ?? fill(M.format.custom, label);
+  }
+  return null;
+}
+
+/** Validate every field. Returns a map of field key -> error message. */
+export function validateAll(
+  fields: FormFieldDef[],
+  values: Record<string, string>,
+  locale = "sv",
+): Record<string, string> {
+  const errors: Record<string, string> = {};
+  for (const f of fields) {
+    const err = validateField(f, values, locale);
+    if (err) errors[f.key] = err;
+  }
+  return errors;
+}
+
+/**
+ * Clean a privacy policy URL that a human typed or pasted.
+ * Strips wrapping brackets/parentheses/quotes and whitespace, and upgrades a
+ * bare domain to https:// so the link always resolves.
+ */
+export function normalizePolicyUrl(raw: string | undefined | null): string {
+  let v = (raw ?? "").trim();
+  for (let i = 0; i < 4; i++) {
+    const before = v;
+    v = v.replace(/^[([{"'<\s]+/, "").replace(/[)\]}"'>\s]+$/, "");
+    if (v === before) break;
+  }
+  if (!v) return "";
+  if (/^(https?:\/\/|mailto:|tel:|\/|#)/i.test(v)) return v;
+  if (/^[\w-]+(\.[\w-]+)+(\/|$)/.test(v)) return `https://${v}`;
+  return `/${v.replace(/^\/+/, "")}`;
+}