@astroapps/forms-core 1.0.0

package/src/schemaInterface.ts

@@ -0,0 +1,135 @@
+import {
+  EqualityFunc,
+  FieldOption,
+  SchemaField,
+  ValidationMessageType,
+} from "./schemaField";
+import { SchemaDataNode } from "./schemaDataNode";
+import { SchemaNode } from "./schemaNode";
+import { Control, ControlSetup } from "@astroapps/controls";
+
+/**
+ * Interface for schema-related operations.
+ */
+export interface SchemaInterface {
+  /**
+   * Checks if the value of a field is empty.
+   * @param field The schema field.
+   * @param value The value to check.
+   * @returns True if the value is empty, false otherwise.
+   */
+  isEmptyValue(field: SchemaField, value: any): boolean;
+
+  /**
+   * Gets the text representation of a field's value.
+   * @param field The schema field.
+   * @param value The value to convert.
+   * @param element Indicates if the value is an element, optional.
+   * @param options The field options, optional.
+   * @returns The text representation of the value.
+   */
+  textValue(
+    field: SchemaField,
+    value: any,
+    element?: boolean,
+    options?: FieldOption[],
+  ): string | undefined;
+
+  /**
+   * Gets the text representation of a field's value for a data node.
+   * @param dataNode
+   */
+  textValueForData(dataNode: SchemaDataNode): string | undefined;
+
+  /**
+   * Gets the length of a control's value.
+   * @param field The schema field.
+   * @param control The control to check.
+   * @returns The length of the control's value.
+   */
+  controlLength(field: SchemaField, control: Control<any>): number;
+
+  /**
+   * Gets the length of a field's value.
+   * @param field The schema field.
+   * @param value The value to check.
+   * @returns The length of the value.
+   */
+  valueLength(field: SchemaField, value: any): number;
+
+  /**
+   * Gets the data options for a schema data node.
+   * @param node The schema data node.
+   * @returns The data options.
+   */
+  getDataOptions(node: SchemaDataNode): FieldOption[] | null | undefined;
+
+  /**
+   * Gets the node options for a schema node.
+   * @param node The schema node.
+   * @returns The node options.
+   */
+  getNodeOptions(node: SchemaNode): FieldOption[] | null | undefined;
+
+  /**
+   * Gets the options for a schema field.
+   * @param field The schema field.
+   * @returns The field options.
+   */
+  getOptions(field: SchemaField): FieldOption[] | undefined | null;
+
+  /**
+   * Gets the filter options for a schema data node and field.
+   * @param array The schema data node.
+   * @param field The schema node.
+   * @returns The filter options.
+   */
+  getFilterOptions(
+    array: SchemaDataNode,
+    field: SchemaNode,
+  ): FieldOption[] | undefined | null;
+
+  /**
+   * Parses a string value to milliseconds.
+   * @param field The schema field.
+   * @param v The string value to parse.
+   * @returns The parsed value in milliseconds.
+   */
+  parseToMillis(field: SchemaField, v: string): number;
+
+  /**
+   * Gets the validation message text for a field.
+   * @param field The schema field.
+   * @param messageType The type of validation message.
+   * @param actual The actual value.
+   * @param expected The expected value.
+   * @returns The validation message text.
+   */
+  validationMessageText(
+    field: SchemaField,
+    messageType: ValidationMessageType,
+    actual: any,
+    expected: any,
+  ): string;
+
+  /**
+   * Compares two values of a field.
+   * @param field The schema field.
+   * @param v1 The first value.
+   * @param v2 The second value.
+   * @returns The comparison result.
+   */
+  compareValue(field: SchemaField, v1: unknown, v2: unknown): number;
+
+  /**
+   * Gets the search text for a field's value.
+   * @param field The schema field.
+   * @param value The value to search.
+   * @returns The search text.
+   */
+  searchText(field: SchemaField, value: any): string;
+
+  makeEqualityFunc(field: SchemaNode, element?: boolean): EqualityFunc;
+
+  makeControlSetup(field: SchemaNode, element?: boolean): ControlSetup<any>;
+}

package/src/schemaNode.ts

