@xnetjs/data 0.3.0 → 0.5.0

package/dist/{chunk-3RUDVTMH.js → chunk-Q67VT5XL.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-QWFTRZQT.js";
 import {
   DatabaseRowSchema
-} from "./chunk-DWEXKD6E.js";
+} from "./chunk-FB63TZVI.js";
 import {
   DatabaseFieldSchema
 } from "./chunk-KQAT4XBL.js";
@@ -25,7 +25,7 @@ import {
 } from "./chunk-6OMG4I7M.js";
 import {
   DatabaseViewSchema
-} from "./chunk-H4GA4BBK.js";
+} from "./chunk-MD553LDL.js";
 import {
   createNodeQueryDescriptor
 } from "./chunk-S5RP5RKY.js";
@@ -85,7 +85,7 @@ function isCellValue(value) {
 
 // src/database/row-operations.ts
 async function createRow(store, options) {
-  const { databaseId, cells = {}, before, after } = options;
+  const { databaseId, cells = {}, before, after, id, submissionMeta } = options;
   let sortKey;
   if (!before && !after) {
     const { rows } = await queryRows(store, databaseId, { limit: 1, sortDirection: "desc" });
@@ -104,10 +104,12 @@ async function createRow(store, options) {
     {
       type: "create",
       options: {
+        ...id ? { id } : {},
         schemaId: DatabaseRowSchema.schema["@id"],
         properties: {
           database: databaseId,
           sortKey,
+          ...submissionMeta ? { submissionMeta } : {},
           ...dynamicProperties
         }
       }
@@ -1286,6 +1288,296 @@ function requiresDateColumn(type) {
   return type === "calendar" || type === "timeline";
 }
 
+// src/database/filter-engine.ts
+function filterRows(rows, columns, filter) {
+  if (!filter || filter.conditions.length === 0) {
+    return rows;
+  }
+  return rows.filter((row) => evaluateGroup(row, columns, filter));
+}
+function evaluateGroup(row, columns, group) {
+  if (group.conditions.length === 0) {
+    return true;
+  }
+  const results = group.conditions.map((condition) => {
+    if (isFilterGroup(condition)) {
+      return evaluateGroup(row, columns, condition);
+    }
+    return evaluateCondition(row, columns, condition);
+  });
+  if (group.operator === "and") {
+    return results.every(Boolean);
+  } else {
+    return results.some(Boolean);
+  }
+}
+function evaluateCondition(row, columns, condition) {
+  const column = columns.find((c) => c.id === condition.columnId);
+  if (!column) {
+    return true;
+  }
+  const cellValue = row.cells[condition.columnId];
+  const filterValue = condition.value;
+  return evaluateOperator(cellValue, filterValue, condition.operator, column.type);
+}
+function evaluateOperator(cellValue, filterValue, operator, columnType) {
+  switch (operator) {
+    // ─── Equality ─────────────────────────────────────────────────────────────
+    case "equals":
+      return cellValue === filterValue;
+    case "notEquals":
+      return cellValue !== filterValue;
+    // ─── Text Operators ───────────────────────────────────────────────────────
+    case "contains":
+      if (typeof cellValue === "string") {
+        return cellValue.toLowerCase().includes(String(filterValue).toLowerCase());
+      }
+      if (Array.isArray(cellValue)) {
+        return cellValue.includes(filterValue);
+      }
+      return false;
+    case "notContains":
+      return !evaluateOperator(cellValue, filterValue, "contains", columnType);
+    case "startsWith":
+      return typeof cellValue === "string" && cellValue.toLowerCase().startsWith(String(filterValue).toLowerCase());
+    case "endsWith":
+      return typeof cellValue === "string" && cellValue.toLowerCase().endsWith(String(filterValue).toLowerCase());
+    // ─── Empty Operators ──────────────────────────────────────────────────────
+    case "isEmpty":
+      return cellValue === null || cellValue === void 0 || cellValue === "" || Array.isArray(cellValue) && cellValue.length === 0;
+    case "isNotEmpty":
+      return !evaluateOperator(cellValue, null, "isEmpty", columnType);
+    // ─── Comparison Operators ─────────────────────────────────────────────────
+    case "greaterThan":
+      return Number(cellValue) > Number(filterValue);
+    case "lessThan":
+      return Number(cellValue) < Number(filterValue);
+    case "greaterOrEqual":
+      return Number(cellValue) >= Number(filterValue);
+    case "lessOrEqual":
+      return Number(cellValue) <= Number(filterValue);
+    // ─── Date Operators ───────────────────────────────────────────────────────
+    case "before":
+      if (cellValue == null) return false;
+      return new Date(cellValue) < new Date(filterValue);
+    case "after":
+      if (cellValue == null) return false;
+      return new Date(cellValue) > new Date(filterValue);
+    case "between": {
+      if (cellValue == null) return false;
+      const [start, end] = filterValue;
+      const date = new Date(cellValue);
+      return date >= new Date(start) && date <= new Date(end);
+    }
+    // ─── Multi-Select Operators ───────────────────────────────────────────────
+    case "hasAny": {
+      const anyValues = filterValue;
+      if (!Array.isArray(cellValue)) return false;
+      return anyValues.some((v) => cellValue.includes(v));
+    }
+    case "hasAll": {
+      const allValues = filterValue;
+      if (!Array.isArray(cellValue)) return false;
+      return allValues.every((v) => cellValue.includes(v));
+    }
+    case "hasNone": {
+      const noneValues = filterValue;
+      if (!Array.isArray(cellValue)) return true;
+      return !noneValues.some((v) => cellValue.includes(v));
+    }
+    default:
+      return true;
+  }
+}
+function createEqualsFilter(columnId, value) {
+  return {
+    operator: "and",
+    conditions: [{ columnId, operator: "equals", value }]
+  };
+}
+function createAnyOfFilter(columnId, values) {
+  return {
+    operator: "or",
+    conditions: values.map((value) => ({
+      columnId,
+      operator: "equals",
+      value
+    }))
+  };
+}
+function combineFiltersAnd(filters) {
+  return {
+    operator: "and",
+    conditions: filters
+  };
+}
+function combineFiltersOr(filters) {
+  return {
+    operator: "or",
+    conditions: filters
+  };
+}
+
+// src/database/form-types.ts
+var compact = (obj) => {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0 && value !== "" && value !== false) out[key] = value;
+  }
+  return out;
+};
+function publicFormQuestion(question, column, resolvedOptions) {
+  if (!column) return null;
+  const type = column.type;
+  if (!isFormFieldTypeAllowed(type, "public")) return null;
+  const configOptions = column.config?.options;
+  const options = resolvedOptions ?? configOptions ?? [];
+  return compact({
+    fieldId: question.fieldId,
+    label: question.label,
+    description: question.description,
+    required: question.required,
+    type,
+    options: options.length > 0 ? options.map((o) => compact({ id: o.id, name: o.name, color: o.color })) : void 0
+  });
+}
+function publishableRules(rules, asked) {
+  const published = {};
+  for (const [fieldId, rule] of Object.entries(rules ?? {})) {
+    if (asked.has(fieldId) && rule.when.every((cond) => asked.has(cond.columnId))) {
+      published[fieldId] = rule;
+    }
+  }
+  return Object.keys(published).length > 0 ? published : void 0;
+}
+function buildPublicFormDefinition(config, rules, columns, fieldOptions) {
+  const byId = new Map(columns.map((c) => [c.id, c]));
+  const questions = config.questions.map((q) => publicFormQuestion(q, byId.get(q.fieldId), fieldOptions?.[q.fieldId])).filter((q) => q !== null);
+  const asked = new Set(questions.map((q) => q.fieldId));
+  return compact({
+    title: config.title,
+    description: config.description,
+    questions,
+    rules: publishableRules(rules, asked),
+    submitLabel: config.submitLabel,
+    confirmation: config.confirmation
+  });
+}
+async function submissionRowId(tokenHash, nonce) {
+  const bytes = new TextEncoder().encode(`form-submission\0${tokenHash}\0${nonce}`);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `formsub_${hex.slice(0, 24)}`;
+}
+var PUBLIC_SAFE_FORM_FIELD_TYPES = [
+  "text",
+  "number",
+  "checkbox",
+  "date",
+  "dateRange",
+  "select",
+  "multiSelect",
+  "url",
+  "email",
+  "phone"
+];
+function isFormFieldTypeAllowed(type, audience) {
+  if (isComputedFieldType(type) || isAutoFieldType(type)) return false;
+  if (type === "richText") return false;
+  if (audience === "public") {
+    return PUBLIC_SAFE_FORM_FIELD_TYPES.includes(type);
+  }
+  return true;
+}
+function isFormQuestionVisible(rule, answers, columns) {
+  if (!rule || rule.when.length === 0) return true;
+  const pseudoRow = { id: "__form_draft__", cells: answers };
+  const matched = filterRows([pseudoRow], columns, {
+    operator: rule.match === "any" ? "or" : "and",
+    conditions: rule.when
+  });
+  return matched.length === 1;
+}
+function visibleFormQuestions(config, rules, answers, columns, audience) {
+  const byId = new Map(columns.map((c) => [c.id, c]));
+  return config.questions.filter((q) => {
+    const column = byId.get(q.fieldId);
+    if (!column) return false;
+    if (!isFormFieldTypeAllowed(column.type, audience)) return false;
+    return isFormQuestionVisible(rules?.[q.fieldId], answers, columns);
+  });
+}
+function isPlausibleValue(type, value) {
+  if (value == null) return true;
+  switch (type) {
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "checkbox":
+      return typeof value === "boolean";
+    case "multiSelect":
+      return Array.isArray(value);
+    case "text":
+    case "url":
+    case "email":
+    case "phone":
+    case "select":
+    case "date":
+      return typeof value === "string";
+    default:
+      return true;
+  }
+}
+function selectOptionsOf(column) {
+  const config = column.config;
+  if (!config?.options) return null;
+  return new Set(config.options.map((o) => o.id));
+}
+var isEmptyAnswer = (value) => value == null || value === "" || Array.isArray(value) && value.length === 0;
+function answerDriftErrors(answers, configured, byId, audience) {
+  const errors = [];
+  for (const fieldId of Object.keys(answers)) {
+    if (!configured.has(fieldId)) continue;
+    const column = byId.get(fieldId);
+    if (!column) {
+      errors.push({ fieldId, reason: "unknown-field" });
+    } else if (!isFormFieldTypeAllowed(column.type, audience)) {
+      errors.push({ fieldId, reason: "type-not-allowed" });
+    }
+  }
+  return errors;
+}
+function answerError(question, column, value) {
+  if (isEmptyAnswer(value)) {
+    return question.required ? "required" : void 0;
+  }
+  if (!isPlausibleValue(column.type, value)) return "bad-value";
+  if (column.type === "select" || column.type === "multiSelect") {
+    const known = selectOptionsOf(column);
+    const ids = Array.isArray(value) ? value.map(String) : [String(value)];
+    if (known && ids.some((id) => !known.has(id))) return "bad-option";
+  }
+  return void 0;
+}
+function validateFormSubmission(config, rules, answers, columns, audience) {
+  const cells = {};
+  const byId = new Map(columns.map((c) => [c.id, c]));
+  const configured = new Set(config.questions.map((q) => q.fieldId));
+  const visible = visibleFormQuestions(config, rules, answers, columns, audience);
+  const errors = answerDriftErrors(answers, configured, byId, audience);
+  for (const question of visible) {
+    const column = byId.get(question.fieldId);
+    if (!column) continue;
+    const value = answers[question.fieldId] ?? null;
+    const reason = answerError(question, column, value);
+    if (reason) {
+      errors.push({ fieldId: question.fieldId, reason });
+    } else if (!isEmptyAnswer(value)) {
+      cells[question.fieldId] = value;
+    }
+  }
+  return { ok: errors.length === 0, errors, cells };
+}
+
 // src/database/view-operations.ts
 import { nanoid as nanoid3 } from "nanoid";
 import * as Y4 from "yjs";
@@ -1535,136 +1827,6 @@ function operatorRequiresValue(operator) {
   return !["isEmpty", "isNotEmpty"].includes(operator);
 }
 
-// src/database/filter-engine.ts
-function filterRows(rows, columns, filter) {
-  if (!filter || filter.conditions.length === 0) {
-    return rows;
-  }
-  return rows.filter((row) => evaluateGroup(row, columns, filter));
-}
-function evaluateGroup(row, columns, group) {
-  if (group.conditions.length === 0) {
-    return true;
-  }
-  const results = group.conditions.map((condition) => {
-    if (isFilterGroup(condition)) {
-      return evaluateGroup(row, columns, condition);
-    }
-    return evaluateCondition(row, columns, condition);
-  });
-  if (group.operator === "and") {
-    return results.every(Boolean);
-  } else {
-    return results.some(Boolean);
-  }
-}
-function evaluateCondition(row, columns, condition) {
-  const column = columns.find((c) => c.id === condition.columnId);
-  if (!column) {
-    return true;
-  }
-  const cellValue = row.cells[condition.columnId];
-  const filterValue = condition.value;
-  return evaluateOperator(cellValue, filterValue, condition.operator, column.type);
-}
-function evaluateOperator(cellValue, filterValue, operator, columnType) {
-  switch (operator) {
-    // ─── Equality ─────────────────────────────────────────────────────────────
-    case "equals":
-      return cellValue === filterValue;
-    case "notEquals":
-      return cellValue !== filterValue;
-    // ─── Text Operators ───────────────────────────────────────────────────────
-    case "contains":
-      if (typeof cellValue === "string") {
-        return cellValue.toLowerCase().includes(String(filterValue).toLowerCase());
-      }
-      if (Array.isArray(cellValue)) {
-        return cellValue.includes(filterValue);
-      }
-      return false;
-    case "notContains":
-      return !evaluateOperator(cellValue, filterValue, "contains", columnType);
-    case "startsWith":
-      return typeof cellValue === "string" && cellValue.toLowerCase().startsWith(String(filterValue).toLowerCase());
-    case "endsWith":
-      return typeof cellValue === "string" && cellValue.toLowerCase().endsWith(String(filterValue).toLowerCase());
-    // ─── Empty Operators ──────────────────────────────────────────────────────
-    case "isEmpty":
-      return cellValue === null || cellValue === void 0 || cellValue === "" || Array.isArray(cellValue) && cellValue.length === 0;
-    case "isNotEmpty":
-      return !evaluateOperator(cellValue, null, "isEmpty", columnType);
-    // ─── Comparison Operators ─────────────────────────────────────────────────
-    case "greaterThan":
-      return Number(cellValue) > Number(filterValue);
-    case "lessThan":
-      return Number(cellValue) < Number(filterValue);
-    case "greaterOrEqual":
-      return Number(cellValue) >= Number(filterValue);
-    case "lessOrEqual":
-      return Number(cellValue) <= Number(filterValue);
-    // ─── Date Operators ───────────────────────────────────────────────────────
-    case "before":
-      if (cellValue == null) return false;
-      return new Date(cellValue) < new Date(filterValue);
-    case "after":
-      if (cellValue == null) return false;
-      return new Date(cellValue) > new Date(filterValue);
-    case "between": {
-      if (cellValue == null) return false;
-      const [start, end] = filterValue;
-      const date = new Date(cellValue);
-      return date >= new Date(start) && date <= new Date(end);
-    }
-    // ─── Multi-Select Operators ───────────────────────────────────────────────
-    case "hasAny": {
-      const anyValues = filterValue;
-      if (!Array.isArray(cellValue)) return false;
-      return anyValues.some((v) => cellValue.includes(v));
-    }
-    case "hasAll": {
-      const allValues = filterValue;
-      if (!Array.isArray(cellValue)) return false;
-      return allValues.every((v) => cellValue.includes(v));
-    }
-    case "hasNone": {
-      const noneValues = filterValue;
-      if (!Array.isArray(cellValue)) return true;
-      return !noneValues.some((v) => cellValue.includes(v));
-    }
-    default:
-      return true;
-  }
-}
-function createEqualsFilter(columnId, value) {
-  return {
-    operator: "and",
-    conditions: [{ columnId, operator: "equals", value }]
-  };
-}
-function createAnyOfFilter(columnId, values) {
-  return {
-    operator: "or",
-    conditions: values.map((value) => ({
-      columnId,
-      operator: "equals",
-      value
-    }))
-  };
-}
-function combineFiltersAnd(filters) {
-  return {
-    operator: "and",
-    conditions: filters
-  };
-}
-function combineFiltersOr(filters) {
-  return {
-    operator: "or",
-    conditions: filters
-  };
-}
-
 // src/database/sort-engine.ts
 function sortRows(rows, columns, sorts) {
   if (!sorts || sorts.length === 0) {
@@ -5410,6 +5572,18 @@ export {
   isFilterCondition,
   supportsGrouping,
   requiresDateColumn,
+  filterRows,
+  createEqualsFilter,
+  createAnyOfFilter,
+  combineFiltersAnd,
+  combineFiltersOr,
+  buildPublicFormDefinition,
+  submissionRowId,
+  PUBLIC_SAFE_FORM_FIELD_TYPES,
+  isFormFieldTypeAllowed,
+  isFormQuestionVisible,
+  visibleFormQuestions,
+  validateFormSubmission,
   getViews2,
   getView2,
   getViewByType,
@@ -5436,11 +5610,6 @@ export {
   isValidOperator,
   getOperatorLabel,
   operatorRequiresValue,
-  filterRows,
-  createEqualsFilter,
-  createAnyOfFilter,
-  combineFiltersAnd,
-  combineFiltersOr,
   sortRows,
   createSort,
   toggleSortDirection,