@object-ui/core 0.5.0 → 2.0.0

package/src/builder/__tests__/schema-builder.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect } from 'vitest';
+import { form, crud, button, input, card, grid, flex } from '../../builder/schema-builder';
+
+describe('SchemaBuilder', () => {
+  describe('form()', () => {
+    it('creates a basic form schema', () => {
+      const schema = form().id('test-form').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('form');
+      expect(schema.id).toBe('test-form');
+    });
+
+    it('supports field definitions', () => {
+      const schema = form()
+        .field({ name: 'email', label: 'Email', type: 'string' })
+        .build();
+      expect(schema.fields).toHaveLength(1);
+      expect(schema.fields![0].name).toBe('email');
+    });
+
+    it('supports bulk fields', () => {
+      const schema = form()
+        .fields([
+          { name: 'first_name', label: 'First Name', type: 'string' },
+          { name: 'last_name', label: 'Last Name', type: 'string' },
+        ])
+        .build();
+      expect(schema.fields).toHaveLength(2);
+    });
+
+    it('supports default values', () => {
+      const schema = form()
+        .defaultValues({ status: 'active' })
+        .build();
+      expect(schema.defaultValues).toEqual({ status: 'active' });
+    });
+
+    it('supports submit label', () => {
+      const schema = form()
+        .submitLabel('Create')
+        .build();
+      expect(schema.submitLabel).toBe('Create');
+    });
+
+    it('supports layout option', () => {
+      const schema = form()
+        .layout('vertical')
+        .build();
+      expect(schema.layout).toBe('vertical');
+    });
+
+    it('supports columns', () => {
+      const schema = form()
+        .columns(2)
+        .build();
+      expect(schema.columns).toBe(2);
+    });
+
+    it('supports chaining', () => {
+      const schema = form()
+        .id('chained')
+        .field({ name: 'name', label: 'Name', type: 'string' })
+        .submitLabel('Submit')
+        .layout('horizontal')
+        .columns(3)
+        .build();
+      expect(schema.id).toBe('chained');
+      expect(schema.fields).toHaveLength(1);
+      expect(schema.submitLabel).toBe('Submit');
+      expect(schema.layout).toBe('horizontal');
+      expect(schema.columns).toBe(3);
+    });
+  });
+
+  describe('crud()', () => {
+    it('creates a basic CRUD schema', () => {
+      const schema = crud().id('test-crud').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('crud');
+      expect(schema.id).toBe('test-crud');
+    });
+
+    it('supports resource definition', () => {
+      const schema = crud()
+        .resource('users')
+        .build();
+      expect(schema.resource).toBe('users');
+    });
+
+    it('supports column definitions', () => {
+      const schema = crud()
+        .column({ name: 'name', label: 'Name' })
+        .build();
+      expect(schema.columns).toHaveLength(1);
+      expect(schema.columns![0].name).toBe('name');
+    });
+
+    it('supports bulk columns', () => {
+      const schema = crud()
+        .columns([
+          { name: 'id', label: 'ID' },
+          { name: 'name', label: 'Name' },
+        ])
+        .build();
+      expect(schema.columns).toHaveLength(2);
+    });
+
+    it('supports CRUD operations', () => {
+      const schema = crud()
+        .api('/api/users')
+        .enableCreate()
+        .enableUpdate()
+        .enableDelete()
+        .build();
+      expect(schema.operations).toBeDefined();
+      expect(schema.operations!.create.enabled).toBe(true);
+      expect(schema.operations!.update.enabled).toBe(true);
+      expect(schema.operations!.delete.enabled).toBe(true);
+    });
+
+    it('supports pagination', () => {
+      const schema = crud()
+        .pagination(25)
+        .build();
+      expect(schema.pagination).toBeDefined();
+      expect(schema.pagination!.enabled).toBe(true);
+      expect(schema.pagination!.pageSize).toBe(25);
+    });
+  });
+
+  describe('button()', () => {
+    it('creates a button schema', () => {
+      const schema = button().id('btn').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('button');
+      expect(schema.id).toBe('btn');
+    });
+
+    it('supports label', () => {
+      const schema = button()
+        .label('Click Me')
+        .build();
+      expect(schema.label).toBe('Click Me');
+    });
+
+    it('supports variant', () => {
+      const schema = button()
+        .variant('destructive')
+        .build();
+      expect(schema.variant).toBe('destructive');
+    });
+  });
+
+  describe('input()', () => {
+    it('creates an input schema', () => {
+      const schema = input().id('my-input').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('input');
+      expect(schema.id).toBe('my-input');
+    });
+
+    it('supports label and placeholder', () => {
+      const schema = input()
+        .label('Username')
+        .placeholder('Enter username')
+        .build();
+      expect(schema.label).toBe('Username');
+      expect(schema.placeholder).toBe('Enter username');
+    });
+  });
+
+  describe('card()', () => {
+    it('creates a card schema', () => {
+      const schema = card().id('my-card').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('card');
+      expect(schema.id).toBe('my-card');
+    });
+  });
+
+  describe('grid()', () => {
+    it('creates a grid schema', () => {
+      const schema = grid().id('my-grid').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('grid');
+      expect(schema.id).toBe('my-grid');
+    });
+  });
+
+  describe('flex()', () => {
+    it('creates a flex schema', () => {
+      const schema = flex().id('my-flex').build();
+      expect(schema).toBeDefined();
+      expect(schema.type).toBe('flex');
+      expect(schema.id).toBe('my-flex');
+    });
+
+    it('supports direction', () => {
+      const schema = flex()
+        .direction('row')
+        .build();
+      expect(schema.direction).toBe('row');
+    });
+  });
+
+  describe('common builder properties', () => {
+    it('supports className', () => {
+      const schema = button()
+        .className('my-class')
+        .build();
+      expect(schema.className).toBe('my-class');
+    });
+
+    it('supports visible', () => {
+      const schema = button()
+        .visible(false)
+        .build();
+      expect(schema.visible).toBe(false);
+    });
+
+    it('supports disabled', () => {
+      const schema = button()
+        .disabled(true)
+        .build();
+      expect(schema.disabled).toBe(true);
+    });
+
+    it('supports testId', () => {
+      const schema = button()
+        .testId('test-btn')
+        .build();
+      expect(schema.testId).toBe('test-btn');
+    });
+  });
+});