@@ -0,0 +1,285 @@
+import {
+  CompoundField,
+  FieldType,
+  isCompoundField,
+  missingField,
+  SchemaField,
+} from "./schemaField";
+
+export interface SchemaTreeLookup {
+  getSchema(schemaId: string): SchemaNode | undefined;
+
+  getSchemaTree(schemaId: string, additional?: SchemaField[]): SchemaTree | undefined;
+}
+
+export abstract class SchemaTree {
+  abstract rootNode: SchemaNode;
+
+  abstract getSchemaTree(schemaId: string): SchemaTree | undefined;
+
+  createChildNode(parent: SchemaNode, field: SchemaField): SchemaNode {
+    return new SchemaNode(parent.id + "/" + field.field, field, this, parent);
+  }
+
+  getSchema(schemaId: string): SchemaNode | undefined {
+    return this.getSchemaTree(schemaId)?.rootNode;
+  }
+}
+
+class SchemaTreeImpl extends SchemaTree {
+  rootNode: SchemaNode;
+
+  getSchemaTree(schemaId: string): SchemaTree | undefined {
+    return this.lookup?.getSchemaTree(schemaId);
+  }
+
+  constructor(
+    rootFields: SchemaField[],
+    private lookup?: SchemaTreeLookup,
+  ) {
+    super();
+    this.rootNode = new SchemaNode(
+      "",
+      {
+        type: FieldType.Compound,
+        field: "",
+        children: rootFields,
+      } as CompoundField,
+      this,
+    );
+  }
+}
+
+export function createSchemaTree(
+  rootFields: SchemaField[],
+  lookup?: SchemaTreeLookup,
+): SchemaTree {
+  return new SchemaTreeImpl(rootFields, lookup);
+}
+
+export class SchemaNode {
+  public constructor(
+    public id: string,
+    public field: SchemaField,
+    public tree: SchemaTree,
+    public parent?: SchemaNode,
+  ) {}
+
+  getSchema(schemaId: string): SchemaNode | undefined {
+    return this.tree.getSchema(schemaId);
+  }
+
+  getUnresolvedFields(): SchemaField[] {
+    return isCompoundField(this.field) ? this.field.children : [];
+  }
+
+  getResolvedParent(noRecurse?: boolean): SchemaNode | undefined {
+    const f = this.field;
+    if (!isCompoundField(f)) return undefined;
+    const parentNode = f.schemaRef
+      ? this.tree.getSchema(f.schemaRef)
+      : !noRecurse && f.treeChildren
+        ? this.parent?.getResolvedParent()
+        : undefined;
+    return parentNode ?? this;
+  }
+
+  getResolvedFields(): SchemaField[] {
+    const resolvedParent = this.getResolvedParent();
+    return resolvedParent?.getUnresolvedFields() ?? [];
+  }
+
+  getChildNodes(): SchemaNode[] {
+    const node = this;
+    return node.getResolvedFields().map((x) => node.createChildNode(x));
+  }
+
+  getChildField(field: string): SchemaField {
+    return (
+      this.getResolvedFields().find((x) => x.field === field) ??
+      missingField(field)
+    );
+  }
+
+  createChildNode(field: SchemaField): SchemaNode {
+    return this.tree.createChildNode(this, field);
+  }
+
+  getChildNode(field: string): SchemaNode {
+    return this.createChildNode(this.getChildField(field));
+  }
+}
+
+export function resolveSchemaNode(
+  node: SchemaNode,
+  fieldSegment: string,
+): SchemaNode | undefined {
+  if (fieldSegment == ".") return node;
+  if (fieldSegment == "..") return node.parent;
+  return node.getChildNode(fieldSegment);
+}
+
+export function createSchemaNode(
+  field: SchemaField,
+  lookup: SchemaTree,
+  parent: SchemaNode | undefined,
+): SchemaNode {
+  return new SchemaNode(
+    parent ? parent.id + "/" + field.field : field.field,
+    field,
+    lookup,
+    parent,
+  );
+}
+
+export function createSchemaLookup<A extends Record<string, SchemaField[]>>(
+  schemaMap: A,
+): {
+  getSchema(schemaId: keyof A): SchemaNode;
+  getSchemaTree(schemaId: keyof A, additional?: SchemaField[]): SchemaTree;
+} {
+  const lookup = {
+    getSchemaTree,
+    getSchema,
+  };
+  return lookup;
+
+  function getSchema(schemaId: keyof A): SchemaNode {
+    return getSchemaTree(schemaId)!.rootNode;
+  }
+
+  function getSchemaTree(
+    schemaId: keyof A,
+    additional?: SchemaField[],
+  ): SchemaTree {
+    const fields = schemaMap[schemaId];
+    if (fields) {
+      return new SchemaTreeImpl(
+        additional ? [...fields, ...additional] : fields,
+        lookup,
+      );
+    }
+    return undefined!;
+  }
+}
+
+export function schemaForFieldRef(
+  fieldRef: string | undefined,
+  schema: SchemaNode,
+): SchemaNode {
+  return schemaForFieldPath(fieldRef?.split("/") ?? [], schema);
+}
+
+export function traverseSchemaPath<A>(
+  fieldPath: string[],
+  schema: SchemaNode,
+  acc: A,
+  next: (acc: A, node: SchemaNode) => A,
+): A {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode = resolveSchemaNode(schema, nextField);
+    if (!childNode) {
+      childNode = createSchemaNode(
+        missingField(nextField),
+        schema.tree,
+        schema,
+      );
+    }
+    acc = next(acc, childNode);
+    schema = childNode;
+    i++;
+  }
+  return acc;
+}
+
+export function traverseData(
+  fieldPath: string[],
+  root: SchemaNode,
+  data: { [k: string]: any },
+): unknown {
+  return traverseSchemaPath(
+    fieldPath,
+    root,
+    data,
+    (acc, n) => acc?.[n.field.field] as any,
+  );
+}
+
+export function schemaForFieldPath(
+  fieldPath: string[],
+  schema: SchemaNode,
+): SchemaNode {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode = resolveSchemaNode(schema, nextField);
+    if (!childNode) {
+      childNode = createSchemaNode(
+        missingField(nextField),
+        schema.tree,
+        schema,
+      );
+    }
+    schema = childNode;
+    i++;
+  }
+  return schema;
+}
+
+export function getSchemaNodePath(node: SchemaNode) {
+  const paths: string[] = [];
+  let curNode: SchemaNode | undefined = node;
+  while (curNode) {
+    paths.push(curNode.field.field);
+    curNode = curNode.parent;
+  }
+  return paths.reverse();
+}
+
+export function getSchemaNodePathString(node: SchemaNode) {
+  return getSchemaNodePath(node).join("/");
+}
+
+export function isCompoundNode(node: SchemaNode) {
+  return isCompoundField(node.field);
+}
+
+/**
+ * Returns the relative path from a parent node to a child node.
+ * @param parent
+ * @param child
+ */
+export function relativePath(parent: SchemaNode, child: SchemaNode): string {
+  // return the path from child to parent
+  if (parent.id === child.id) return ".";
+
+  const parentPath = getSchemaNodePath(parent);
+  const childPath = getSchemaNodePath(child);
+  return relativeSegmentPath(parentPath, childPath);
+}
+
+/**
+ * Returns the relative path from a parent node to a child node.
+ * @param parentPath
+ * @param childPath
+ */
+export function relativeSegmentPath(
+  parentPath: string[],
+  childPath: string[],
+): string {
+  let i = 0;
+  while (
+    i < parentPath.length &&
+    i < childPath.length &&
+    parentPath[i] === childPath[i]
+  ) {
+    i++;
+  }
+
+  const upLevels = parentPath.length - i;
+  const downPath = childPath.slice(i).join("/");
+
+  return "../".repeat(upLevels) + downPath;
+}

