@object-ui/core 0.3.1 → 2.0.0

package/src/adapters/__tests__/ValueDataSource.test.ts

@@ -0,0 +1,325 @@
+/**
+ * ObjectUI — ValueDataSource Tests
+ * 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 { ValueDataSource } from '../ValueDataSource';
+
+const sampleData = [
+  { _id: '1', name: 'Alice', age: 30, role: 'admin' },
+  { _id: '2', name: 'Bob', age: 25, role: 'user' },
+  { _id: '3', name: 'Charlie', age: 35, role: 'admin' },
+  { _id: '4', name: 'Diana', age: 28, role: 'user' },
+  { _id: '5', name: 'Eve', age: 22, role: 'guest' },
+];
+
+function createDS() {
+  return new ValueDataSource({ items: sampleData });
+}
+
+// ---------------------------------------------------------------------------
+// find
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — find', () => {
+  it('should return all items with no params', async () => {
+    const ds = createDS();
+    const result = await ds.find('users');
+    expect(result.data).toHaveLength(5);
+    expect(result.total).toBe(5);
+  });
+
+  it('should filter by equality', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $filter: { role: 'admin' } });
+    expect(result.data).toHaveLength(2);
+    expect(result.data.every((r: any) => r.role === 'admin')).toBe(true);
+    expect(result.total).toBe(2);
+  });
+
+  it('should filter with $gt operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $filter: { age: { $gt: 28 } } });
+    expect(result.data).toHaveLength(2);
+    expect(result.data.map((r: any) => r.name).sort()).toEqual(['Alice', 'Charlie']);
+  });
+
+  it('should filter with $gte operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $filter: { age: { $gte: 28 } } });
+    expect(result.data).toHaveLength(3);
+  });
+
+  it('should filter with $lt operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $filter: { age: { $lt: 25 } } });
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0].name).toBe('Eve');
+  });
+
+  it('should filter with $ne operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $filter: { role: { $ne: 'admin' } } });
+    expect(result.data).toHaveLength(3);
+  });
+
+  it('should filter with $in operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', {
+      $filter: { role: { $in: ['admin', 'guest'] } },
+    });
+    expect(result.data).toHaveLength(3);
+  });
+
+  it('should filter with $contains operator', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', {
+      $filter: { name: { $contains: 'ali' } },
+    });
+    expect(result.data).toHaveLength(1); // Alice only ('ali' is not in 'Charlie')
+  });
+
+  it('should sort ascending by Record format', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $orderby: { name: 'asc' } });
+    const names = result.data.map((r: any) => r.name);
+    expect(names).toEqual(['Alice', 'Bob', 'Charlie', 'Diana', 'Eve']);
+  });
+
+  it('should sort descending by Record format', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $orderby: { age: 'desc' } });
+    expect(result.data[0].name).toBe('Charlie');
+    expect(result.data[4].name).toBe('Eve');
+  });
+
+  it('should sort by string array format', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $orderby: ['-age'] });
+    expect(result.data[0].name).toBe('Charlie');
+  });
+
+  it('should sort by object array format', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', {
+      $orderby: [{ field: 'age', order: 'asc' }],
+    });
+    expect(result.data[0].name).toBe('Eve');
+    expect(result.data[4].name).toBe('Charlie');
+  });
+
+  it('should paginate with $skip and $top', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $skip: 2, $top: 2 });
+    expect(result.data).toHaveLength(2);
+    expect(result.total).toBe(5); // total before pagination
+    expect(result.hasMore).toBe(true);
+  });
+
+  it('should return hasMore=false when all items returned', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $top: 10 });
+    expect(result.hasMore).toBe(false);
+  });
+
+  it('should select specific fields', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $select: ['name', 'age'] });
+    const first = result.data[0] as any;
+    expect(first.name).toBeDefined();
+    expect(first.age).toBeDefined();
+    expect(first._id).toBeUndefined();
+    expect(first.role).toBeUndefined();
+  });
+
+  it('should search across string fields', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', { $search: 'bob' });
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0].name).toBe('Bob');
+  });
+
+  it('should combine filter + sort + pagination', async () => {
+    const ds = createDS();
+    const result = await ds.find('users', {
+      $filter: { role: 'user' },
+      $orderby: { age: 'asc' },
+      $top: 1,
+    });
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0].name).toBe('Bob'); // youngest user
+    expect(result.total).toBe(2); // 2 users total
+    expect(result.hasMore).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// findOne
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — findOne', () => {
+  it('should find a record by _id', async () => {
+    const ds = createDS();
+    const record = await ds.findOne('users', '3');
+    expect(record).not.toBeNull();
+    expect((record as any).name).toBe('Charlie');
+  });
+
+  it('should return null for missing id', async () => {
+    const ds = createDS();
+    const record = await ds.findOne('users', '999');
+    expect(record).toBeNull();
+  });
+
+  it('should use custom idField', async () => {
+    const ds = new ValueDataSource({
+      items: [{ code: 'A', label: 'Alpha' }],
+      idField: 'code',
+    });
+    const record = await ds.findOne('items', 'A');
+    expect(record).not.toBeNull();
+    expect((record as any).label).toBe('Alpha');
+  });
+
+  it('should select fields on findOne', async () => {
+    const ds = createDS();
+    const record = await ds.findOne('users', '1', { $select: ['name'] });
+    expect(record).not.toBeNull();
+    expect((record as any).name).toBe('Alice');
+    expect((record as any).age).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — create', () => {
+  it('should add a record to the collection', async () => {
+    const ds = createDS();
+    const created = await ds.create('users', { name: 'Frank', age: 40, role: 'user' });
+    expect((created as any).name).toBe('Frank');
+    expect(ds.count).toBe(6);
+  });
+
+  it('should auto-generate an ID if missing', async () => {
+    const ds = createDS();
+    const created = await ds.create('users', { name: 'Grace' });
+    expect((created as any)._id).toBeDefined();
+    expect(String((created as any)._id).startsWith('auto_')).toBe(true);
+  });
+
+  it('should preserve existing ID', async () => {
+    const ds = createDS();
+    const created = await ds.create('users', { _id: 'custom-id', name: 'Heidi' });
+    expect((created as any)._id).toBe('custom-id');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — update', () => {
+  it('should update an existing record', async () => {
+    const ds = createDS();
+    const updated = await ds.update('users', '1', { age: 31 });
+    expect((updated as any).age).toBe(31);
+    expect((updated as any).name).toBe('Alice');
+  });
+
+  it('should throw for non-existent record', async () => {
+    const ds = createDS();
+    await expect(ds.update('users', '999', { age: 50 })).rejects.toThrow(
+      'Record with id "999" not found',
+    );
+  });
+
+  it('should persist updates in subsequent finds', async () => {
+    const ds = createDS();
+    await ds.update('users', '2', { name: 'Bobby' });
+    const result = await ds.findOne('users', '2');
+    expect((result as any).name).toBe('Bobby');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// delete
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — delete', () => {
+  it('should remove a record', async () => {
+    const ds = createDS();
+    const ok = await ds.delete('users', '1');
+    expect(ok).toBe(true);
+    expect(ds.count).toBe(4);
+  });
+
+  it('should return false for non-existent record', async () => {
+    const ds = createDS();
+    const ok = await ds.delete('users', '999');
+    expect(ok).toBe(false);
+    expect(ds.count).toBe(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// bulk
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — bulk', () => {
+  it('should bulk create records', async () => {
+    const ds = createDS();
+    const results = await ds.bulk!('users', 'create', [
+      { name: 'X', age: 10 },
+      { name: 'Y', age: 20 },
+    ]);
+    expect(results).toHaveLength(2);
+    expect(ds.count).toBe(7);
+  });
+
+  it('should bulk delete records', async () => {
+    const ds = createDS();
+    await ds.bulk!('users', 'delete', [{ _id: '1' }, { _id: '2' }]);
+    expect(ds.count).toBe(3);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getObjectSchema
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — getObjectSchema', () => {
+  it('should infer schema from first item', async () => {
+    const ds = createDS();
+    const schema = await ds.getObjectSchema('users');
+    expect(schema.name).toBe('users');
+    expect(schema.fields._id).toBeDefined();
+    expect(schema.fields.name.type).toBe('string');
+    expect(schema.fields.age.type).toBe('number');
+  });
+
+  it('should return empty fields for empty dataset', async () => {
+    const ds = new ValueDataSource({ items: [] });
+    const schema = await ds.getObjectSchema('empty');
+    expect(schema.fields).toEqual({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Isolation
+// ---------------------------------------------------------------------------
+
+describe('ValueDataSource — isolation', () => {
+  it('should not mutate the original items array', async () => {
+    const original = [{ _id: '1', name: 'Test' }];
+    const ds = new ValueDataSource({ items: original });
+    await ds.create('x', { name: 'New' });
+    expect(original).toHaveLength(1); // original untouched
+    expect(ds.count).toBe(2);
+  });
+});

package/src/adapters/__tests__/resolveDataSource.test.ts

@@ -0,0 +1,144 @@
+/**
+ * ObjectUI — resolveDataSource Tests
+ * 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 { resolveDataSource } from '../resolveDataSource';
+import { ApiDataSource } from '../ApiDataSource';
+import { ValueDataSource } from '../ValueDataSource';
+import type { DataSource, ViewData } from '@object-ui/types';
+
+// ---------------------------------------------------------------------------
+// Minimal mock DataSource for "object" provider fallback
+// ---------------------------------------------------------------------------
+
+const mockFallback: DataSource<any> = {
+  find: async () => ({ data: [], total: 0 }),
+  findOne: async () => null,
+  create: async (_r, d) => d as any,
+  update: async (_r, _id, d) => d as any,
+  delete: async () => true,
+  getObjectSchema: async (name) => ({ name, fields: {} }),
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('resolveDataSource', () => {
+  it('should return null when viewData is null and no fallback', () => {
+    const ds = resolveDataSource(null);
+    expect(ds).toBeNull();
+  });
+
+  it('should return fallback when viewData is null', () => {
+    const ds = resolveDataSource(null, mockFallback);
+    expect(ds).toBe(mockFallback);
+  });
+
+  it('should return null when viewData is undefined and no fallback', () => {
+    const ds = resolveDataSource(undefined);
+    expect(ds).toBeNull();
+  });
+
+  // -----------------------------------------------------------------------
+  // provider: 'object'
+  // -----------------------------------------------------------------------
+
+  it('should return fallback for provider: "object"', () => {
+    const viewData: ViewData = { provider: 'object', object: 'contacts' };
+    const ds = resolveDataSource(viewData, mockFallback);
+    expect(ds).toBe(mockFallback);
+  });
+
+  it('should return null for provider: "object" without fallback', () => {
+    const viewData: ViewData = { provider: 'object', object: 'contacts' };
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeNull();
+  });
+
+  // -----------------------------------------------------------------------
+  // provider: 'api'
+  // -----------------------------------------------------------------------
+
+  it('should create ApiDataSource for provider: "api"', () => {
+    const viewData: ViewData = {
+      provider: 'api',
+      read: { url: '/api/contacts' },
+    };
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeInstanceOf(ApiDataSource);
+  });
+
+  it('should create ApiDataSource with read and write configs', () => {
+    const viewData: ViewData = {
+      provider: 'api',
+      read: { url: '/api/contacts', method: 'GET' },
+      write: { url: '/api/contacts', method: 'POST' },
+    };
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeInstanceOf(ApiDataSource);
+  });
+
+  it('should pass adapter options to ApiDataSource', () => {
+    const viewData: ViewData = {
+      provider: 'api',
+      read: { url: '/api/contacts' },
+    };
+    const ds = resolveDataSource(viewData, null, {
+      defaultHeaders: { Authorization: 'Bearer test' },
+    });
+    expect(ds).toBeInstanceOf(ApiDataSource);
+  });
+
+  // -----------------------------------------------------------------------
+  // provider: 'value'
+  // -----------------------------------------------------------------------
+
+  it('should create ValueDataSource for provider: "value"', () => {
+    const viewData: ViewData = {
+      provider: 'value',
+      items: [{ id: '1', name: 'Test' }],
+    };
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeInstanceOf(ValueDataSource);
+  });
+
+  it('should handle empty items array', () => {
+    const viewData: ViewData = {
+      provider: 'value',
+      items: [],
+    };
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeInstanceOf(ValueDataSource);
+  });
+
+  it('should pass idField option to ValueDataSource', () => {
+    const viewData: ViewData = {
+      provider: 'value',
+      items: [{ code: 'A', label: 'Alpha' }],
+    };
+    const ds = resolveDataSource(viewData, null, { idField: 'code' });
+    expect(ds).toBeInstanceOf(ValueDataSource);
+  });
+
+  // -----------------------------------------------------------------------
+  // Unknown provider
+  // -----------------------------------------------------------------------
+
+  it('should return fallback for unknown provider', () => {
+    const viewData = { provider: 'graphql' } as unknown as ViewData;
+    const ds = resolveDataSource(viewData, mockFallback);
+    expect(ds).toBe(mockFallback);
+  });
+
+  it('should return null for unknown provider without fallback', () => {
+    const viewData = { provider: 'unknown' } as unknown as ViewData;
+    const ds = resolveDataSource(viewData);
+    expect(ds).toBeNull();
+  });
+});

package/src/adapters/index.ts

@@ -7,4 +7,9 @@
  */
 
 // export { ObjectStackAdapter, createObjectStackAdapter } from './objectstack-adapter';
