@object-ui/core 3.1.5 → 3.3.1

package/src/actions/__tests__/UndoManager.test.ts

@@ -1,320 +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.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { UndoManager, type UndoableOperation } from '../UndoManager';
-
-function makeOp(id: string, type: 'create' | 'update' | 'delete' = 'update'): UndoableOperation {
-  return {
-    id,
-    type,
-    objectName: 'Account',
-    recordId: `rec-${id}`,
-    timestamp: Date.now(),
-    description: `op-${id}`,
-    undoData: { prev: id },
-    redoData: { next: id },
-  };
-}
-
-describe('UndoManager', () => {
-  let manager: UndoManager;
-
-  beforeEach(() => {
-    manager = new UndoManager({ maxHistory: 5 });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Basic push / pop (existing behaviour)
-  // ---------------------------------------------------------------------------
-  describe('basic push/pop', () => {
-    it('pushes and peeks', () => {
-      const op = makeOp('1');
-      manager.push(op);
-      expect(manager.canUndo).toBe(true);
-      expect(manager.peekUndo()).toEqual(op);
-      expect(manager.undoCount).toBe(1);
-    });
-
-    it('popUndo moves to redo stack', () => {
-      const op = makeOp('1');
-      manager.push(op);
-      const popped = manager.popUndo();
-      expect(popped).toEqual(op);
-      expect(manager.canUndo).toBe(false);
-      expect(manager.canRedo).toBe(true);
-      expect(manager.peekRedo()).toEqual(op);
-    });
-
-    it('popRedo moves back to undo stack', () => {
-      manager.push(makeOp('1'));
-      manager.popUndo();
-      const redone = manager.popRedo();
-      expect(redone?.id).toBe('1');
-      expect(manager.canUndo).toBe(true);
-      expect(manager.canRedo).toBe(false);
-    });
-
-    it('push clears redo stack', () => {
-      manager.push(makeOp('1'));
-      manager.popUndo();
-      expect(manager.canRedo).toBe(true);
-      manager.push(makeOp('2'));
-      expect(manager.canRedo).toBe(false);
-    });
-
-    it('trims beyond maxHistory', () => {
-      for (let i = 0; i < 7; i++) manager.push(makeOp(String(i)));
-      expect(manager.undoCount).toBe(5);
-      // Oldest operations should have been shifted out
-      expect(manager.getHistory()[0].id).toBe('2');
-    });
-
-    it('clear removes everything', () => {
-      manager.push(makeOp('1'));
-      manager.clear();
-      expect(manager.canUndo).toBe(false);
-      expect(manager.canRedo).toBe(false);
-    });
-
-    it('subscribe notifies on changes', () => {
-      const listener = vi.fn();
-      const unsub = manager.subscribe(listener);
-      manager.push(makeOp('1'));
-      expect(listener).toHaveBeenCalledTimes(1);
-      unsub();
-      manager.push(makeOp('2'));
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // pushBatch
-  // ---------------------------------------------------------------------------
-  describe('pushBatch', () => {
-    it('pushes multiple operations atomically', () => {
-      const ops = [makeOp('a'), makeOp('b'), makeOp('c')];
-      manager.pushBatch(ops);
-      expect(manager.undoCount).toBe(3);
-      expect(manager.getHistory().map((o) => o.id)).toEqual(['a', 'b', 'c']);
-    });
-
-    it('clears redo stack', () => {
-      manager.push(makeOp('1'));
-      manager.popUndo();
-      expect(manager.canRedo).toBe(true);
-      manager.pushBatch([makeOp('x')]);
-      expect(manager.canRedo).toBe(false);
-    });
-
-    it('notifies listeners exactly once', () => {
-      const listener = vi.fn();
-      manager.subscribe(listener);
-      manager.pushBatch([makeOp('a'), makeOp('b')]);
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-
-    it('is a no-op for empty array', () => {
-      const listener = vi.fn();
-      manager.subscribe(listener);
-      manager.pushBatch([]);
-      expect(listener).not.toHaveBeenCalled();
-      expect(manager.undoCount).toBe(0);
-    });
-
-    it('trims to maxHistory when batch exceeds limit', () => {
-      const ops = Array.from({ length: 8 }, (_, i) => makeOp(String(i)));
-      manager.pushBatch(ops);
-      expect(manager.undoCount).toBe(5);
-      // Oldest should be trimmed
-      expect(manager.getHistory()[0].id).toBe('3');
-      expect(manager.getHistory()[4].id).toBe('7');
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // popUndoBatch / popRedoBatch
-  // ---------------------------------------------------------------------------
-  describe('popUndoBatch', () => {
-    it('pops multiple operations from undo to redo', () => {
-      manager.pushBatch([makeOp('a'), makeOp('b'), makeOp('c')]);
-      const popped = manager.popUndoBatch(2);
-      expect(popped.map((o) => o.id)).toEqual(['b', 'c']);
-      expect(manager.undoCount).toBe(1);
-      expect(manager.redoCount).toBe(2);
-    });
-
-    it('clamps to available stack size', () => {
-      manager.push(makeOp('1'));
-      const popped = manager.popUndoBatch(10);
-      expect(popped).toHaveLength(1);
-      expect(manager.undoCount).toBe(0);
-    });
-
-    it('returns empty array when nothing to undo', () => {
-      expect(manager.popUndoBatch(3)).toEqual([]);
-    });
-
-    it('notifies listeners once', () => {
-      manager.pushBatch([makeOp('a'), makeOp('b')]);
-      const listener = vi.fn();
-      manager.subscribe(listener);
-      manager.popUndoBatch(2);
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('popRedoBatch', () => {
-    it('pops multiple operations from redo to undo', () => {
-      manager.pushBatch([makeOp('a'), makeOp('b'), makeOp('c')]);
-      manager.popUndoBatch(3);
-      expect(manager.redoCount).toBe(3);
-      const redone = manager.popRedoBatch(2);
-      expect(redone.map((o) => o.id)).toEqual(['b', 'c']);
-      expect(manager.undoCount).toBe(2);
-      expect(manager.redoCount).toBe(1);
-    });
-
-    it('clamps to available stack size', () => {
-      manager.push(makeOp('1'));
-      manager.popUndo();
-      const redone = manager.popRedoBatch(5);
-      expect(redone).toHaveLength(1);
-    });
-
-    it('returns empty array when nothing to redo', () => {
-      expect(manager.popRedoBatch(3)).toEqual([]);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // getHistory / getRedoHistory
-  // ---------------------------------------------------------------------------
-  describe('getHistory / getRedoHistory', () => {
-    it('getHistory returns shallow copy of undo stack', () => {
-      manager.push(makeOp('1'));
-      manager.push(makeOp('2'));
-      const history = manager.getHistory();
-      expect(history).toHaveLength(2);
-      // Mutating the copy must not affect the manager
-      history.pop();
-      expect(manager.undoCount).toBe(2);
-    });
-
-    it('getRedoHistory returns shallow copy of redo stack', () => {
-      manager.push(makeOp('1'));
-      manager.push(makeOp('2'));
-      manager.popUndo();
-      const redoHistory = manager.getRedoHistory();
-      expect(redoHistory).toHaveLength(1);
-      expect(redoHistory[0].id).toBe('2');
-      // Mutating the copy must not affect the manager
-      redoHistory.pop();
-      expect(manager.redoCount).toBe(1);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // saveToStorage / loadFromStorage
-  // ---------------------------------------------------------------------------
-  describe('persistence', () => {
-    let storage: Record<string, string>;
-
-    beforeEach(() => {
-      storage = {};
-      vi.stubGlobal('localStorage', {
-        getItem: vi.fn((key: string) => storage[key] ?? null),
-        setItem: vi.fn((key: string, value: string) => { storage[key] = value; }),
-        removeItem: vi.fn((key: string) => { delete storage[key]; }),
-      });
-    });
-
-    it('round-trips undo/redo stacks through localStorage', () => {
-      manager.push(makeOp('1'));
-      manager.push(makeOp('2'));
-      manager.popUndo(); // '2' goes to redo
-
-      manager.saveToStorage();
-
-      const fresh = new UndoManager({ maxHistory: 5 });
-      fresh.loadFromStorage();
-
-      expect(fresh.undoCount).toBe(1);
-      expect(fresh.redoCount).toBe(1);
-      expect(fresh.peekUndo()?.id).toBe('1');
-      expect(fresh.peekRedo()?.id).toBe('2');
-    });
-
-    it('preserves all UndoableOperation fields', () => {
-      const op = makeOp('full');
-      manager.push(op);
-      manager.saveToStorage();
-
-      const fresh = new UndoManager();
-      fresh.loadFromStorage();
-      const restored = fresh.peekUndo()!;
-      expect(restored.id).toBe(op.id);
-      expect(restored.type).toBe(op.type);
-      expect(restored.objectName).toBe(op.objectName);
-      expect(restored.recordId).toBe(op.recordId);
-      expect(restored.timestamp).toBe(op.timestamp);
-      expect(restored.description).toBe(op.description);
-      expect(restored.undoData).toEqual(op.undoData);
-      expect(restored.redoData).toEqual(op.redoData);
-    });
-
-    it('is a no-op when localStorage has no data', () => {
-      const fresh = new UndoManager();
-      fresh.loadFromStorage();
-      expect(fresh.undoCount).toBe(0);
-      expect(fresh.redoCount).toBe(0);
-    });
-
-    it('handles corrupt localStorage data gracefully', () => {
-      storage['objectui:undo-history'] = 'not-valid-json!!!';
-      const fresh = new UndoManager();
-      expect(() => fresh.loadFromStorage()).not.toThrow();
-      expect(fresh.undoCount).toBe(0);
-    });
-
-    it('notifies listeners after loading', () => {
-      manager.push(makeOp('1'));
-      manager.saveToStorage();
-
-      const fresh = new UndoManager();
-      const listener = vi.fn();
-      fresh.subscribe(listener);
-      fresh.loadFromStorage();
-      expect(listener).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Boundary: batch larger than maxHistory
-  // ---------------------------------------------------------------------------
-  describe('boundary: batch larger than maxHistory', () => {
-    it('trims oldest entries when batch overflows maxHistory', () => {
-      // maxHistory is 5
-      manager.push(makeOp('existing'));
-      const batch = Array.from({ length: 6 }, (_, i) => makeOp(`batch-${i}`));
-      manager.pushBatch(batch);
-      expect(manager.undoCount).toBe(5);
-      // 1 existing + 6 batch = 7 total, trimmed to last 5
-      const ids = manager.getHistory().map((o) => o.id);
-      expect(ids).toEqual(['batch-1', 'batch-2', 'batch-3', 'batch-4', 'batch-5']);
-    });
-
-    it('works when batch itself equals maxHistory', () => {
-      const batch = Array.from({ length: 5 }, (_, i) => makeOp(`b-${i}`));
-      manager.pushBatch(batch);
-      expect(manager.undoCount).toBe(5);
-      expect(manager.getHistory()[0].id).toBe('b-0');
-      expect(manager.getHistory()[4].id).toBe('b-4');
-    });
-  });
-});

package/src/actions/index.ts

@@ -1,12 +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.
- */
-
-export * from './ActionRunner.js';
-export * from './ActionEngine.js';
-export * from './TransactionManager.js';
-export * from './UndoManager.js';

package/src/adapters/ApiDataSource.ts

@@ -1,376 +0,0 @@
-/**
- * ObjectUI — ApiDataSource
- * 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.
- *
- * A DataSource adapter for the `provider: 'api'` ViewData mode.
- * Makes raw HTTP requests using the HttpRequest configs from ViewData.
- */
-
-import type {
-  DataSource,
-  QueryParams,
-  QueryResult,
-  HttpRequest,
-  HttpMethod,
-  AggregateParams,
-  AggregateResult,
-} from '@object-ui/types';
-
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-
-export interface ApiDataSourceConfig {
-  /** HttpRequest config for read operations (find, findOne) */
-  read?: HttpRequest;
-  /** HttpRequest config for write operations (create, update, delete) */
-  write?: HttpRequest;
-  /** Custom fetch implementation (defaults to globalThis.fetch) */
-  fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-  /** Default headers applied to all requests */
-  defaultHeaders?: Record<string, string>;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Build a full URL with query params */
-function buildUrl(
-  base: string,
-  pathSuffix?: string,
-  queryParams?: Record<string, unknown>,
-): string {
-  let url = base;
-  if (pathSuffix) {
-    url = url.replace(/\/+$/, '') + '/' + pathSuffix.replace(/^\/+/, '');
-  }
-
-  if (queryParams && Object.keys(queryParams).length > 0) {
-    const search = new URLSearchParams();
-    for (const [key, value] of Object.entries(queryParams)) {
-      if (value !== undefined && value !== null) {
-        search.set(key, String(value));
-      }
-    }
-    const qs = search.toString();
-    if (qs) {
-      url += (url.includes('?') ? '&' : '?') + qs;
-    }
-  }
-
-  return url;
-}
-
-/** Convert QueryParams to flat query string params */
-function queryParamsToRecord(params?: QueryParams): Record<string, unknown> {
-  if (!params) return {};
-
-  const out: Record<string, unknown> = {};
-
-  if (params.$select?.length) {
-    out.$select = params.$select.join(',');
-  }
-  if (params.$filter && Object.keys(params.$filter).length > 0) {
-    out.$filter = JSON.stringify(params.$filter);
-  }
-  if (params.$orderby) {
-    if (Array.isArray(params.$orderby)) {
-      if (typeof params.$orderby[0] === 'string') {
-        out.$orderby = (params.$orderby as string[]).join(',');
-      } else {
-        out.$orderby = (params.$orderby as Array<{ field: string; order?: string }>)
-          .map((s) => `${s.field} ${s.order || 'asc'}`)
-          .join(',');
-      }
-    } else {
-      out.$orderby = Object.entries(params.$orderby)
-        .map(([field, order]) => `${field} ${order}`)
-        .join(',');
-    }
-  }
-  if (params.$skip !== undefined) out.$skip = params.$skip;
-  if (params.$top !== undefined) out.$top = params.$top;
-  if (params.$expand?.length) out.$expand = params.$expand.join(',');
-  if (params.$search) out.$search = params.$search;
-  if (params.$count) out.$count = 'true';
-
-  return out;
-}
-
-/** Merge two header objects, giving priority to the second */
-function mergeHeaders(
-  base?: Record<string, string>,
-  override?: Record<string, string>,
-): Record<string, string> {
-  return { ...base, ...override };
-}
-
-// ---------------------------------------------------------------------------
-// ApiDataSource
-// ---------------------------------------------------------------------------
-
-/**
- * ApiDataSource — a DataSource adapter for raw HTTP APIs.
- *
- * Used when `ViewData.provider === 'api'`. The read and write HttpRequest
- * configs define the endpoints; all CRUD methods map onto HTTP verbs.
- *
- * Read operations use the `read` config, write operations use the `write` config.
- * Both fall back to each other when one is not provided.
- *
- * @example
- * ```ts
- * const ds = new ApiDataSource({
- *   read:  { url: '/api/contacts', method: 'GET' },
- *   write: { url: '/api/contacts', method: 'POST' },
- * });
- *
- * const result = await ds.find('contacts', { $top: 10 });
- * ```
- */
-export class ApiDataSource<T = any> implements DataSource<T> {
-  private readConfig: HttpRequest | undefined;
-  private writeConfig: HttpRequest | undefined;
-  private fetchFn: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-  private defaultHeaders: Record<string, string>;
-
-  constructor(config: ApiDataSourceConfig) {
-    this.readConfig = config.read;
-    this.writeConfig = config.write;
-    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
-    this.defaultHeaders = config.defaultHeaders ?? {};
-  }
-
-  // -----------------------------------------------------------------------
-  // Internal request executor
-  // -----------------------------------------------------------------------
-
-  private async request<R = any>(
-    base: HttpRequest | undefined,
-    options: {
-      pathSuffix?: string;
-      method?: HttpMethod;
-      queryParams?: Record<string, unknown>;
-      body?: unknown;
-      headers?: Record<string, string>;
-    } = {},
-  ): Promise<R> {
-    if (!base) {
-      throw new Error(
-        'ApiDataSource: No HTTP configuration provided for this operation. ' +
-          'Ensure the ViewData has read/write configs.',
-      );
-    }
-
-    const method = options.method ?? base.method ?? 'GET';
-
-    // Merge query params: base.params + extra queryParams
-    const allQuery = {
-      ...(base.params as Record<string, unknown> | undefined),
-      ...options.queryParams,
-    };
-
-    const url = buildUrl(base.url, options.pathSuffix, allQuery);
-
-    const headers = mergeHeaders(
-      mergeHeaders(this.defaultHeaders, base.headers),
-      options.headers,
-    );
-
-    const init: RequestInit = {
-      method,
-      headers,
-    };
-
-    // Attach body for non-GET methods
-    if (options.body !== undefined && method !== 'GET') {
-      if (
-        options.body instanceof FormData ||
-        options.body instanceof Blob
-      ) {
-        init.body = options.body as FormData | Blob;
-      } else if (typeof options.body === 'string') {
-        init.body = options.body;
-        if (!headers['Content-Type']) {
-          headers['Content-Type'] = 'text/plain';
-        }
-      } else {
-        init.body = JSON.stringify(options.body);
-        if (!headers['Content-Type']) {
-          headers['Content-Type'] = 'application/json';
-        }
-      }
-    }
-
-    const response = await this.fetchFn(url, init);
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(
-        `ApiDataSource: HTTP ${response.status} ${response.statusText} — ${text}`,
-      );
-    }
-
-    // Try to parse as JSON; fall back to empty object
-    const contentType = response.headers.get('content-type') ?? '';
-    if (contentType.includes('application/json')) {
-      return response.json();
-    }
-
-    // Non-JSON response — return text wrapped in an object
-    const text = await response.text();
-    return text as unknown as R;
-  }
-
-  // -----------------------------------------------------------------------
-  // DataSource interface
-  // -----------------------------------------------------------------------
-
-  async find(_resource: string, params?: QueryParams): Promise<QueryResult<T>> {
-    const queryParams = queryParamsToRecord(params);
-    const raw = await this.request<any>(this.readConfig, {
-      method: 'GET',
-      queryParams,
-    });
-
-    // Normalize: the API might return an array, an object with `data`, or a QueryResult
-    return this.normalizeQueryResult(raw);
-  }
-
-  async findOne(_resource: string, id: string | number, params?: QueryParams): Promise<T | null> {
-    try {
-      const queryParams = queryParamsToRecord(params);
-      const raw = await this.request<T>(this.readConfig, {
-        pathSuffix: String(id),
-        method: 'GET',
-        queryParams,
-      });
-      return raw ?? null;
-    } catch {
-      return null;
-    }
-  }
-
-  async create(_resource: string, data: Partial<T>): Promise<T> {
-    const config = this.writeConfig ?? this.readConfig;
-    return this.request<T>(config, {
-      method: 'POST',
-      body: data,
-    });
-  }
-
-  async update(_resource: string, id: string | number, data: Partial<T>): Promise<T> {
-    const config = this.writeConfig ?? this.readConfig;
-    return this.request<T>(config, {
-      pathSuffix: String(id),
-      method: 'PATCH',
-      body: data,
-    });
-  }
-
-  async delete(_resource: string, id: string | number): Promise<boolean> {
-    const config = this.writeConfig ?? this.readConfig;
-    try {
-      await this.request(config, {
-        pathSuffix: String(id),
-        method: 'DELETE',
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async getObjectSchema(_objectName: string): Promise<any> {
-    // Generic API endpoints typically don't expose schema metadata.
-    // Return a minimal stub so schema-dependent components don't crash.
-    return { name: _objectName, fields: {} };
-  }
-
-  async getView(_objectName: string, _viewId: string): Promise<any | null> {
-    return null;
-  }
-
-  async getApp(_appId: string): Promise<any | null> {
-    return null;
-  }
-
-  async aggregate(_resource: string, params: AggregateParams): Promise<AggregateResult[]> {
-    const queryParams: Record<string, unknown> = {
-      field: params.field,
-      function: params.function,
-      groupBy: params.groupBy,
-    };
-    if (params.filter) {
-      queryParams.filter = typeof params.filter === 'string'
-        ? params.filter
-        : JSON.stringify(params.filter);
-    }
-
-    const raw = await this.request<any>(this.readConfig, {
-      pathSuffix: 'aggregate',
-      method: 'GET',
-      queryParams,
-    });
-
-    // Normalize: the API might return an array or an object with data/results
-    if (Array.isArray(raw)) return raw;
-    if (raw?.data && Array.isArray(raw.data)) return raw.data;
-    if (raw?.results && Array.isArray(raw.results)) return raw.results;
-    return [];
-  }
-
-  // -----------------------------------------------------------------------
-  // Helpers
-  // -----------------------------------------------------------------------
-
-  /**
-   * Normalize various API response shapes into a QueryResult.
-   *
-   * Supported shapes:
-   * - `T[]`                      → wrap in QueryResult
-   * - `{ data: T[] }`            → extract data
-   * - `{ items: T[] }`           → extract items
-   * - `{ results: T[] }`         → extract results
-   * - `{ records: T[] }`         → extract records (Salesforce-style)
-   * - `{ value: T[] }`           → extract value (OData-style)
-   * - Full QueryResult (has data + totalCount) → return as-is
-   */
-  private normalizeQueryResult(raw: any): QueryResult<T> {
-    if (Array.isArray(raw)) {
-      return { data: raw, total: raw.length };
-    }
-
-    if (raw && typeof raw === 'object') {
-      // Already a QueryResult
-      if (Array.isArray(raw.data) && ('total' in raw || 'totalCount' in raw)) {
-        return {
-          data: raw.data,
-          total: raw.total ?? raw.totalCount ?? raw.data.length,
-          hasMore: raw.hasMore,
-          cursor: raw.cursor,
-        };
-      }
-
-      // Common envelope patterns
-      for (const key of ['data', 'items', 'results', 'records', 'value']) {
-        if (Array.isArray(raw[key])) {
-          return {
-            data: raw[key],
-            total: raw.total ?? raw.totalCount ?? raw.count ?? raw[key].length,
-            hasMore: raw.hasMore ?? raw.hasNextPage,
-          };
-        }
-      }
-
-      // Single-object response — wrap as array
-      return { data: [raw as T], total: 1 };
-    }
-
-    return { data: [], total: 0 };
-  }
-}