package/src/schemaValidator.ts

@@ -0,0 +1,32 @@
+export enum ValidatorType {
+  Jsonata = "Jsonata",
+  Date = "Date",
+  Length = "Length",
+}
+
+export interface SchemaValidator {
+  type: string;
+}
+
+export interface JsonataValidator extends SchemaValidator {
+  type: ValidatorType.Jsonata;
+  expression: string;
+}
+
+export interface LengthValidator extends SchemaValidator {
+  type: ValidatorType.Length;
+  min?: number | null;
+  max?: number | null;
+}
+
+export enum DateComparison {
+  NotBefore = "NotBefore",
+  NotAfter = "NotAfter",
+}
+
+export interface DateValidator extends SchemaValidator {
+  type: ValidatorType.Date;
+  comparison: DateComparison;
+  fixedDate?: string | null;
+  daysFromCurrent?: number | null;
+}

package/src/util.ts

@@ -0,0 +1,50 @@
+import {
+  addDependent,
+  CleanupScope,
+  Control, ControlSetup,
+  newControl,
+  updateComputedValue
+} from "@astroapps/controls";
+
+/**
+ * Type representing a JSON path, which can be a string or a number.
+ */
+export type JsonPath = string | number;
+
+/**
+ * Converts a JSON path array to a string.
+ * @param jsonPath - The JSON path array to convert.
+ * @param customIndex - Optional function to customize the index format.
+ * @returns The JSON path string.
+ */
+export function jsonPathString(
+  jsonPath: JsonPath[],
+  customIndex?: (n: number) => string,
+) {
+  let out = "";
+  jsonPath.forEach((v, i) => {
+    if (typeof v === "number") {
+      out += customIndex?.(v) ?? "[" + v + "]";
+    } else {
+      if (i > 0) out += ".";
+      out += v;
+    }
+  });
+  return out;
+}
+
+export function createScopedComputed<T>(
+  parent: CleanupScope,
+  compute: () => T,
+): Control<T> {
+  const c = newControl<any>(undefined);
+  updateComputedValue(c, compute);
+  addDependent(parent, c);
+  return c.as();
+}
+
+export function createScoped<T>(parent: CleanupScope, value: T, setup?: ControlSetup<T>): Control<T> {
+  const c = newControl<T>(value, setup);
+  addDependent(parent, c);
+  return c;
+}

