@object-ui/core 3.3.0 → 3.3.2

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

@@ -1,144 +0,0 @@
-/**
- * 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

@@ -1,15 +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 { ObjectStackAdapter, createObjectStackAdapter } from './objectstack-adapter';
-// 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

@@ -1,79 +0,0 @@
-/**
- * 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;
-  }
-}

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

@@ -1,235 +0,0 @@
-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');
-    });
-  });
-});