@fogpipe/forma-core 0.6.0 → 0.8.0

package/src/__tests__/validate.test.ts

@@ -0,0 +1,278 @@
+/**
+ * Tests for validation engine
+ */
+
+import { describe, it, expect } from "vitest";
+import { validate } from "../engine/validate.js";
+import type { Forma } from "../types.js";
+
+/**
+ * Helper to create a minimal Forma spec for testing
+ */
+function createTestSpec(options: {
+  schemaProperties: Record<string, unknown>;
+  fields?: Record<string, unknown>;
+  required?: string[];
+}): Forma {
+  const { schemaProperties, fields = {}, required = [] } = options;
+
+  // Build fields from schema if not provided
+  const fieldDefs = Object.keys(schemaProperties).reduce(
+    (acc, key) => {
+      acc[key] = fields[key] || { label: key };
+      return acc;
+    },
+    {} as Record<string, unknown>
+  );
+
+  return {
+    version: "1.0",
+    meta: { id: "test", title: "Test" },
+    schema: {
+      type: "object",
+      properties: schemaProperties as Forma["schema"]["properties"],
+      required: required.length > 0 ? required : undefined,
+    },
+    fields: fieldDefs as Forma["fields"],
+    fieldOrder: Object.keys(schemaProperties),
+  };
+}
+
+describe("validate", () => {
+  // ============================================================================
+  // multipleOf validation
+  // ============================================================================
+
+  describe("multipleOf", () => {
+    it("should pass when value is a multiple of the constraint", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          amount: { type: "number", multipleOf: 0.01 },
+        },
+      });
+
+      const result = validate({ amount: 10.25 }, spec);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it("should fail when value is not a multiple of the constraint", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          amount: { type: "number", multipleOf: 0.01 },
+        },
+        fields: { amount: { label: "Amount" } },
+      });
+
+      const result = validate({ amount: 10.255 }, spec);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].field).toBe("amount");
+      expect(result.errors[0].message).toBe("Amount must be a multiple of 0.01");
+    });
+
+    it("should handle multipleOf for integers", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          quantity: { type: "integer", multipleOf: 5 },
+        },
+        fields: { quantity: { label: "Quantity" } },
+      });
+
+      // Valid - multiple of 5
+      expect(validate({ quantity: 15 }, spec).valid).toBe(true);
+      expect(validate({ quantity: 100 }, spec).valid).toBe(true);
+
+      // Invalid - not multiple of 5
+      const result = validate({ quantity: 17 }, spec);
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toBe("Quantity must be a multiple of 5");
+    });
+
+    it("should handle multipleOf: 0.5 for half-units", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          rating: { type: "number", multipleOf: 0.5 },
+        },
+      });
+
+      // Valid half-units
+      expect(validate({ rating: 3.5 }, spec).valid).toBe(true);
+      expect(validate({ rating: 4.0 }, spec).valid).toBe(true);
+      expect(validate({ rating: 0.5 }, spec).valid).toBe(true);
+
+      // Invalid
+      expect(validate({ rating: 3.3 }, spec).valid).toBe(false);
+      expect(validate({ rating: 4.25 }, spec).valid).toBe(false);
+    });
+
+    it("should handle floating point precision correctly", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          value: { type: "number", multipleOf: 0.1 },
+        },
+      });
+
+      // These should pass despite floating point precision issues
+      // 0.1 + 0.2 = 0.30000000000000004 in JS
+      expect(validate({ value: 0.3 }, spec).valid).toBe(true);
+      expect(validate({ value: 0.7 }, spec).valid).toBe(true);
+      expect(validate({ value: 1.1 }, spec).valid).toBe(true);
+    });
+
+    it("should pass validation when value is null/undefined (empty)", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          amount: { type: "number", multipleOf: 0.01 },
+        },
+      });
+
+      // Empty values should not trigger multipleOf validation
+      expect(validate({ amount: null }, spec).valid).toBe(true);
+      expect(validate({ amount: undefined }, spec).valid).toBe(true);
+      expect(validate({}, spec).valid).toBe(true);
+    });
+
+    it("should work with minimum and maximum constraints together", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          friction: {
+            type: "number",
+            minimum: 0.05,
+            maximum: 0.3,
+            multipleOf: 0.01,
+          },
+        },
+        fields: { friction: { label: "Friction Coefficient" } },
+      });
+
+      // Valid - within range and correct precision
+      expect(validate({ friction: 0.14 }, spec).valid).toBe(true);
+      expect(validate({ friction: 0.05 }, spec).valid).toBe(true);
+      expect(validate({ friction: 0.3 }, spec).valid).toBe(true);
+
+      // Invalid - wrong precision
+      const precisionResult = validate({ friction: 0.145 }, spec);
+      expect(precisionResult.valid).toBe(false);
+      expect(precisionResult.errors[0].message).toContain("multiple of 0.01");
+
+      // Invalid - below minimum
+      const minResult = validate({ friction: 0.01 }, spec);
+      expect(minResult.valid).toBe(false);
+      expect(minResult.errors[0].message).toContain("at least 0.05");
+
+      // Invalid - above maximum
+      const maxResult = validate({ friction: 0.5 }, spec);
+      expect(maxResult.valid).toBe(false);
+      expect(maxResult.errors[0].message).toContain("no more than 0.3");
+    });
+
+    it("should handle multipleOf: 1 for whole numbers", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          count: { type: "number", multipleOf: 1 },
+        },
+      });
+
+      expect(validate({ count: 5 }, spec).valid).toBe(true);
+      expect(validate({ count: 100 }, spec).valid).toBe(true);
+      expect(validate({ count: 5.5 }, spec).valid).toBe(false);
+    });
+
+    it("should handle very small multipleOf values", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          precision: { type: "number", multipleOf: 0.001 },
+        },
+      });
+
+      expect(validate({ precision: 1.234 }, spec).valid).toBe(true);
+      expect(validate({ precision: 1.2345 }, spec).valid).toBe(false);
+    });
+
+    it("should handle large multipleOf values", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          angle: { type: "integer", multipleOf: 15 },
+        },
+      });
+
+      expect(validate({ angle: 0 }, spec).valid).toBe(true);
+      expect(validate({ angle: 15 }, spec).valid).toBe(true);
+      expect(validate({ angle: 90 }, spec).valid).toBe(true);
+      expect(validate({ angle: 360 }, spec).valid).toBe(true);
+      expect(validate({ angle: 45 }, spec).valid).toBe(true);
+      expect(validate({ angle: 17 }, spec).valid).toBe(false);
+    });
+  });
+
+  // ============================================================================
+  // Basic type validation (existing behavior)
+  // ============================================================================
+
+  describe("basic type validation", () => {
+    it("should validate required fields", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          name: { type: "string" },
+        },
+        required: ["name"],
+      });
+
+      const result = validate({ name: "" }, spec);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toContain("required");
+    });
+
+    it("should validate minimum for numbers", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          age: { type: "integer", minimum: 0 },
+        },
+        fields: { age: { label: "Age" } },
+      });
+
+      expect(validate({ age: 25 }, spec).valid).toBe(true);
+      expect(validate({ age: 0 }, spec).valid).toBe(true);
+
+      const result = validate({ age: -1 }, spec);
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toBe("Age must be at least 0");
+    });
+
+    it("should validate maximum for numbers", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          percentage: { type: "number", maximum: 100 },
+        },
+        fields: { percentage: { label: "Percentage" } },
+      });
+
+      expect(validate({ percentage: 50 }, spec).valid).toBe(true);
+      expect(validate({ percentage: 100 }, spec).valid).toBe(true);
+
+      const result = validate({ percentage: 101 }, spec);
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toBe("Percentage must be no more than 100");
+    });
+
+    it("should validate string minLength", () => {
+      const spec = createTestSpec({
+        schemaProperties: {
+          name: { type: "string", minLength: 2 },
+        },
+        fields: { name: { label: "Name" } },
+      });
+
+      expect(validate({ name: "Jo" }, spec).valid).toBe(true);
+      expect(validate({ name: "John" }, spec).valid).toBe(true);
+
+      const result = validate({ name: "J" }, spec);
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toBe("Name must be at least 2 characters");
+    });
+  });
+});