-// Adapters have been moved to separate packages (e.g. @object-ui/data-objectstack)
+// ObjectStack adapter has been moved to @object-ui/data-objectstack
+
+// Generic data source adapters (no external SDK dependencies)
+export { ApiDataSource, type ApiDataSourceConfig } from './ApiDataSource.js';
+export { ValueDataSource, type ValueDataSourceConfig } from './ValueDataSource.js';
+export { resolveDataSource, type ResolveDataSourceOptions } from './resolveDataSource.js';

package/src/adapters/resolveDataSource.ts

@@ -0,0 +1,79 @@
+/**
+ * ObjectUI — resolveDataSource
+ * 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.
+ *
+ * Factory function to create the right DataSource from a ViewData config.
+ */
+
+import type { DataSource, ViewData } from '@object-ui/types';
+import { ApiDataSource, type ApiDataSourceConfig } from './ApiDataSource.js';
+import { ValueDataSource } from './ValueDataSource.js';
+
+export interface ResolveDataSourceOptions {
+  /** Custom fetch implementation passed to ApiDataSource */
+  fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  /** Default headers for API requests */
+  defaultHeaders?: Record<string, string>;
+  /** Custom ID field for ValueDataSource */
+  idField?: string;
+}
+
+/**
+ * Resolve a ViewData configuration into a concrete DataSource instance.
+ *
+ * - `provider: 'object'` → returns `fallback` (the context DataSource — typically ObjectStackAdapter)
+ * - `provider: 'api'`    → returns a new `ApiDataSource`
+ * - `provider: 'value'`  → returns a new `ValueDataSource`
+ *
+ * @param viewData - The ViewData configuration from the schema
+ * @param fallback - The default DataSource from context (for `provider: 'object'`)
+ * @param options  - Additional options for adapter construction
+ * @returns A DataSource instance, or null if neither viewData nor fallback is available
+ *
+ * @example
+ * ```ts
+ * const ds = resolveDataSource(
+ *   { provider: 'api', read: { url: '/api/users' } },
+ *   contextDataSource,
+ * );
+ * const result = await ds.find('users');
+ * ```
+ */
+export function resolveDataSource<T = any>(
+  viewData: ViewData | null | undefined,
+  fallback?: DataSource<T> | null,
+  options?: ResolveDataSourceOptions,
+): DataSource<T> | null {
+  if (!viewData) {
+    return fallback ?? null;
+  }
+
+  switch (viewData.provider) {
+    case 'object':
+      // Delegate to the context DataSource (ObjectStackAdapter, etc.)
+      return fallback ?? null;
+
+    case 'api': {
+      const config: ApiDataSourceConfig = {
+        read: viewData.read,
+        write: viewData.write,
+        fetch: options?.fetch,
+        defaultHeaders: options?.defaultHeaders,
+      };
+      return new ApiDataSource<T>(config);
+    }
+
+    case 'value':
+      return new ValueDataSource<T>({
+        items: (viewData.items ?? []) as T[],
+        idField: options?.idField,
+      });
+
+    default:
+      // Unknown provider — fall back to context
+      return fallback ?? null;
+  }
+}