@treenity/core 1.0.48 → 3.0.0

package/src/comp/validate.test.ts

@@ -0,0 +1,304 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { validateValue, validateComponent, addTypeValidator, type ValidationError } from './validate';
+import type { PropertySchema, TypeSchema } from '#schema/types';
+import type { ComponentData } from '#core';
+
+// Helper: collect errors from validateValue
+function check(value: unknown, def: Partial<PropertySchema>, path = 'x'): ValidationError[] {
+  const errors: ValidationError[] = [];
+  validateValue(value, def as PropertySchema, path, errors);
+  return errors;
+}
+
+describe('validateValue', () => {
+
+  // ── String ──
+
+  describe('string', () => {
+    it('passes valid string', () => {
+      assert.equal(check('hello', { type: 'string' }).length, 0);
+    });
+
+    it('rejects non-string', () => {
+      const e = check(42, { type: 'string' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected string/);
+    });
+
+    it('minLength', () => {
+      assert.equal(check('ab', { type: 'string', minLength: 2 } as any).length, 0);
+      const e = check('a', { type: 'string', minLength: 2 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /min length 2/);
+    });
+
+    it('maxLength', () => {
+      assert.equal(check('ab', { type: 'string', maxLength: 5 } as any).length, 0);
+      const e = check('toolong', { type: 'string', maxLength: 3 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /max length 3/);
+    });
+
+    it('pattern', () => {
+      assert.equal(check('abc123', { type: 'string', pattern: '^[a-z]+\\d+$' } as any).length, 0);
+      const e = check('ABC', { type: 'string', pattern: '^[a-z]+$' } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /must match/);
+    });
+
+    it('enum', () => {
+      assert.equal(check('a', { type: 'string', enum: ['a', 'b'] }).length, 0);
+      const e = check('c', { type: 'string', enum: ['a', 'b'] });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /must be one of/);
+    });
+  });
+
+  // ── Number ──
+
+  describe('number', () => {
+    it('passes valid number', () => {
+      assert.equal(check(42, { type: 'number' }).length, 0);
+    });
+
+    it('rejects non-number', () => {
+      const e = check('nope', { type: 'number' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('minimum', () => {
+      assert.equal(check(10, { type: 'number', minimum: 5 } as any).length, 0);
+      const e = check(3, { type: 'number', minimum: 5 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /minimum 5/);
+    });
+
+    it('maximum', () => {
+      assert.equal(check(5, { type: 'number', maximum: 10 } as any).length, 0);
+      const e = check(15, { type: 'number', maximum: 10 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /maximum 10/);
+    });
+  });
+
+  // ── Boolean ──
+
+  describe('boolean', () => {
+    it('passes valid boolean', () => {
+      assert.equal(check(true, { type: 'boolean' }).length, 0);
+    });
+
+    it('rejects non-boolean', () => {
+      const e = check(1, { type: 'boolean' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected boolean/);
+    });
+  });
+
+  // ── Array ──
+
+  describe('array', () => {
+    it('passes valid array', () => {
+      assert.equal(check([1, 2], { type: 'array' }).length, 0);
+    });
+
+    it('rejects non-array', () => {
+      const e = check('not array', { type: 'array' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected array/);
+    });
+
+    it('minItems', () => {
+      assert.equal(check([1, 2], { type: 'array', minItems: 2 } as any).length, 0);
+      const e = check([1], { type: 'array', minItems: 2 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /min items 2/);
+    });
+
+    it('maxItems', () => {
+      assert.equal(check([1], { type: 'array', maxItems: 3 } as any).length, 0);
+      const e = check([1, 2, 3, 4], { type: 'array', maxItems: 3 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /max items 3/);
+    });
+
+    it('validates primitive items', () => {
+      const def = { type: 'array', items: { type: 'number' } };
+      assert.equal(check([1, 2, 3], def as any).length, 0);
+      const e = check([1, 'bad', 3], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[1]');
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('validates object items with properties', () => {
+      const def = {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', title: 'Name' },
+            age: { type: 'number', title: 'Age' },
+          },
+        },
+      };
+      assert.equal(check([{ name: 'Alice', age: 30 }], def as any).length, 0);
+
+      const e = check([{ name: 'Alice', age: 'thirty' }], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[0].age');
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('validates nested arrays', () => {
+      const def = {
+        type: 'array',
+        items: { type: 'array', items: { type: 'number' } },
+      };
+      assert.equal(check([[1, 2], [3]], def as any).length, 0);
+
+      const e = check([[1, 'x']], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[0][1]');
+    });
+
+    it('skips null items in array', () => {
+      const def = { type: 'array', items: { type: 'number' } };
+      assert.equal(check([1, null, 3], def as any).length, 0);
+    });
+
+    it('rejects non-object when properties expected', () => {
+      const def = {
+        type: 'array',
+        items: { properties: { name: { type: 'string', title: 'N' } } },
+      };
+      const e = check(['not-object'], def as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object/);
+    });
+  });
+
+  // ── Object ──
+
+  describe('object', () => {
+    it('passes valid object', () => {
+      assert.equal(check({}, { type: 'object' }).length, 0);
+    });
+
+    it('rejects non-object', () => {
+      const e = check('nope', { type: 'object' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object/);
+    });
+
+    it('rejects array as object', () => {
+      const e = check([], { type: 'object' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object, got array/);
+    });
+
+    it('validates nested properties', () => {
+      const def = {
+        type: 'object',
+        properties: {
+          x: { type: 'number', title: 'X' },
+        },
+      };
+      assert.equal(check({ x: 5 }, def as any).length, 0);
+      const e = check({ x: 'bad' }, def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x.x');
+    });
+  });
+
+  // ── Edge cases ──
+
+  it('no type = no validation', () => {
+    assert.equal(check('anything', {}).length, 0);
+  });
+
+  it('unknown type = no validation', () => {
+    assert.equal(check('anything', { type: 'custom-widget' }).length, 0);
+  });
+
+  it('preserves path through nesting', () => {
+    const def = {
+      type: 'object',
+      properties: {
+        items: {
+          type: 'array',
+          title: 'Items',
+          items: {
+            properties: {
+              price: { type: 'number', title: 'Price' },
+            },
+          },
+        },
+      },
+    };
+    const e = check({ items: [{ price: 'free' }] }, def as any, 'order');
+    assert.equal(e.length, 1);
+    assert.equal(e[0].path, 'order.items[0].price');
+  });
+});
+
+// ── validateComponent ──
+
+describe('validateComponent', () => {
+  it('validates component against schema', () => {
+    const schema: TypeSchema = {
+      title: 'Money',
+      type: 'object',
+      properties: {
+        amount: { type: 'number', title: 'Amount' },
+        currency: { type: 'string', title: 'Currency' },
+      },
+    };
+    const comp: ComponentData = { $type: 'money', amount: 100, currency: 'USD' };
+    assert.equal(validateComponent(comp, schema, 'budget').length, 0);
+  });
+
+  it('reports errors with component field path', () => {
+    const schema: TypeSchema = {
+      title: 'Money',
+      type: 'object',
+      properties: {
+        amount: { type: 'number', title: 'Amount' },
+      },
+    };
+    const comp: ComponentData = { $type: 'money', amount: 'bad' };
+    const e = validateComponent(comp, schema, 'budget');
+    assert.equal(e.length, 1);
+    assert.equal(e[0].path, 'budget.amount');
+  });
+
+  it('skips null/undefined values', () => {
+    const schema: TypeSchema = {
+      title: 'Test',
+      type: 'object',
+      properties: {
+        name: { type: 'string', title: 'Name' },
+      },
+    };
+    const comp: ComponentData = { $type: 'test' }; // name missing
+    assert.equal(validateComponent(comp, schema, '').length, 0);
+  });
+});
+
+// ── addTypeValidator ──
+
+describe('addTypeValidator', () => {
+  it('extends validation with custom type', () => {
+    addTypeValidator('email', (value, _def, path, errors) => {
+      if (typeof value !== 'string' || !value.includes('@'))
+        errors.push({ path, message: 'invalid email' });
+    });
+
+    assert.equal(check('user@test.com', { type: 'email' }).length, 0);
+    const e = check('not-email', { type: 'email' });
+    assert.equal(e.length, 1);
+    assert.match(e[0].message, /invalid email/);
+  });
+});

package/src/comp/validate.ts

@@ -0,0 +1,125 @@
+// Component validation — shared between client and server
+// Type-dispatched validator tree: type check → dispatch → type-specific constraints + recurse
+
+import { AnyType, type ComponentData, getComponents, type NodeData } from '#core';
+import { resolve } from '#core/registry';
+import type { PropertySchema, TypeSchema } from '#schema/types';
+
+export type ValidationError = {
+  path: string;
+  message: string;
+};
+
+// ── Type-dispatched validator tree ──
+
+type TypeValidator = (value: unknown, def: PropertySchema, path: string, errors: ValidationError[]) => void;
+
+const typeValidators: Record<string, TypeValidator> = {
+  string(value, def, path, errors) {
+    if (typeof value !== 'string') { errors.push({ path, message: `expected string, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minLength === 'number' && value.length < d.minLength)
+      errors.push({ path, message: `min length ${d.minLength}, got ${value.length}` });
+    if (typeof d.maxLength === 'number' && value.length > d.maxLength)
+      errors.push({ path, message: `max length ${d.maxLength}, got ${value.length}` });
+    if (typeof d.pattern === 'string' && !new RegExp(d.pattern).test(value))
+      errors.push({ path, message: `must match /${d.pattern}/` });
+    if (def.enum && !def.enum.includes(value))
+      errors.push({ path, message: `must be one of: ${def.enum.join(', ')}` });
+  },
+
+  number(value, def, path, errors) {
+    if (typeof value !== 'number') { errors.push({ path, message: `expected number, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minimum === 'number' && value < d.minimum)
+      errors.push({ path, message: `minimum ${d.minimum}, got ${value}` });
+    if (typeof d.maximum === 'number' && value > d.maximum)
+      errors.push({ path, message: `maximum ${d.maximum}, got ${value}` });
+  },
+
+  boolean(value, _def, path, errors) {
+    if (typeof value !== 'boolean') errors.push({ path, message: `expected boolean, got ${typeof value}` });
+  },
+
+  array(value, def, path, errors) {
+    if (!Array.isArray(value)) { errors.push({ path, message: `expected array, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minItems === 'number' && value.length < d.minItems)
+      errors.push({ path, message: `min items ${d.minItems}, got ${value.length}` });
+    if (typeof d.maxItems === 'number' && value.length > d.maxItems)
+      errors.push({ path, message: `max items ${d.maxItems}, got ${value.length}` });
+
+    if (!def.items) return;
+    const items = def.items;
+
+    for (let i = 0; i < value.length; i++) {
+      if (value[i] === undefined || value[i] === null) continue;
+      const ip = `${path}[${i}]`;
+
+      if (items.properties) {
+        if (typeof value[i] !== 'object' || value[i] === null) {
+          errors.push({ path: ip, message: `expected object, got ${typeof value[i]}` });
+        } else {
+          validateObject(value[i] as Record<string, unknown>, items.properties as Record<string, PropertySchema>, ip, errors);
+        }
+      } else if (items.type) {
+        validateValue(value[i], items as PropertySchema, ip, errors);
+      }
+    }
+  },
+
+  object(value, def, path, errors) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      errors.push({ path, message: `expected object, got ${Array.isArray(value) ? 'array' : typeof value}` });
+      return;
+    }
+    const props = (def as any).properties as Record<string, PropertySchema> | undefined;
+    if (props) validateObject(value as Record<string, unknown>, props, path, errors);
+  },
+};
+
+// ── Extension point ──
+
+export function addTypeValidator(type: string, fn: TypeValidator): void {
+  typeValidators[type] = fn;
+}
+
+// ── Core ──
+
+export function validateValue(value: unknown, def: PropertySchema, path: string, errors: ValidationError[]): void {
+  if (!def.type) return;
+  const validator = typeValidators[def.type];
+  if (validator) validator(value, def, path, errors);
+}
+
+function validateObject(obj: Record<string, unknown>, properties: Record<string, PropertySchema>, basePath: string, errors: ValidationError[]): void {
+  for (const [prop, propDef] of Object.entries(properties)) {
+    const val = obj[prop];
+    if (val === undefined || val === null) continue;
+    validateValue(val, propDef, basePath ? `${basePath}.${prop}` : prop, errors);
+  }
+}
+
+export function validateComponent(comp: ComponentData, schema: TypeSchema, field: string): ValidationError[] {
+  if (!schema.properties) return [];
+  const errors: ValidationError[] = [];
+  const basePath = field || comp.$type;
+  validateObject(comp as unknown as Record<string, unknown>, schema.properties, basePath, errors);
+  return errors;
+}
+
+export function validateNode(node: NodeData): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  for (const [name, comp] of getComponents(node, AnyType)) {
+    const schemaHandler = resolve(comp.$type, 'schema');
+    if (!schemaHandler) continue;
+
+    const schema = (schemaHandler as () => TypeSchema)();
+    if (!schema?.properties) continue;
+
+    errors.push(...validateComponent(comp, schema, name));
+  }
+
+  return errors;
+}

package/src/comp.ts

@@ -0,0 +1 @@
+export * from './comp/index.ts';

package/src/contexts/schema/index.ts

@@ -0,0 +1,7 @@
+export type SchemaHandler = () => Record<string, unknown>;
+
+declare module '#core/context' {
+  interface ContextHandlers {
+    schema: SchemaHandler;
+  }
+}

package/src/contexts/schema.ts

@@ -0,0 +1 @@
+export * from './schema/index';