package/src/engine/validate.ts

@@ -333,6 +333,20 @@ function validateType(
         }
       }
 
+      if ("multipleOf" in schema && schema.multipleOf !== undefined) {
+        const multipleOf = schema.multipleOf;
+        // Use epsilon comparison to handle floating point precision issues
+        const remainder = Math.abs(value % multipleOf);
+        const isValid = remainder < 1e-10 || Math.abs(remainder - multipleOf) < 1e-10;
+        if (!isValid) {
+          return {
+            field: path,
+            message: `${label} must be a multiple of ${multipleOf}`,
+            severity: "error",
+          };
+        }
+      }
+
       return null;
     }
 

package/src/index.ts

@@ -5,8 +5,42 @@
  * Provides types, FEEL expression evaluation, and form state engines.
  */
 
-// Types
-export * from "./types.js";
+// Types (explicit type-only exports)
+export type {
+  // FEEL
+  FEELExpression,
+  // JSON Schema
+  JSONSchema,
+  JSONSchemaProperty,
+  JSONSchemaBase,
+  JSONSchemaString,
+  JSONSchemaNumber,
+  JSONSchemaInteger,
+  JSONSchemaBoolean,
+  JSONSchemaArray,
+  JSONSchemaObject,
+  JSONSchemaEnum,
+  // Field types
+  FieldType,
+  ValidationRule,
+  SelectOption,
+  FieldDefinition,
+  ComputedField,
+  PageDefinition,
+  FormMeta,
+  Forma,
+  // Evaluation
+  EvaluationContext,
+  // Results
+  VisibilityResult,
+  RequiredResult,
+  RequiredFieldsResult,
+  EnabledResult,
+  FieldError,
+  ValidationResult,
+  CalculationError,
+  CalculationResult,
+} from "./types.js";
 
 // FEEL expression evaluation
 export * from "./feel/index.js";