package/src/data-scope/DataScopeManager.ts

@@ -0,0 +1,269 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @object-ui/core - DataScope Manager
+ *
+ * Runtime implementation of the DataContext interface for managing
+ * named data scopes. Provides row-level data access control and
+ * reactive data state management within the UI component tree.
+ *
+ * @module data-scope
+ * @packageDocumentation
+ */
+
+import type { DataScope, DataContext, DataSource } from '@object-ui/types';
+
+/**
+ * Row-level filter for restricting data access within a scope
+ */
+export interface RowLevelFilter {
+  /** Field to filter on */
+  field: string;
+  /** Filter operator */
+  operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'in' | 'nin' | 'contains';
+  /** Filter value */
+  value: any;
+}
+
+/**
+ * Configuration for creating a data scope
+ */
+export interface DataScopeConfig {
+  /** Data source instance */
+  dataSource?: DataSource;
+  /** Initial data */
+  data?: any;
+  /** Row-level filters to apply */
+  filters?: RowLevelFilter[];
+  /** Whether this scope is read-only */
+  readOnly?: boolean;
+}
+
+/**
+ * DataScopeManager — Runtime implementation of DataContext.
+ *
+ * Manages named data scopes for the component tree, providing:
+ * - Scope registration and lookup
+ * - Row-level security via filters
+ * - Data state management (data, loading, error)
+ *
+ * @example
+ * ```ts
+ * const manager = new DataScopeManager();
+ * manager.registerScope('contacts', {
+ *   dataSource: myDataSource,
+ *   data: [],
+ * });
+ * const scope = manager.getScope('contacts');
+ * ```
+ */
+export class DataScopeManager implements DataContext {
+  scopes: Record<string, DataScope> = {};
+  private filters: Record<string, RowLevelFilter[]> = {};
+  private readOnlyScopes: Set<string> = new Set();
+  private listeners: Map<string, Array<(scope: DataScope) => void>> = new Map();
+
+  /**
+   * Register a data scope
+   */
+  registerScope(name: string, scope: DataScope): void {
+    this.scopes[name] = scope;
+    this.notifyListeners(name, scope);
+  }
+
+  /**
+   * Register a data scope with configuration
+   */
+  registerScopeWithConfig(name: string, config: DataScopeConfig): void {
+    const scope: DataScope = {
+      dataSource: config.dataSource,
+      data: config.data,
+      loading: false,
+      error: null,
+    };
+
+    if (config.filters) {
+      this.filters[name] = config.filters;
+    }
+
+    if (config.readOnly) {
+      this.readOnlyScopes.add(name);
+    }
+
+    this.scopes[name] = scope;
+    this.notifyListeners(name, scope);
+  }
+
+  /**
+   * Get a data scope by name
+   */
+  getScope(name: string): DataScope | undefined {
+    return this.scopes[name];
+  }
+
+  /**
+   * Remove a data scope
+   */
+  removeScope(name: string): void {
+    delete this.scopes[name];
+    delete this.filters[name];
+    this.readOnlyScopes.delete(name);
+    this.listeners.delete(name);
+  }
+
+  /**
+   * Check if a scope is read-only
+   */
+  isReadOnly(name: string): boolean {
+    return this.readOnlyScopes.has(name);
+  }
+
+  /**
+   * Get row-level filters for a scope
+   */
+  getFilters(name: string): RowLevelFilter[] {
+    return this.filters[name] || [];
+  }
+
+  /**
+   * Set row-level filters for a scope
+   */
+  setFilters(name: string, filters: RowLevelFilter[]): void {
+    this.filters[name] = filters;
+  }
+
+  /**
+   * Apply row-level filters to a dataset
+   */
+  applyFilters(name: string, data: any[]): any[] {
+    const scopeFilters = this.filters[name];
+    if (!scopeFilters || scopeFilters.length === 0) {
+      return data;
+    }
+
+    return data.filter(row => {
+      return scopeFilters.every(filter => {
+        const fieldValue = row[filter.field];
+        return evaluateFilter(fieldValue, filter.operator, filter.value);
+      });
+    });
+  }
+
+  /**
+   * Update data in a scope
+   */
+  updateScopeData(name: string, data: any): void {
+    const scope = this.scopes[name];
+    if (!scope) return;
+
+    if (this.readOnlyScopes.has(name)) {
+      throw new Error(`Cannot update read-only scope: ${name}`);
+    }
+
+    scope.data = data;
+    this.notifyListeners(name, scope);
+  }
+
+  /**
+   * Update loading state for a scope
+   */
+  updateScopeLoading(name: string, loading: boolean): void {
+    const scope = this.scopes[name];
+    if (!scope) return;
+
+    scope.loading = loading;
+    this.notifyListeners(name, scope);
+  }
+
+  /**
+   * Update error state for a scope
+   */
+  updateScopeError(name: string, error: Error | string | null): void {
+    const scope = this.scopes[name];
+    if (!scope) return;
+
+    scope.error = error;
+    this.notifyListeners(name, scope);
+  }
+
+  /**
+   * Subscribe to scope changes
+   */
+  onScopeChange(name: string, listener: (scope: DataScope) => void): () => void {
+    if (!this.listeners.has(name)) {
+      this.listeners.set(name, []);
+    }
+    this.listeners.get(name)!.push(listener);
+
+    return () => {
+      const arr = this.listeners.get(name);
+      if (arr) {
+        const idx = arr.indexOf(listener);
+        if (idx >= 0) arr.splice(idx, 1);
+      }
+    };
+  }
+
+  /**
+   * Get all registered scope names
+   */
+  getScopeNames(): string[] {
+    return Object.keys(this.scopes);
+  }
+
+  /**
+   * Clear all scopes
+   */
+  clear(): void {
+    this.scopes = {};
+    this.filters = {};
+    this.readOnlyScopes.clear();
+    this.listeners.clear();
+  }
+
+  private notifyListeners(name: string, scope: DataScope): void {
+    const arr = this.listeners.get(name);
+    if (arr) {
+      arr.forEach(listener => listener(scope));
+    }
+  }
+}
+
+/**
+ * Evaluate a single filter condition against a field value
+ */
+function evaluateFilter(fieldValue: any, operator: RowLevelFilter['operator'], filterValue: any): boolean {
+  switch (operator) {
+    case 'eq':
+      return fieldValue === filterValue;
+    case 'ne':
+      return fieldValue !== filterValue;
+    case 'gt':
+      return fieldValue > filterValue;
+    case 'lt':
+      return fieldValue < filterValue;
+    case 'gte':
+      return fieldValue >= filterValue;
+    case 'lte':
+      return fieldValue <= filterValue;
+    case 'in':
+      return Array.isArray(filterValue) && filterValue.includes(fieldValue);
+    case 'nin':
+      return Array.isArray(filterValue) && !filterValue.includes(fieldValue);
+    case 'contains':
+      return typeof fieldValue === 'string' && fieldValue.includes(String(filterValue));
+    default:
+      return true;
+  }
+}
+
+/**
+ * Default DataScopeManager instance
+ */
+export const defaultDataScopeManager = new DataScopeManager();

