@onchaindb/sdk 0.4.5 → 1.0.0

package/src/query-sdk/tests/comprehensive.test.ts

@@ -1,4 +1,4 @@
-import { QueryBuilder, FieldConditionBuilder, LogicalOperator, createQueryResult } from '../index';
+import { QueryBuilder, FieldConditionBuilder, LogicalOperator } from '../index';
 import { MockHttpClient, createMockResponse } from './setup';
 
 describe('Comprehensive SDK Integration Tests', () => {
@@ -34,13 +34,12 @@ describe('Comprehensive SDK Integration Tests', () => {
       });
 
       expect(rawQuery.limit).toBe(10);
-      expect(rawQuery.select).toEqual({ fields: ['id', 'name'] });
+      expect(rawQuery.select).toEqual({ id: true, name: true });
     });
 
     test('should handle deep nesting scenarios', () => {
       const deepCondition = new FieldConditionBuilder('user.profile.settings.preferences.theme').equals('dark');
-      const logicalOp = LogicalOperator.Condition(deepCondition);
-      const composable = logicalOp.toComposable();
+      const composable = deepCondition.toComposable();
 
       const expected = {
         user: {
@@ -79,90 +78,7 @@ describe('Comprehensive SDK Integration Tests', () => {
     });
   });
 
-  describe('QueryResult advanced operations', () => {
-    test('should perform complex join operations', () => {
-      const users = createQueryResult([
-        { id: 1, name: 'John', departmentId: 1 },
-        { id: 2, name: 'Jane', departmentId: 2 }
-      ]);
-
-      const departments = createQueryResult([
-        { id: 1, name: 'Engineering' },
-        { id: 2, name: 'Design' }
-      ]);
-
-      const joined = users.innerJoin(departments, 'departmentId', 'id');
-      expect(joined.length).toBe(2);
-      expect(joined[0].name).toBe('Engineering'); // Department name merged
-      expect(joined[1].name).toBe('Design');
-    });
-
-    test('should export to CSV with proper formatting', () => {
-      const users = createQueryResult([
-        { id: 1, name: 'John', age: 30, score: 95.5 },
-        { id: 2, name: 'Jane', age: 25, score: 87.2 },
-        { id: 3, name: 'Bob', age: 35, score: 92.8 }
-      ]);
-
-      const csv = users.toCsv();
-      const lines = csv.split('\n');
-      
-      expect(lines.length).toBe(4); // header + 3 data rows
-      expect(lines[0]).toContain('id');
-      expect(lines[0]).toContain('name');
-      expect(lines[0]).toContain('age');
-      expect(lines[0]).toContain('score');
-    });
-
-    test('should provide comprehensive numeric summaries', () => {
-      const testData = [
-        { id: 1, name: 'John', age: 30, score: 95.5 },
-        { id: 2, name: 'Jane', age: 25, score: 87.2 },
-        { id: 3, name: 'Bob', age: 35, score: 92.8 }
-      ];
-
-      const result = createQueryResult(testData);
-      const scoreSummary = result.summarizeNumeric('score');
-      
-      expect(scoreSummary).not.toBeNull();
-      expect(scoreSummary!.count).toBe(3);
-      expect(scoreSummary!.mean).toBeCloseTo((95.5 + 87.2 + 92.8) / 3, 2);
-      expect(scoreSummary!.min).toBe(87.2);
-      expect(scoreSummary!.max).toBe(95.5);
-    });
-
-    test('should handle sorting and filtering', () => {
-      const testData = [
-        { id: 1, name: 'John', age: 30 },
-        { id: 2, name: 'Jane', age: 25 },
-        { id: 3, name: 'Bob', age: 35 }
-      ];
-
-      const result = createQueryResult(testData);
-      
-      const sortedByAge = result.sortBy('age');
-      expect(sortedByAge[0].age).toBe(25);
-      expect(sortedByAge[2].age).toBe(35);
-
-      const filtered = result.filter(item => item.age > 30);
-      expect(filtered.length).toBe(1);
-      expect(filtered[0].name).toBe('Bob');
-
-      const grouped = result.groupBy('age');
-      expect(Object.keys(grouped).length).toBe(3);
-    });
-  });
-
   describe('Error handling and validation', () => {
-    test('should handle empty QueryResult operations gracefully', () => {
-      const emptyResult = createQueryResult([]);
-      
-      expect(emptyResult.isEmpty()).toBe(true);
-      expect(emptyResult.first()).toBeUndefined();
-      expect(emptyResult.len()).toBe(0);
-      expect(emptyResult.summarizeNumeric('field')).toBeNull();
-    });
-
     test('should validate QueryBuilder state', () => {
       const emptyBuilder = new QueryBuilder();
       expect(emptyBuilder.isValid()).toBe(false);
@@ -174,106 +90,9 @@ describe('Comprehensive SDK Integration Tests', () => {
 
     test('should handle invalid field references', () => {
       expect(() => {
-        const condition = new FieldConditionBuilder('').equals('test');
-        LogicalOperator.Condition(condition).toComposable();
+        new FieldConditionBuilder('').equals('test').toComposable();
       }).not.toThrow();
     });
   });
 
-  describe('All operators comprehensive coverage', () => {
-    test('should support all field condition operators', () => {
-      const builder = new FieldConditionBuilder('test_field');
-
-      // Only test operators that actually exist in the Rust implementation
-      const operators = [
-        'equals', 'notEquals', 'greaterThan', 'lessThan', 'greaterThanOrEqual', 'lessThanOrEqual',
-        'contains', 'startsWith', 'endsWith', 'in', 'notIn', 'exists', 'notExists', 
-        'isNull', 'isNotNull', 'regExpMatches', 'includesCaseInsensitive', 
-        'startsWithCaseInsensitive', 'endsWithCaseInsensitive', 'between',
-        'isLocalIp', 'isExternalIp', 'b64', 'inDataset', 'inCountry', 'cidr',
-        'isTrue', 'isFalse'
-      ];
-
-      operators.forEach(op => {
-        expect(typeof (builder as any)[op]).toBe('function');
-      });
-    });
-
-    test('should create correct conditions for advanced operators', () => {
-      const builder = new FieldConditionBuilder('test_field');
-
-      // String operators
-      const regexCondition = builder.regExpMatches('^test.*');
-      expect(regexCondition.operator).toBe('regExpMatches');
-
-      const caseInsensitiveCondition = builder.includesCaseInsensitive('Test');
-      expect(caseInsensitiveCondition.operator).toBe('includesCaseInsensitive');
-
-      // IP operators
-      const ipBuilder = new FieldConditionBuilder('ip_address');
-      const ipLocalCondition = ipBuilder.isLocalIp();
-      expect(ipLocalCondition.operator).toBe('isLocalIp');
-      
-      const ipExternalCondition = ipBuilder.isExternalIp();
-      expect(ipExternalCondition.operator).toBe('isExternalIp');
-
-      // Misc operators
-      const b64Condition = builder.b64('dGVzdA==');
-      expect(b64Condition.operator).toBe('b64');
-      
-      const countryCondition = builder.inCountry('US');
-      expect(countryCondition.operator).toBe('inCountry');
-
-      const cidrCondition = builder.cidr('192.168.1.0/24');
-      expect(cidrCondition.operator).toBe('CIDR');
-
-      const datasetCondition = builder.inDataset('malware_ips');
-      expect(datasetCondition.operator).toBe('inDataset');
-
-      const betweenCondition = builder.between(5, 15);
-      expect(betweenCondition.operator).toBe('betweenOp');
-    });
-  });
-
-  describe('Performance and memory scenarios', () => {
-    test('should handle large datasets efficiently', () => {
-      const largeDataset = Array.from({ length: 1000 }, (_, i) => ({
-        id: i,
-        name: `User${i}`,
-        value: Math.random() * 100
-      }));
-
-      const result = createQueryResult(largeDataset);
-      expect(result.len()).toBe(1000);
-
-      const filtered = result.filter(item => item.value > 50);
-      expect(filtered.length).toBeGreaterThan(0);
-
-      const summary = result.summarizeNumeric('value');
-      expect(summary).not.toBeNull();
-      expect(summary!.count).toBe(1000);
-    });
-
-    test('should handle complex nested structures', () => {
-      const complexData = Array.from({ length: 100 }, (_, i) => ({
-        id: i,
-        user: {
-          profile: {
-            details: {
-              settings: {
-                preferences: {
-                  theme: i % 2 === 0 ? 'dark' : 'light'
-                }
-              }
-            }
-          }
-        }
-      }));
-
-      const result = createQueryResult(complexData);
-      const themes = result.pluck('user.profile.details.settings.preferences.theme');
-      expect(themes.filter(theme => theme === 'dark')).toHaveLength(50);
-      expect(themes.filter(theme => theme === 'light')).toHaveLength(50);
-    });
-  });
 });

package/src/tests/client-requests.test.ts

@@ -0,0 +1,280 @@
+import axios from 'axios';
+import { OnChainDBClient } from '../client';
+import { CreateQueryRequest } from '../types';
+
+// Spy on axios.create so we can capture the instance handed to the client
+let mockHttp: {
+    post: jest.Mock;
+    get: jest.Mock;
+    delete: jest.Mock;
+    patch: jest.Mock;
+    interceptors: { request: { use: jest.Mock }; response: { use: jest.Mock } };
+};
+let createSpy: jest.SpyInstance;
+let client: OnChainDBClient;
+
+beforeEach(() => {
+    mockHttp = {
+        post: jest.fn().mockResolvedValue({ data: {} }),
+        get: jest.fn().mockResolvedValue({ data: {} }),
+        delete: jest.fn().mockResolvedValue({ data: {} }),
+        patch: jest.fn().mockResolvedValue({ data: {} }),
+        interceptors: {
+            request: { use: jest.fn() },
+            response: { use: jest.fn() },
+        },
+    };
+    createSpy = jest.spyOn(axios, 'create').mockReturnValue(mockHttp as any);
+    client = new OnChainDBClient({
+        endpoint: 'http://localhost:9092',
+        appId: 'test_app',
+        appKey: 'key123',
+    });
+});
+
+afterEach(() => {
+    createSpy.mockRestore();
+    jest.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Predefined Queries
+// ---------------------------------------------------------------------------
+
+describe('createQuery()', () => {
+    test('POSTs the full CreateQueryRequest body (not just name+query)', async () => {
+        const req: CreateQueryRequest = {
+            name: 'active_orders',
+            source_collection: 'orders',
+            base_query: { find: { status: { $eq: 'active' } } },
+            parameters: [
+                { name: 'status', field_path: 'status', required: true },
+                { name: 'min_amount', field_path: 'amount.$gte', default: 0 },
+            ],
+            description: 'Active orders query',
+        };
+
+        mockHttp.post.mockResolvedValue({ data: { success: true, message: 'ok', query_name: 'active_orders' } });
+        await client.createQuery(req);
+
+        expect(mockHttp.post).toHaveBeenCalledWith('/apps/test_app/queries', req);
+    });
+
+    test('uses the correct URL with appId', async () => {
+        mockHttp.post.mockResolvedValue({ data: { success: true, message: 'ok', query_name: 'q' } });
+        await client.createQuery({ name: 'q', source_collection: 'col', base_query: {} });
+
+        const [url] = mockHttp.post.mock.calls[0];
+        expect(url).toBe('/apps/test_app/queries');
+    });
+});
+
+describe('executeQuery()', () => {
+    test('passes params as axios params object, not as path string', async () => {
+        mockHttp.get.mockResolvedValue({ data: { success: true, query_name: 'q', data: [], count: 0, query_time_ms: 1 } });
+        await client.executeQuery('active_orders', { market: 'BTC', status: 'open' });
+
+        const [url, config] = mockHttp.get.mock.calls[0];
+        expect(url).toBe('/api/queries/test_app/active_orders/data');
+        expect(config.params).toMatchObject({ market: 'BTC', status: 'open' });
+        expect(url).not.toContain('?'); // no manual query string
+    });
+
+    test('includes v param when version is provided', async () => {
+        mockHttp.get.mockResolvedValue({ data: { success: true, query_name: 'q', data: [], count: 0, query_time_ms: 1 } });
+        await client.executeQuery('active_orders', { market: 'ETH' }, 2);
+
+        const [, config] = mockHttp.get.mock.calls[0];
+        expect(config.params).toMatchObject({ market: 'ETH', v: 2 });
+    });
+
+    test('works without params or version', async () => {
+        mockHttp.get.mockResolvedValue({ data: { success: true, query_name: 'q', data: [], count: 0, query_time_ms: 1 } });
+        await client.executeQuery('active_orders');
+
+        const [url, config] = mockHttp.get.mock.calls[0];
+        expect(url).toBe('/api/queries/test_app/active_orders/data');
+        expect(config.params).toEqual({}); // no params, no v
+    });
+});
+
+describe('listQueries()', () => {
+    test('unwraps response.data.queries array', async () => {
+        const definitions = [
+            { name: 'q1', source_collection: 'orders', base_query: {}, created_at: '2024-01-01' },
+            { name: 'q2', source_collection: 'users', base_query: {}, created_at: '2024-01-02' },
+        ];
+        mockHttp.get.mockResolvedValue({ data: { queries: definitions } });
+
+        const result = await client.listQueries();
+        expect(result).toEqual(definitions);
+    });
+
+    test('falls back to raw data when no queries wrapper', async () => {
+        const definitions = [{ name: 'q1', source_collection: 'col', base_query: {}, created_at: '' }];
+        mockHttp.get.mockResolvedValue({ data: definitions });
+
+        const result = await client.listQueries();
+        expect(result).toEqual(definitions);
+    });
+});
+
+describe('deleteQuery()', () => {
+    test('sends DELETE to the correct URL', async () => {
+        mockHttp.delete.mockResolvedValue({ data: { success: true } });
+        await client.deleteQuery('my_query');
+
+        expect(mockHttp.delete).toHaveBeenCalledWith('/apps/test_app/queries/my_query');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Retention
+// ---------------------------------------------------------------------------
+
+describe('getRetention()', () => {
+    test('GETs the correct URL', async () => {
+        mockHttp.get.mockResolvedValue({
+            data: { collection: 'orders', monthly_cost_per_kb: 0.001, status: 'permanent' },
+        });
+        await client.getRetention('orders');
+
+        expect(mockHttp.get).toHaveBeenCalledWith('/api/apps/test_app/collections/orders/retention');
+    });
+});
+
+describe('setRetention()', () => {
+    test('POSTs to the correct URL with retention_days in the body', async () => {
+        mockHttp.post.mockResolvedValue({
+            data: { message: 'updated', config: { collection: 'orders', monthly_cost_per_kb: 0.001, status: 'active' } },
+        });
+        await client.setRetention('orders', { retention_days: 90 });
+
+        expect(mockHttp.post).toHaveBeenCalledWith(
+            '/api/apps/test_app/collections/orders/retention',
+            { retention_days: 90 }
+        );
+    });
+
+    test('can set null to remove retention (permanent storage)', async () => {
+        mockHttp.post.mockResolvedValue({ data: { message: 'updated', config: {} } });
+        await client.setRetention('orders', { retention_days: null });
+
+        const [, body] = mockHttp.post.mock.calls[0];
+        expect(body.retention_days).toBeNull();
+    });
+});
+
+describe('getRetentionCost()', () => {
+    test('GETs the correct URL', async () => {
+        mockHttp.get.mockResolvedValue({
+            data: { app_id: 'test_app', collections: [], total_monthly_cost_tia: 0, projected_next_month_cost_tia: 0 },
+        });
+        await client.getRetentionCost();
+
+        expect(mockHttp.get).toHaveBeenCalledWith('/api/apps/test_app/retention/cost');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Collection management
+// ---------------------------------------------------------------------------
+
+describe('deleteCollection()', () => {
+    test('sends DELETE to the correct URL', async () => {
+        mockHttp.delete.mockResolvedValue({ data: { success: true } });
+        await client.deleteCollection('old_col');
+
+        expect(mockHttp.delete).toHaveBeenCalledWith('/api/apps/test_app/collections/old_col');
+    });
+});
+
+describe('updateCollection()', () => {
+    test('sends PATCH to the correct URL with the update body', async () => {
+        mockHttp.patch.mockResolvedValue({ data: { success: true } });
+        await client.updateCollection('users', { public: true, description: 'Public users' });
+
+        expect(mockHttp.patch).toHaveBeenCalledWith(
+            '/api/apps/test_app/collections/users',
+            { public: true, description: 'Public users' }
+        );
+    });
+});
+
+describe('getCollectionInfo()', () => {
+    test('GETs using the collectionId (index-based ID, not name)', async () => {
+        mockHttp.get.mockResolvedValue({
+            data: {
+                id: 'test_app_0', name: 'users', namespace: 'ns', primary_column: 'id',
+                status: 'active', collection_type: 'local', document_count: 100,
+                size_kb: 50, created_at: '', last_modified: '',
+            },
+        });
+        await client.getCollectionInfo('test_app_0');
+
+        expect(mockHttp.get).toHaveBeenCalledWith('/api/apps/test_app/collections/test_app_0');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// syncCollection
+// ---------------------------------------------------------------------------
+
+describe('syncCollection()', () => {
+    test('POSTs one index per indexed field to the correct URL', async () => {
+        mockHttp.post.mockResolvedValue({ data: {} });
+
+        const result = await client.syncCollection({
+            name: 'products',
+            fields: {
+                title:  { type: 'string',  index: true },
+                price:  { type: 'number',  index: true },
+                active: { type: 'boolean', index: false }, // not indexed
+            },
+            useBaseFields: false,
+        });
+
+        // Only 'title' and 'price' are indexed
+        const indexCalls = mockHttp.post.mock.calls.filter(([url]) =>
+            url === '/api/apps/test_app/indexes'
+        );
+        expect(indexCalls).toHaveLength(2);
+        const fieldNames = indexCalls.map(([, body]) => body.field_name).sort();
+        expect(fieldNames).toEqual(['price', 'title']);
+    });
+
+    test('includes sharding PATCH when schema has sharding config', async () => {
+        mockHttp.post.mockResolvedValue({ data: {} });
+        mockHttp.patch.mockResolvedValue({ data: {} });
+
+        const result = await client.syncCollection({
+            name: 'snapshots',
+            fields: { market: { type: 'string', index: true } },
+            useBaseFields: false,
+            sharding: {
+                keys: [{ field: 'market', type: 'discrete' }],
+                enforce_in_queries: true,
+            },
+        });
+
+        expect(mockHttp.patch).toHaveBeenCalledWith(
+            '/api/apps/test_app/collections/snapshots/sharding',
+            expect.objectContaining({ keys: [{ field: 'market', type: 'discrete' }] })
+        );
+        expect(result.sharding_configured).toBe(true);
+    });
+
+    test('marks index errors in result without throwing', async () => {
+        mockHttp.post.mockRejectedValue(new Error('index creation failed'));
+
+        const result = await client.syncCollection({
+            name: 'col',
+            fields: { email: { type: 'string', index: true } },
+            useBaseFields: false,
+        });
+
+        expect(result.success).toBe(false);
+        expect(result.errors!.length).toBeGreaterThan(0);
+        expect(result.errors![0]).toContain('email');
+    });
+});

package/src/tests/client-validation.test.ts

@@ -0,0 +1,80 @@
+import { OnChainDBClient } from '../client';
+import { ValidationError } from '../types';
+
+// These tests cover pure validation logic that throws before any HTTP is made.
+// No axios mock required — the errors fire synchronously before any await.
+
+const clientWithApp = new OnChainDBClient({
+    endpoint: 'http://localhost:9092',
+    appId: 'test_app',
+});
+
+const clientNoApp = new OnChainDBClient({
+    endpoint: 'http://localhost:9092',
+});
+
+describe('OnChainDBClient — store() validation', () => {
+    test('throws when data is empty array', async () => {
+        await expect(
+            clientWithApp.store({ collection: 'col', data: [] })
+        ).rejects.toThrow(ValidationError);
+    });
+
+    test('throws when data is not an array', async () => {
+        await expect(
+            clientWithApp.store({ collection: 'col', data: 'not-an-array' as any })
+        ).rejects.toThrow(ValidationError);
+    });
+
+    test('throws when data is missing entirely', async () => {
+        await expect(
+            clientWithApp.store({ collection: 'col' } as any)
+        ).rejects.toThrow(ValidationError);
+    });
+
+    test('throws when neither root nor collection is provided', async () => {
+        await expect(
+            clientWithApp.store({ data: [{ id: '1' }] })
+        ).rejects.toThrow(ValidationError);
+    });
+
+    test('throws when data item is not an object', async () => {
+        await expect(
+            clientWithApp.store({ collection: 'col', data: ['not-an-object'] as any })
+        ).rejects.toThrow(ValidationError);
+    });
+
+    test('throws when total data size exceeds 5MB', async () => {
+        const bigRecord = { id: '1', payload: 'x'.repeat(6 * 1024 * 1024) };
+        await expect(
+            clientWithApp.store({ collection: 'col', data: [bigRecord] })
+        ).rejects.toThrow(ValidationError);
+    });
+});
+
+describe('OnChainDBClient — appId-required methods throw ValidationError when appId is missing', () => {
+    const cases: Array<[string, () => Promise<any>]> = [
+        ['setupSharding()', () => clientNoApp.setupSharding('col', { keys: [], enforce_in_queries: false })],
+        ['syncCollection()', () => clientNoApp.syncCollection({ name: 'col', fields: {} })],
+        ['deleteCollection()', () => clientNoApp.deleteCollection('col')],
+        ['updateCollection()', () => clientNoApp.updateCollection('col', {})],
+        ['getCollectionInfo()', () => clientNoApp.getCollectionInfo('col_0')],
+        ['getRetention()', () => clientNoApp.getRetention('col')],
+        ['setRetention()', () => clientNoApp.setRetention('col', { retention_days: 30 })],
+        ['getRetentionCost()', () => clientNoApp.getRetentionCost()],
+        ['listQueries()', () => clientNoApp.listQueries()],
+        ['createQuery()', () => clientNoApp.createQuery({ name: 'q', source_collection: 'col', base_query: {} })],
+        ['getQuery()', () => clientNoApp.getQuery('q')],
+        ['deleteQuery()', () => clientNoApp.deleteQuery('q')],
+        ['executeQuery()', () => clientNoApp.executeQuery('q')],
+        // database() tested separately below — it throws synchronously
+    ];
+
+    test.each(cases)('%s', async (_name, fn) => {
+        await expect(fn()).rejects.toThrow(ValidationError);
+    });
+
+    test('database()', () => {
+        expect(() => clientNoApp.database()).toThrow(ValidationError);
+    });
+});