@tapstack/db 1.0.6 → 3.0.0

package/src/__tests__/client.test.ts

@@ -1,84 +1,340 @@
-import axios from 'axios';
-import { TapstackDBClient } from '../index';
+import {
+  TapstackDBClient,
+  IInstanceAdapter,
+  createClient,
+  createCustomClient,
+} from '../index';
 
-jest.mock('axios');
+/**
+ * Mock adapter for testing
+ */
+class MockAdapter implements IInstanceAdapter {
+  public requests: Array<{
+    method: string;
+    path: string;
+    options?: { body?: unknown; params?: Record<string, string> };
+  }> = [];
+  public uploads: Array<{ path: string; file: File | Blob; metadata?: Record<string, string> }> = [];
+  private workspaceId: string | null = null;
+  public mockResponse: unknown = {};
 
-const mockedCreate = axios.create as jest.Mock;
+  async request<T>(
+    method: string,
+    path: string,
+    options?: { body?: unknown; params?: Record<string, string> }
+  ): Promise<T> {
+    this.requests.push({ method, path, options });
+    return this.mockResponse as T;
+  }
 
-describe('TapstackDBClient', () => {
-  const apiClient = {
-    get: jest.fn(),
-    post: jest.fn(),
-    put: jest.fn(),
-    delete: jest.fn(),
-  };
+  async upload<T>(
+    path: string,
+    file: File | Blob,
+    metadata?: Record<string, string>
+  ): Promise<T> {
+    this.uploads.push({ path, file, metadata });
+    return this.mockResponse as T;
+  }
+
+  setWorkspaceId(id: string | null): void {
+    this.workspaceId = id;
+  }
+
+  getWorkspaceId(): string | null {
+    return this.workspaceId;
+  }
 
+  clearRequests(): void {
+    this.requests = [];
+    this.uploads = [];
+  }
+}
+
+describe('TapstackDBClient', () => {
+  let adapter: MockAdapter;
   let client: TapstackDBClient;
 
   beforeEach(() => {
-    mockedCreate.mockReturnValue(apiClient);
-    client = new TapstackDBClient({ baseURL: 'http://example.com', apiKey: 'token' });
+    adapter = new MockAdapter();
+    client = new TapstackDBClient(adapter);
   });
 
   afterEach(() => {
-    jest.clearAllMocks();
+    adapter.clearRequests();
   });
 
+  describe('Objects Module', () => {
+    it('list() calls GET schema/objects', async () => {
+      adapter.mockResponse = { objects: [] };
+      await client.objects.list();
+      expect(adapter.requests).toHaveLength(1);
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'schema/objects',
+        options: undefined,
+      });
+    });
+
+    it('get() calls GET schema/objects/:slug', async () => {
+      adapter.mockResponse = { id: '1', slug: 'contacts' };
+      await client.objects.get('contacts');
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'schema/objects/contacts',
+        options: undefined,
+      });
+    });
 
-  it('getObject calls axios.get with correct path', async () => {
-    await client.getObject('item');
-    expect(apiClient.get).toHaveBeenCalledWith('/system/item');
+    it('create() calls POST schema/objects', async () => {
+      const payload = { singleName: 'Contact', pluralName: 'Contacts' };
+      adapter.mockResponse = { id: '1', ...payload };
+      await client.objects.create(payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'POST',
+        path: 'schema/objects',
+        options: { body: payload },
+      });
+    });
+
+    it('update() calls PATCH schema/objects/:slug', async () => {
+      const payload = { singleName: 'Updated Contact' };
+      await client.objects.update('contacts', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'PATCH',
+        path: 'schema/objects/contacts',
+        options: { body: payload },
+      });
+    });
+
+    it('delete() calls DELETE schema/objects/:slug', async () => {
+      await client.objects.delete('contacts');
+      expect(adapter.requests[0]).toEqual({
+        method: 'DELETE',
+        path: 'schema/objects/contacts',
+        options: { params: { soft: 'true' } },
+      });
+    });
   });
 
