@objectstack/objectql 3.3.0 → 4.0.0

package/src/plugin.ts

@@ -175,7 +175,7 @@ export class ObjectQLPlugin implements Plugin {
       if (hookCtx.input?.id && !hookCtx.previous) {
         try {
           const existing = await this.ql!.findOne(hookCtx.object, {
-            filter: { id: hookCtx.input.id }
+            where: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -191,7 +191,7 @@ export class ObjectQLPlugin implements Plugin {
       if (hookCtx.input?.id && !hookCtx.previous) {
         try {
           const existing = await this.ql!.findOne(hookCtx.object, {
-            filter: { id: hookCtx.input.id }
+            where: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -239,9 +239,13 @@ export class ObjectQLPlugin implements Plugin {
   /**
    * Synchronize all registered object schemas to the database.
    *
-   * Iterates every object in the SchemaRegistry and calls the
-   * responsible driver's `syncSchema()` for each one.  This is
-   * idempotent — drivers must tolerate repeated calls without
+   * Groups objects by their responsible driver, then:
+   * - If the driver advertises `supports.batchSchemaSync` and implements
+   *   `syncSchemasBatch()`, submits all schemas in a single call (reducing
+   *   network round-trips for remote drivers like Turso).
+   * - Otherwise falls back to sequential `syncSchema()` per object.
+   *
+   * This is idempotent — drivers must tolerate repeated calls without
    * duplicating tables or erroring out.
    *
    * Drivers that do not implement `syncSchema` are silently skipped.
@@ -255,6 +259,9 @@ export class ObjectQLPlugin implements Plugin {
     let synced = 0;
     let skipped = 0;
 
+    // Group objects by driver for potential batch optimization
+    const driverGroups = new Map<any, Array<{ obj: any; tableName: string }>>();
+
     for (const obj of allObjects) {
       const driver = this.ql.getDriverForObject(obj.name);
       if (!driver) {
@@ -274,21 +281,69 @@ export class ObjectQLPlugin implements Plugin {
         continue;
       }
 
-      // Use the physical table name (e.g., 'sys_user') for DDL operations
-      // instead of the FQN (e.g., 'sys__user'). ObjectSchema.create()
-      // auto-derives tableName as {namespace}_{name}.
       const tableName = obj.tableName || obj.name;
 
-      try {
-        await driver.syncSchema(tableName, obj);
-        synced++;
-      } catch (e: unknown) {
-        ctx.logger.warn('Failed to sync schema for object', {
-          object: obj.name,
-          tableName,
-          driver: driver.name,
-          error: e instanceof Error ? e.message : String(e),
-        });
+      let group = driverGroups.get(driver);
+      if (!group) {
+        group = [];
+        driverGroups.set(driver, group);
+      }
+      group.push({ obj, tableName });
+    }
+
+    // Process each driver group
+    for (const [driver, entries] of driverGroups) {
+      // Batch path: driver supports batch schema sync
+      if (
+        driver.supports?.batchSchemaSync &&
+        typeof driver.syncSchemasBatch === 'function'
+      ) {
+        const batchPayload = entries.map((e) => ({
+          object: e.tableName,
+          schema: e.obj,
+        }));
+        try {
+          await driver.syncSchemasBatch(batchPayload);
+          synced += entries.length;
+          ctx.logger.debug('Batch schema sync succeeded', {
+            driver: driver.name,
+            count: entries.length,
+          });
+        } catch (e: unknown) {
+          ctx.logger.warn('Batch schema sync failed, falling back to sequential', {
+            driver: driver.name,
+            error: e instanceof Error ? e.message : String(e),
+          });
+          // Fallback: sequential sync for this driver's objects
+          for (const { obj, tableName } of entries) {
+            try {
+              await driver.syncSchema(tableName, obj);
+              synced++;
+            } catch (seqErr: unknown) {
+              ctx.logger.warn('Failed to sync schema for object', {
+                object: obj.name,
+                tableName,
+                driver: driver.name,
+                error: seqErr instanceof Error ? seqErr.message : String(seqErr),
+              });
+            }
+          }
+        }
+      } else {
+        // Sequential path: no batch support
+        for (const { obj, tableName } of entries) {
+          try {
+            await driver.syncSchema(tableName, obj);
+            synced++;
+          } catch (e: unknown) {
+            ctx.logger.warn('Failed to sync schema for object', {
+              object: obj.name,
+              tableName,
+              driver: driver.name,
+              error: e instanceof Error ? e.message : String(e),
+            });
+          }
+        }
       }
     }
 

package/src/protocol-data.test.ts

@@ -25,87 +25,88 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
     // ═══════════════════════════════════════════════════════════════
 
     describe('findData', () => {
-        it('should normalize expand string to populate array', async () => {
-            await protocol.findData({ object: 'order_item', query: { expand: 'order,product' } });
+        it('should normalize $expand (OData) string to expand Record', async () => {
+            await protocol.findData({ object: 'order_item', query: { $expand: 'order,product' } });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'order_item',
                 expect.objectContaining({
-                    populate: ['order', 'product'],
+                    expand: { order: { object: 'order' }, product: { object: 'product' } },
                 }),
             );
-            // expand should be deleted from options
+            // $expand should be deleted from options
             const callArgs = mockEngine.find.mock.calls[0][1];
-            expect(callArgs.expand).toBeUndefined();
             expect(callArgs.$expand).toBeUndefined();
         });
 
-        it('should normalize $expand (OData) to populate array', async () => {
+        it('should normalize $expand (OData) with different fields to expand Record', async () => {
             await protocol.findData({ object: 'task', query: { $expand: 'assignee,project' } });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    populate: ['assignee', 'project'],
+                    expand: { assignee: { object: 'assignee' }, project: { object: 'project' } },
                 }),
             );
         });
 
-        it('should pass populate array as-is if already an array', async () => {
+        it('should normalize populate array to expand Record', async () => {
             await protocol.findData({ object: 'task', query: { populate: ['assignee'] } });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    populate: ['assignee'],
+                    expand: { assignee: { object: 'assignee' } },
                 }),
             );
         });
 
-        it('should normalize populate string to array', async () => {
+        it('should normalize populate string to expand Record', async () => {
             await protocol.findData({ object: 'task', query: { populate: 'assignee,project' } });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    populate: ['assignee', 'project'],
+                    expand: { assignee: { object: 'assignee' }, project: { object: 'project' } },
                 }),
             );
         });
 
-        it('should prefer explicit populate over expand', async () => {
+        it('should prefer populate names over expand string when both provided', async () => {
             await protocol.findData({
                 object: 'task',
                 query: { populate: ['assignee'], expand: 'project' },
             });
 
-            // populate takes precedence; expand is not converted
-            expect(mockEngine.find).toHaveBeenCalledWith(
-                'task',
-                expect.objectContaining({
-                    populate: ['assignee'],
-                }),
-            );
+            // populate names take precedence; the non-object expand string is
+            // cleaned up first, then populate-derived names create the Record.
+            const callArgs = mockEngine.find.mock.calls[0][1];
+            expect(callArgs.populate).toBeUndefined();
+            expect(callArgs.$expand).toBeUndefined();
+            expect(callArgs.expand).toEqual({ assignee: { object: 'assignee' } });
         });
 
-        it('should normalize expand array to populate array', async () => {
-            await protocol.findData({ object: 'task', query: { expand: ['owner', 'team'] } });
+        it('should pass expand Record object through as-is', async () => {
+            await protocol.findData({
+                object: 'task',
+                query: { expand: { owner: { object: 'owner' }, team: { object: 'team' } } },
+            });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    populate: ['owner', 'team'],
+                    expand: { owner: { object: 'owner' }, team: { object: 'team' } },
                 }),
             );
         });
 
-        it('should normalize select string to array', async () => {
+        it('should normalize select string to fields array', async () => {
             await protocol.findData({ object: 'task', query: { select: 'name,status,assignee' } });
 
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    select: ['name', 'status', 'assignee'],
+                    fields: ['name', 'status', 'assignee'],
                 }),
             );
         });
@@ -116,8 +117,8 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.find).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    top: 10,
-                    skip: 20,
+                    limit: 10,
+                    offset: 20,
                 }),
             );
         });
@@ -148,7 +149,7 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
     // ═══════════════════════════════════════════════════════════════
 
     describe('getData', () => {
-        it('should convert expand string to populate array', async () => {
+        it('should convert expand string to expand Record', async () => {
             mockEngine.findOne.mockResolvedValue({ id: 'oi_1', name: 'Item 1' });
 
             await protocol.getData({ object: 'order_item', id: 'oi_1', expand: 'order,product' });
@@ -156,13 +157,13 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'order_item',
                 expect.objectContaining({
-                    filter: { id: 'oi_1' },
-                    populate: ['order', 'product'],
+                    where: { id: 'oi_1' },
+                    expand: { order: { object: 'order' }, product: { object: 'product' } },
                 }),
             );
         });
 
-        it('should convert expand array to populate array', async () => {
+        it('should convert expand array to expand Record', async () => {
             mockEngine.findOne.mockResolvedValue({ id: 't1' });
 
             await protocol.getData({ object: 'task', id: 't1', expand: ['assignee', 'project'] });
@@ -170,12 +171,13 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    populate: ['assignee', 'project'],
+                    where: { id: 't1' },
+                    expand: { assignee: { object: 'assignee' }, project: { object: 'project' } },
                 }),
             );
         });
 
-        it('should convert select string to array', async () => {
+        it('should convert select string to fields array', async () => {
             mockEngine.findOne.mockResolvedValue({ id: 't1', name: 'Test' });
 
             await protocol.getData({ object: 'task', id: 't1', select: 'name,status' });
@@ -183,12 +185,13 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'task',
                 expect.objectContaining({
-                    select: ['name', 'status'],
+                    where: { id: 't1' },
+                    fields: ['name', 'status'],
                 }),
             );
         });
 
-        it('should pass both expand and select together', async () => {
+        it('should pass both expand and fields together', async () => {
             mockEngine.findOne.mockResolvedValue({ id: 'oi_1' });
 
             await protocol.getData({
@@ -201,9 +204,9 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'order_item',
                 expect.objectContaining({
-                    filter: { id: 'oi_1' },
-                    populate: ['order'],
-                    select: ['name', 'total'],
+                    where: { id: 'oi_1' },
+                    expand: { order: { object: 'order' } },
+                    fields: ['name', 'total'],
                 }),
             );
         });
@@ -215,7 +218,7 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
 
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'task',
-                { filter: { id: 't1' } },
+                { where: { id: 't1' } },
             );
         });
 

package/src/protocol-discovery.test.ts

@@ -92,7 +92,7 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     
     // Core services should always be available
     expect(discovery.services.metadata.enabled).toBe(true);
-    expect(discovery.services.metadata.status).toBe('degraded');
+    expect(discovery.services.metadata.status).toBe('available');
     expect(discovery.services.data.enabled).toBe(true);
     expect(discovery.services.data.status).toBe('available');
     expect(discovery.services.analytics.enabled).toBe(true);
@@ -148,14 +148,14 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     expect(discovery.capabilities).toBeDefined();
     // workflow is registered but doesn't map to a well-known capability directly
     expect(discovery.services.workflow.enabled).toBe(true);
-    // All well-known capabilities should be false since workflow doesn't map to any
-    expect(discovery.capabilities!.feed).toBe(false);
-    expect(discovery.capabilities!.comments).toBe(false);
-    expect(discovery.capabilities!.automation).toBe(false);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(false);
-    expect(discovery.capabilities!.export).toBe(false);
-    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+    // All well-known capabilities should be disabled since workflow doesn't map to any
+    expect(discovery.capabilities!.feed).toEqual({ enabled: false });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: false });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: false });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: false });
+    expect(discovery.capabilities!.export).toEqual({ enabled: false });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: false });
   });
 
   it('should set all capabilities to false when no services are registered', async () => {
@@ -163,13 +163,13 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     const discovery = await protocol.getDiscovery();
 
     expect(discovery.capabilities).toBeDefined();
-    expect(discovery.capabilities!.feed).toBe(false);
-    expect(discovery.capabilities!.comments).toBe(false);
-    expect(discovery.capabilities!.automation).toBe(false);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(false);
-    expect(discovery.capabilities!.export).toBe(false);
-    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+    expect(discovery.capabilities!.feed).toEqual({ enabled: false });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: false });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: false });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: false });
+    expect(discovery.capabilities!.export).toEqual({ enabled: false });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: false });
   });
 
   it('should dynamically set capabilities based on registered services', async () => {
@@ -182,13 +182,13 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.feed).toBe(true);
-    expect(discovery.capabilities!.comments).toBe(true);
-    expect(discovery.capabilities!.automation).toBe(true);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(true);
-    expect(discovery.capabilities!.export).toBe(true);
-    expect(discovery.capabilities!.chunkedUpload).toBe(true);
+    expect(discovery.capabilities!.feed).toEqual({ enabled: true });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: true });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: true });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: true });
+    expect(discovery.capabilities!.export).toEqual({ enabled: true });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: true });
   });
 
   it('should enable cron capability when job service is registered', async () => {
@@ -198,7 +198,7 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.cron).toBe(true);
+    expect(discovery.capabilities!.cron).toEqual({ enabled: true });
   });
 
   it('should enable export capability when queue service is registered', async () => {
@@ -208,6 +208,6 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.export).toBe(true);
+    expect(discovery.capabilities!.export).toEqual({ enabled: true });
   });
 });