package/src/data-scope/__tests__/DataScopeManager.test.ts

@@ -0,0 +1,211 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { DataScopeManager } from '../DataScopeManager';
+
+describe('DataScopeManager', () => {
+  describe('Scope Registration', () => {
+    it('should register and retrieve a scope', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('contacts', { data: [{ name: 'Alice' }] });
+      const scope = manager.getScope('contacts');
+      expect(scope).toBeDefined();
+      expect(scope?.data).toEqual([{ name: 'Alice' }]);
+    });
+
+    it('should return undefined for unregistered scope', () => {
+      const manager = new DataScopeManager();
+      expect(manager.getScope('unknown')).toBeUndefined();
+    });
+
+    it('should remove a scope', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      expect(manager.getScope('test')).toBeDefined();
+      manager.removeScope('test');
+      expect(manager.getScope('test')).toBeUndefined();
+    });
+
+    it('should list scope names', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('a', { data: [] });
+      manager.registerScope('b', { data: [] });
+      expect(manager.getScopeNames()).toEqual(['a', 'b']);
+    });
+
+    it('should clear all scopes', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('a', { data: [] });
+      manager.registerScope('b', { data: [] });
+      manager.clear();
+      expect(manager.getScopeNames()).toEqual([]);
+    });
+  });
+
+  describe('Scope Configuration', () => {
+    it('should register scope with config', () => {
+      const manager = new DataScopeManager();
+      manager.registerScopeWithConfig('test', {
+        data: [1, 2, 3],
+        readOnly: true,
+        filters: [{ field: 'status', operator: 'eq', value: 'active' }],
+      });
+
+      expect(manager.getScope('test')?.data).toEqual([1, 2, 3]);
+      expect(manager.isReadOnly('test')).toBe(true);
+      expect(manager.getFilters('test')).toHaveLength(1);
+    });
+
+    it('should throw when updating read-only scope', () => {
+      const manager = new DataScopeManager();
+      manager.registerScopeWithConfig('readonly', { readOnly: true });
+      expect(() => manager.updateScopeData('readonly', [1])).toThrow('Cannot update read-only scope');
+    });
+  });
+
+  describe('Row-Level Filtering', () => {
+    it('should apply eq filter', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.setFilters('test', [{ field: 'status', operator: 'eq', value: 'active' }]);
+
+      const result = manager.applyFilters('test', [
+        { id: 1, status: 'active' },
+        { id: 2, status: 'inactive' },
+        { id: 3, status: 'active' },
+      ]);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe(1);
+      expect(result[1].id).toBe(3);
+    });
+
+    it('should apply gt filter', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.setFilters('test', [{ field: 'age', operator: 'gt', value: 18 }]);
+
+      const result = manager.applyFilters('test', [
+        { name: 'A', age: 15 },
+        { name: 'B', age: 25 },
+        { name: 'C', age: 18 },
+      ]);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('B');
+    });
+
+    it('should apply in filter', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.setFilters('test', [{ field: 'role', operator: 'in', value: ['admin', 'editor'] }]);
+
+      const result = manager.applyFilters('test', [
+        { name: 'A', role: 'admin' },
+        { name: 'B', role: 'viewer' },
+        { name: 'C', role: 'editor' },
+      ]);
+
+      expect(result).toHaveLength(2);
+    });
+
+    it('should apply contains filter', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.setFilters('test', [{ field: 'name', operator: 'contains', value: 'ob' }]);
+
+      const result = manager.applyFilters('test', [
+        { name: 'Bob' },
+        { name: 'Alice' },
+        { name: 'Robert' },
+      ]);
+
+      expect(result).toHaveLength(2);
+    });
+
+    it('should apply multiple filters (AND logic)', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.setFilters('test', [
+        { field: 'status', operator: 'eq', value: 'active' },
+        { field: 'age', operator: 'gte', value: 18 },
+      ]);
+
+      const result = manager.applyFilters('test', [
+        { status: 'active', age: 25 },
+        { status: 'inactive', age: 25 },
+        { status: 'active', age: 15 },
+      ]);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].age).toBe(25);
+    });
+
+    it('should return all data when no filters set', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      const data = [{ a: 1 }, { a: 2 }];
+      expect(manager.applyFilters('test', data)).toEqual(data);
+    });
+  });
+
+  describe('Scope Updates', () => {
+    it('should update scope data', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.updateScopeData('test', [1, 2, 3]);
+      expect(manager.getScope('test')?.data).toEqual([1, 2, 3]);
+    });
+
+    it('should update loading state', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [], loading: false });
+      manager.updateScopeLoading('test', true);
+      expect(manager.getScope('test')?.loading).toBe(true);
+    });
+
+    it('should update error state', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      manager.updateScopeError('test', new Error('fail'));
+      expect(manager.getScope('test')?.error).toBeDefined();
+    });
+  });
+
+  describe('Change Listeners', () => {
+    it('should notify listeners on scope registration', () => {
+      const manager = new DataScopeManager();
+      let notified = false;
+      manager.onScopeChange('test', () => { notified = true; });
+      manager.registerScope('test', { data: [] });
+      expect(notified).toBe(true);
+    });
+
+    it('should notify listeners on data update', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      let newData: any;
+      manager.onScopeChange('test', (scope) => { newData = scope.data; });
+      manager.updateScopeData('test', [1, 2]);
+      expect(newData).toEqual([1, 2]);
+    });
+
+    it('should allow unsubscribing', () => {
+      const manager = new DataScopeManager();
+      manager.registerScope('test', { data: [] });
+      let count = 0;
+      const unsub = manager.onScopeChange('test', () => { count++; });
+      manager.updateScopeData('test', [1]);
+      expect(count).toBe(1);
+      unsub();
+      manager.updateScopeData('test', [2]);
+      expect(count).toBe(1);
+    });
+  });
+});