-  it('getAllObjects calls axios.get on /system', async () => {
-    await client.getAllObjects();
-    expect(apiClient.get).toHaveBeenCalledWith('/system');
+  describe('Fields Module', () => {
+    it('list() calls GET schema/objects/:slug/fields', async () => {
+      adapter.mockResponse = { fields: [] };
+      await client.fields.list('contacts');
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'schema/objects/contacts/fields',
+        options: undefined,
+      });
+    });
+
+    it('create() calls POST schema/objects/:slug/fields', async () => {
+      const payload = { label: 'Email', value: 'email', type: 'email' as const };
+      await client.fields.create('contacts', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'POST',
+        path: 'schema/objects/contacts/fields',
+        options: { body: payload },
+      });
+    });
+
+    it('update() calls PATCH schema/objects/:slug/fields/:fieldId', async () => {
+      const payload = { label: 'Updated Email' };
+      await client.fields.update('contacts', 'field-1', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'PATCH',
+        path: 'schema/objects/contacts/fields/field-1',
+        options: { body: payload },
+      });
+    });
+
+    it('delete() calls DELETE schema/objects/:slug/fields/:fieldId', async () => {
+      await client.fields.delete('contacts', 'field-1');
+      expect(adapter.requests[0]).toEqual({
+        method: 'DELETE',
+        path: 'schema/objects/contacts/fields/field-1',
+        options: { params: { soft: 'true' } },
+      });
+    });
   });
 
-  it('createObject posts to /system', async () => {
-    const data = { name: 'test' };
-    await client.createObject(data);
-    expect(apiClient.post).toHaveBeenCalledWith('/system', data);
+  describe('Records Module', () => {
+    it('list() calls GET records/:slug', async () => {
+      adapter.mockResponse = { items: [], total: 0 };
+      await client.records.list('contacts');
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'records/contacts',
+        options: { params: {} },
+      });
+    });
+
+    it('list() with options adds query params', async () => {
+      adapter.mockResponse = { items: [], total: 0 };
+      await client.records.list('contacts', {
+        page: 2,
+        pageSize: 10,
+        sortBy: 'createdAt',
+        sortOrder: 'desc',
+      });
+      expect(adapter.requests[0].options?.params).toEqual({
+        page: '2',
+        pageSize: '10',
+        sortBy: 'createdAt',
+        sortOrder: 'desc',
+      });
+    });
+
+    it('get() calls GET records/:slug/:id', async () => {
+      await client.records.get('contacts', 'rec-1');
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'records/contacts/rec-1',
+        options: undefined,
+      });
+    });
+
+    it('create() calls POST records/:slug', async () => {
+      const payload = { data: { name: 'John' } };
+      await client.records.create('contacts', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'POST',
+        path: 'records/contacts',
+        options: { body: payload },
+      });
+    });
+
+    it('update() calls PATCH records/:slug/:id', async () => {
+      const payload = { data: { name: 'Jane' } };
+      await client.records.update('contacts', 'rec-1', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'PATCH',
+        path: 'records/contacts/rec-1',
+        options: { body: payload },
+      });
+    });
+
+    it('delete() calls DELETE records/:slug/:id', async () => {
+      await client.records.delete('contacts', 'rec-1');
+      expect(adapter.requests[0]).toEqual({
+        method: 'DELETE',
+        path: 'records/contacts/rec-1',
+        options: { params: { soft: 'true' } },
+      });
+    });
   });
 
-  it('updateObject puts to correct path', async () => {
-    await client.updateObject('item', { a: 1 });
-    expect(apiClient.put).toHaveBeenCalledWith('/system/item', { a: 1 });
+  describe('Organizations Module', () => {
+    it('list() calls GET organizations', async () => {
+      adapter.mockResponse = { organizations: [] };
+      await client.organizations.list();
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'organizations',
+        options: undefined,
+      });
+    });
+
+    it('create() calls POST organizations', async () => {
+      const payload = { name: 'Acme Corp' };
+      await client.organizations.create(payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'POST',
+        path: 'organizations',
+        options: { body: payload },
+      });
+    });
   });
 
