@object-ui/core 3.1.5 → 3.3.1

package/src/data-scope/DataScopeManager.ts

@@ -1,269 +0,0 @@
-/**
- * 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/ViewDataProvider.ts

@@ -1,282 +0,0 @@
-/**
- * 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 - View Data Provider
- *
- * Resolves @objectstack/spec ViewData discriminated union into
- * a unified data access interface. Supports three data modes:
- *
- * 1. 'object' — Metadata-driven via ObjectStack API (object name → fields/records)
- * 2. 'api' — Custom REST API endpoints (read/write URLs)
- * 3. 'value' — Static data (pre-loaded items array)
- *
- * @module data-scope
- * @packageDocumentation
- */
-
-/** ViewData union — matches @objectstack/spec ViewDataSchema */
-export type ViewDataConfig =
-  | { provider: 'object'; object: string }
-  | {
-      provider: 'api';
-      read: { url: string; method?: string; headers?: Record<string, string> };
-      write?: { url: string; method?: string; headers?: Record<string, string> };
-    }
-  | { provider: 'value'; items: any[] };
-
-/** Element-level data source — matches @objectstack/spec ElementDataSourceSchema */
-export interface ElementDataSourceConfig {
-  object: string;
-  view?: string;
-  filter?: Record<string, any>;
-  sort?: Array<{ field: string; order: 'asc' | 'desc' }>;
-  limit?: number;
-}
-
-/** Fetcher interface — consumers provide the actual fetch implementation */
-export interface DataFetcher {
-  /** Fetch records for an object */
-  fetchRecords(
-    object: string,
-    options?: {
-      filter?: Record<string, any>;
-      sort?: Array<{ field: string; order: 'asc' | 'desc' }>;
-      limit?: number;
-      offset?: number;
-      fields?: string[];
-    },
-  ): Promise<{ records: any[]; total: number }>;
-
-  /** Fetch object metadata (fields, etc.) */
-  fetchMetadata?(object: string): Promise<{
-    name: string;
-    label?: string;
-    fields: Array<{
-      name: string;
-      label?: string;
-      type: string;
-      required?: boolean;
-    }>;
-  }>;
-
-  /** Fetch from a custom API URL */
-  fetchUrl?(
-    url: string,
-    options?: {
-      method?: string;
-      headers?: Record<string, string>;
-      body?: any;
-    },
-  ): Promise<any>;
-}
-
-/** Resolved data result */
-export interface ResolvedData {
-  /** Data records */
-  records: any[];
-  /** Total record count (for pagination) */
-  total: number;
-  /** Object metadata (if available) */
-  metadata?: {
-    name: string;
-    label?: string;
-    fields: Array<{
-      name: string;
-      label?: string;
-      type: string;
-      required?: boolean;
-    }>;
-  };
-  /** Provider type */
-  provider: 'object' | 'api' | 'value';
-  /** Loading state */
-  loading: boolean;
-  /** Error */
-  error?: string;
-}
-
-/** Extract records array from various common API response shapes */
-function extractRecords(data: any): any[] {
-  if (Array.isArray(data)) return data;
-  if (Array.isArray(data?.records)) return data.records;
-  if (Array.isArray(data?.data)) return data.data;
-  if (Array.isArray(data?.items)) return data.items;
-  return [];
-}
-
-/**
- * Resolves ViewData configuration into actual data via a pluggable fetcher.
- *
- * @example
- * ```ts
- * const provider = new ViewDataProvider(myFetcher);
- * const data = await provider.resolve({ provider: 'object', object: 'Account' });
- * ```
- */
-export class ViewDataProvider {
-  private fetcher: DataFetcher | null = null;
-
-  constructor(fetcher?: DataFetcher) {
-    this.fetcher = fetcher ?? null;
-  }
-
-  /** Set the data fetcher implementation */
-  setFetcher(fetcher: DataFetcher): void {
-    this.fetcher = fetcher;
-  }
-
-  /** Resolve ViewData config into actual data */
-  async resolve(
-    config: ViewDataConfig,
-    options?: {
-      filter?: Record<string, any>;
-      sort?: Array<{ field: string; order: 'asc' | 'desc' }>;
-      limit?: number;
-      offset?: number;
-      fields?: string[];
-    },
-  ): Promise<ResolvedData> {
-    switch (config.provider) {
-      case 'value':
-        return this.resolveValue(config);
-      case 'api':
-        return this.resolveApi(config);
-      case 'object':
-        return this.resolveObject(config, options);
-      default:
-        return {
-          records: [],
-          total: 0,
-          provider: 'value' as const,
-          loading: false,
-          error: `Unknown data provider: ${(config as any).provider}`,
-        };
-    }
-  }
-
-  /** Resolve static value data */
-  private resolveValue(config: {
-    provider: 'value';
-    items: any[];
-  }): ResolvedData {
-    const items = Array.isArray(config.items) ? config.items : [];
-    return {
-      records: items,
-      total: items.length,
-      provider: 'value',
-      loading: false,
-    };
-  }
-
-  /** Resolve API-based data */
-  private async resolveApi(config: {
-    provider: 'api';
-    read: { url: string; method?: string; headers?: Record<string, string> };
-  }): Promise<ResolvedData> {
-    if (!this.fetcher?.fetchUrl) {
-      return {
-        records: [],
-        total: 0,
-        provider: 'api',
-        loading: false,
-        error: 'No fetchUrl implementation available for API data provider',
-      };
-    }
-
-    try {
-      const data = await this.fetcher.fetchUrl(config.read.url, {
-        method: config.read.method,
-        headers: config.read.headers,
-      });
-
-      // Handle common response shapes
-      const records = extractRecords(data);
-      const total = data?.total ?? data?.count ?? records.length;
-
-      return {
-        records,
-        total,
-        provider: 'api',
-        loading: false,
-      };
-    } catch (error) {
-      return {
-        records: [],
-        total: 0,
-        provider: 'api',
-        loading: false,
-        error: (error as Error).message,
-      };
-    }
-  }
-
-  /** Resolve object-based data (metadata-driven) */
-  private async resolveObject(
-    config: { provider: 'object'; object: string },
-    options?: {
-      filter?: Record<string, any>;
-      sort?: Array<{ field: string; order: 'asc' | 'desc' }>;
-      limit?: number;
-      offset?: number;
-      fields?: string[];
-    },
-  ): Promise<ResolvedData> {
-    if (!this.fetcher) {
-      return {
-        records: [],
-        total: 0,
-        provider: 'object',
-        loading: false,
-        error: 'No data fetcher configured for object data provider',
-      };
-    }
-
-    try {
-      // Fetch metadata if available
-      let metadata: ResolvedData['metadata'];
-      if (this.fetcher.fetchMetadata) {
-        metadata = await this.fetcher.fetchMetadata(config.object);
-      }
-
-      // Fetch records
-      const result = await this.fetcher.fetchRecords(config.object, options);
-
-      return {
-        records: result.records,
-        total: result.total,
-        metadata,
-        provider: 'object',
-        loading: false,
-      };
-    } catch (error) {
-      return {
-        records: [],
-        total: 0,
-        provider: 'object',
-        loading: false,
-        error: (error as Error).message,
-      };
-    }
-  }
-
-  /** Resolve element-level data source */
-  async resolveElementDataSource(
-    config: ElementDataSourceConfig,
-  ): Promise<ResolvedData> {
-    return this.resolve(
-      { provider: 'object', object: config.object },
-      {
-        filter: config.filter,
-        sort: config.sort,
-        limit: config.limit,
-      },
-    );
-  }
-
-}