package/src/validators.ts

@@ -0,0 +1,220 @@
+import {
+  DateComparison,
+  DateValidator,
+  JsonataValidator,
+  LengthValidator,
+  SchemaValidator,
+  ValidatorType,
+} from "./schemaValidator";
+import { ControlDefinition, isDataControl } from "./controlDefinition";
+import { SchemaDataNode } from "./schemaDataNode";
+import {
+  Control,
+  ControlChange,
+  createCleanupScope,
+  createEffect,
+  trackControlChange,
+} from "@astroapps/controls";
+import { ValidationMessageType } from "./schemaField";
+import { SchemaInterface } from "./schemaInterface";
+
+import { FormContextOptions } from "./formState";
+import { FormNode } from "./formNode";
+import { jsonataEval } from "./evalExpression";
+import { ExpressionType } from "./entityExpression";
+import { createScopedComputed } from "./util";
+
+export interface ValidationEvalContext {
+  addSync(validate: (value: unknown) => string | undefined | null): void;
+  addCleanup(cleanup: () => void): void;
+  validationEnabled: Control<boolean>;
+  parentData: SchemaDataNode;
+  data: SchemaDataNode;
+  schemaInterface: SchemaInterface;
+  formContext: Control<FormContextOptions>;
+}
+
+export type ValidatorEval<T extends SchemaValidator> = (
+  validation: T,
+  context: ValidationEvalContext,
+) => void;
+
+export const jsonataValidator: ValidatorEval<JsonataValidator> = (
+  validation,
+  context,
+) => {
+  const error = createScopedComputed(context, () => undefined);
+  jsonataEval(
+    { type: ExpressionType.Jsonata, expression: validation.expression },
+    {
+      scope: error,
+      dataNode: context.parentData,
+      returnResult: (v) => {
+        trackControlChange(context.data.control, ControlChange.Validate);
+        console.log("Setting jsonata error", v);
+        context.data.control.setError("jsonata", v?.toString());
+      },
+      schemaInterface: context.schemaInterface,
+      variables: context.formContext.fields.variables,
+    },
+  );
+};
+
+export const lengthValidator: ValidatorEval<LengthValidator> = (
+  lv,
+  context,
+) => {
+  const { schemaInterface } = context;
+  context.addSync(() => {
+    const field = context.data.schema.field;
+    const control = context.data.control;
+    const len = schemaInterface.controlLength(field, control);
+    if (lv.min != null && len < lv.min) {
+      if (field?.collection) {
+        control.setValue((v) =>
+          Array.isArray(v)
+            ? v.concat(Array.from({ length: lv.min! - v.length }))
+            : Array.from({ length: lv.min! }),
+        );
+      } else {
+        return schemaInterface.validationMessageText(
+          field,
+          ValidationMessageType.MinLength,
+          len,
+          lv.min,
+        );
+      }
+    } else if (lv.max != null && len > lv.max) {
+      return schemaInterface.validationMessageText(
+        field,
+        ValidationMessageType.MaxLength,
+        len,
+        lv.max,
+      );
+    }
+    return undefined;
+  });
+};
+
+export const dateValidator: ValidatorEval<DateValidator> = (dv, context) => {
+  const { schemaInterface } = context;
+  const field = context.data.schema.field;
+  let comparisonDate: number;
+  if (dv.fixedDate) {
+    comparisonDate = schemaInterface.parseToMillis(field, dv.fixedDate);
+  } else {
+    const nowDate = new Date();
+    comparisonDate = Date.UTC(
+      nowDate.getFullYear(),
+      nowDate.getMonth(),
+      nowDate.getDate(),
+    );
+    if (dv.daysFromCurrent) {
+      comparisonDate += dv.daysFromCurrent * 86400000;
+    }
+  }
+
+  context.addSync((v) => {
+    if (v) {
+      const selDate = schemaInterface.parseToMillis(field, v as string);
+      const notAfter = dv.comparison === DateComparison.NotAfter;
+      if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+        return schemaInterface.validationMessageText(
+          field,
+          notAfter
+            ? ValidationMessageType.NotAfterDate
+            : ValidationMessageType.NotBeforeDate,
+          selDate,
+          comparisonDate,
+        );
+      }
+    }
+    return null;
+  });
+};
+
+export const defaultValidators: Record<string, ValidatorEval<any>> = {
+  [ValidatorType.Jsonata]: jsonataValidator,
+  [ValidatorType.Length]: lengthValidator,
+  [ValidatorType.Date]: dateValidator,
+};
+
+export function createValidators(
+  def: ControlDefinition,
+  context: ValidationEvalContext,
+): void {
+  if (isDataControl(def)) {
+    const { schemaInterface } = context;
+    if (def.required) {
+      context.addSync((v) => {
+        const field = context.data.schema.field;
+        return schemaInterface.isEmptyValue(field, v)
+          ? schemaInterface.validationMessageText(
+              field,
+              ValidationMessageType.NotEmpty,
+              false,
+              true,
+            )
+          : null;
+      });
+    }
+    def.validators?.forEach((x) => defaultValidators[x.type]?.(x, context));
+  }
+}
+
+export function setupValidation(
+  controlImpl: Control<FormContextOptions>,
+  definition: ControlDefinition,
+  dataNode: Control<SchemaDataNode | undefined>,
+  schemaInterface: SchemaInterface,
+  parent: SchemaDataNode,
+  formNode: FormNode,
+) {
+  const validationEnabled = createScopedComputed(
+    controlImpl,
+    () => !definition.hidden,
+  );
+  const validatorsScope = createCleanupScope();
+  createEffect(
+    () => {
+      validatorsScope.cleanup();
+      const dn = dataNode.value;
+      if (dn) {
+        let syncValidations: ((v: unknown) => string | undefined | null)[] = [];
+        createValidators(formNode.definition, {
+          data: dn,
+          parentData: parent,
+          validationEnabled,
+          schemaInterface,
+          addSync(validate: (v: unknown) => string | undefined | null) {
+            syncValidations.push(validate);
+          },
+          addCleanup(cleanup: () => void) {
+            validatorsScope.addCleanup(cleanup);
+          },
+          formContext: controlImpl,
+        });
+
+        createEffect(
+          () => {
+            if (!validationEnabled.value) return undefined;
+            trackControlChange(dn.control, ControlChange.Validate);
+            const value = dn.control.value;
+            let error = null;
+            for (const syncValidation of syncValidations) {
+              error = syncValidation(value);
+              if (error) break;
+            }
+            return error;
+          },
+          (e) => {
+            dn.control.setError("default", e);
+          },
+          validatorsScope,
+        );
+      }
+    },
+    (c) => {},
+    controlImpl,
+  );
+}