-  it('deleteObject deletes from correct path', async () => {
-    await client.deleteObject('item');
-    expect(apiClient.delete).toHaveBeenCalledWith('/system/item');
+  describe('Workspaces Module', () => {
+    it('list() calls GET workspaces', async () => {
+      adapter.mockResponse = { workspaces: [] };
+      await client.workspaces.list();
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'workspaces',
+        options: undefined,
+      });
+    });
+
+    it('create() calls POST workspaces/org/:orgId', async () => {
+      const payload = { name: 'Production' };
+      await client.workspaces.create('org-1', payload);
+      expect(adapter.requests[0]).toEqual({
+        method: 'POST',
+        path: 'workspaces/org/org-1',
+        options: { body: payload },
+      });
+    });
   });
 
-  it('getFields calls axios.get with fields path', async () => {
-    await client.getFields('item');
-    expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields');
+  describe('Files Module', () => {
+    it('list() calls GET files/list', async () => {
+      adapter.mockResponse = { files: [], total: 0 };
+      await client.files.list();
+      expect(adapter.requests[0]).toEqual({
+        method: 'GET',
+        path: 'files/list',
+        options: { params: {} },
+      });
+    });
+
+    it('upload() uses adapter.upload', async () => {
+      const file = new Blob(['test'], { type: 'text/plain' });
+      await client.files.upload(file, { folderId: 'folder-1' });
+      expect(adapter.uploads).toHaveLength(1);
+      expect(adapter.uploads[0]).toEqual({
+        path: 'files/upload',
+        file,
+        metadata: { folderId: 'folder-1' },
+      });
+    });
   });
 
-  it('getField calls axios.get with field id', async () => {
-    await client.getField('item', '1');
-    expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields/1');
+  describe('Workspace Context', () => {
+    it('setWorkspaceId updates adapter workspace', () => {
+      client.setWorkspaceId('ws-123');
+      expect(adapter.getWorkspaceId()).toBe('ws-123');
+    });
+
+    it('getWorkspaceId returns current workspace', () => {
+      adapter.setWorkspaceId('ws-456');
+      expect(client.getWorkspaceId()).toBe('ws-456');
+    });
   });
+});
 
-  it('createField posts to fields path', async () => {
-    await client.createField('item', { name: 'field' });
-    expect(apiClient.post).toHaveBeenCalledWith('/system/item/fields', { name: 'field' });
+describe('Factory Functions', () => {
+  // Mock fetch for adapter tests
+  const mockFetch = jest.fn();
+  global.fetch = mockFetch;
+
+  beforeEach(() => {
+    mockFetch.mockReset();
+    mockFetch.mockResolvedValue({
+      status: 200,
+      json: () => Promise.resolve({ success: true, data: {} }),
+    });
   });
 
-  it('updateField puts to specific field path', async () => {
-    await client.updateField('item', '1', { name: 'f' });
-    expect(apiClient.put).toHaveBeenCalledWith('/system/item/fields/1', { name: 'f' });
+  it('createClient creates a client with default API URL', () => {
+    const client = createClient({
+      apiKey: 'api-key',
+    });
+    expect(client).toBeInstanceOf(TapstackDBClient);
   });
 
-  it('deleteField deletes the field path', async () => {
-    await client.deleteField('item', '1');
-    expect(apiClient.delete).toHaveBeenCalledWith('/system/item/fields/1');
+  it('createClient creates a client with custom base URL', () => {
+    const client = createClient({
+      baseUrl: 'https://api.example.com',
+      apiKey: 'api-key',
+    });
+    expect(client).toBeInstanceOf(TapstackDBClient);
   });
 
-  it('query posts to slug', async () => {
-    const variables = { a: 1 };
-    await client.query('item', variables);
-    expect(apiClient.post).toHaveBeenCalledWith('/item', variables);
+  it('createCustomClient creates a client with custom adapter', () => {
+    const adapter = new MockAdapter();
+    const client = createCustomClient(adapter);
+    expect(client).toBeInstanceOf(TapstackDBClient);
+    expect(client.getAdapter()).toBe(adapter);
   });
 });

package/src/adapters/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Adapters Index
+ * Export all adapter types and implementations
+ */
+
+export * from './types';
+export * from './nodejs.adapter';
+
+
+
+
+
+