package/src/types.ts

@@ -71,12 +71,14 @@ export interface JSONSchemaNumber extends JSONSchemaBase {
   maximum?: number;
   exclusiveMinimum?: number;
   exclusiveMaximum?: number;
+  multipleOf?: number;
 }
 
 export interface JSONSchemaInteger extends JSONSchemaBase {
   type: "integer";
   minimum?: number;
   maximum?: number;
+  multipleOf?: number;
 }
 
 export interface JSONSchemaBoolean extends JSONSchemaBase {

package/dist/engine/index.d.cts

@@ -1,258 +0,0 @@
-import { m as Forma, t as CalculationResult, n as VisibilityResult, o as RequiredFieldsResult, p as EnabledResult, r as ValidationResult, q as FieldError } from '../types-Bs3CG9JZ.cjs';
-
-/**
- * Calculation Engine
- *
- * Evaluates computed fields based on form data.
- * Computed values are derived from form data using FEEL expressions.
- */
-
-/**
- * Calculate all computed values from form data
- *
- * Evaluates each computed field's FEEL expression and returns the results.
- * Errors are collected rather than thrown, allowing partial results.
- *
- * @param data - Current form data
- * @param spec - Form specification with computed fields
- * @returns Computed values and any calculation errors
- *
- * @example
- * const spec = {
- *   computed: {
- *     bmi: {
- *       expression: "weight / (height / 100) ** 2",
- *       label: "BMI",
- *       format: "decimal(1)"
- *     },
- *     isObese: {
- *       expression: "$computed.bmi >= 30"
- *     }
- *   }
- * };
- *
- * const result = calculate({ weight: 85, height: 175 }, spec);
- * // => { values: { bmi: 27.76, isObese: false }, errors: [] }
- */
-declare function calculate(data: Record<string, unknown>, spec: Forma): Record<string, unknown>;
-/**
- * Calculate computed values with error reporting
- *
- * Same as calculate() but also returns any errors that occurred.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Values and errors
- */
-declare function calculateWithErrors(data: Record<string, unknown>, spec: Forma): CalculationResult;
-/**
- * Get a computed value formatted according to its format specification
- *
- * @param fieldName - Name of the computed field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Formatted string or null if not displayable
- */
-declare function getFormattedValue(fieldName: string, data: Record<string, unknown>, spec: Forma): string | null;
-/**
- * Calculate a single computed field
- *
- * @param fieldName - Name of the computed field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Computed value or null if calculation failed
- */
-declare function calculateField(fieldName: string, data: Record<string, unknown>, spec: Forma): unknown;
-
-/**
- * Visibility Engine
- *
- * Determines which fields should be visible based on form data
- * and Forma visibility rules.
- */
-
-interface VisibilityOptions {
-    /** Pre-calculated computed values (avoids recalculation) */
-    computed?: Record<string, unknown>;
-}
-/**
- * Determine visibility for all fields in a form
- *
- * Returns a map of field paths to boolean visibility states.
- * Fields without visibleWhen expressions are always visible.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Optional pre-calculated computed values
- * @returns Map of field paths to visibility states
- *
- * @example
- * const visibility = getVisibility(
- *   { age: 21, hasLicense: true },
- *   forma
- * );
- * // => { age: true, hasLicense: true, vehicleType: true, ... }
- */
-declare function getVisibility(data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): VisibilityResult;
-/**
- * Check if a single field is visible
- *
- * Useful for checking visibility of one field without computing all.
- *
- * @param fieldPath - Field path to check
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Optional pre-calculated computed values
- * @returns True if the field is visible
- */
-declare function isFieldVisible(fieldPath: string, data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): boolean;
-/**
- * Determine which pages are visible in a wizard form
- *
- * @param data - Current form data
- * @param spec - Form specification with pages
- * @param options - Optional pre-calculated computed values
- * @returns Map of page IDs to visibility states
- */
-declare function getPageVisibility(data: Record<string, unknown>, spec: Forma, options?: VisibilityOptions): Record<string, boolean>;
-
-/**
- * Required Fields Engine
- *
- * Determines which fields are currently required based on
- * conditional requiredWhen expressions and schema required array.
- */
-
-interface RequiredOptions {
-    /** Pre-calculated computed values */
-    computed?: Record<string, unknown>;
-}
-/**
- * Determine which fields are currently required
- *
- * Returns a map of field paths to boolean required states.
- * Evaluates requiredWhen expressions for conditional requirements.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Optional pre-calculated computed values
- * @returns Map of field paths to required states
- *
- * @example
- * const required = getRequired(
- *   { hasInsurance: true },
- *   forma
- * );
- * // => { hasInsurance: true, insuranceProvider: true, policyNumber: true }
- */
-declare function getRequired(data: Record<string, unknown>, spec: Forma, options?: RequiredOptions): RequiredFieldsResult;
-/**
- * Check if a single field is currently required
- *
- * @param fieldPath - Path to the field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns True if the field is required
- */
-declare function isRequired(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
-
-/**
- * Enabled Fields Engine
- *
- * Determines which fields are currently enabled (editable) based on
- * conditional enabledWhen expressions.
- */
-
-interface EnabledOptions {
-    /** Pre-calculated computed values */
-    computed?: Record<string, unknown>;
-}
-/**
- * Determine which fields are currently enabled (editable)
- *
- * Returns a map of field paths to boolean enabled states.
- * Fields without enabledWhen expressions are always enabled.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Optional pre-calculated computed values
- * @returns Map of field paths to enabled states
- *
- * @example
- * const enabled = getEnabled(
- *   { isLocked: true },
- *   forma
- * );
- * // => { isLocked: true, lockedField: false, ... }
- */
-declare function getEnabled(data: Record<string, unknown>, spec: Forma, options?: EnabledOptions): EnabledResult;
-/**
- * Check if a single field is currently enabled
- *
- * @param fieldPath - Path to the field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns True if the field is enabled
- */
-declare function isEnabled(fieldPath: string, data: Record<string, unknown>, spec: Forma): boolean;
-
-/**
- * Validation Engine
- *
- * Validates form data against Forma rules including:
- * - JSON Schema type validation
- * - Required field validation (with conditional requiredWhen)
- * - Custom FEEL validation rules
- * - Array item validation
- */
-
-interface ValidateOptions {
-    /** Pre-calculated computed values */
-    computed?: Record<string, unknown>;
-    /** Pre-calculated visibility */
-    visibility?: Record<string, boolean>;
-    /** Only validate visible fields (default: true) */
-    onlyVisible?: boolean;
-}
-/**
- * Validate form data against a Forma
- *
- * Performs comprehensive validation including:
- * - Required field checks (respecting conditional requiredWhen)
- * - JSON Schema type validation
- * - Custom FEEL validation rules
- * - Array min/max items validation
- * - Array item field validation
- *
- * By default, only visible fields are validated.
- *
- * @param data - Current form data
- * @param spec - Form specification
- * @param options - Validation options
- * @returns Validation result with valid flag and errors array
- *
- * @example
- * const result = validate(
- *   { name: "", age: 15 },
- *   forma
- * );
- * // => {
- * //   valid: false,
- * //   errors: [
- * //     { field: "name", message: "Name is required", severity: "error" },
- * //     { field: "age", message: "Must be 18 or older", severity: "error" }
- * //   ]
- * // }
- */
-declare function validate(data: Record<string, unknown>, spec: Forma, options?: ValidateOptions): ValidationResult;
-/**
- * Validate a single field
- *
- * @param fieldPath - Path to the field
- * @param data - Current form data
- * @param spec - Form specification
- * @returns Array of errors for this field
- */
-declare function validateSingleField(fieldPath: string, data: Record<string, unknown>, spec: Forma): FieldError[];
-
-export { type EnabledOptions, type RequiredOptions, type ValidateOptions, type VisibilityOptions, calculate, calculateField, calculateWithErrors, getEnabled, getFormattedValue, getPageVisibility, getRequired, getVisibility, isEnabled, isFieldVisible, isRequired, validate, validateSingleField };