@objectstack/objectql 3.2.1 → 3.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/objectql",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "license": "Apache-2.0",
   "description": "Isomorphic ObjectQL Engine for ObjectStack",
   "main": "dist/index.js",
@@ -13,9 +13,9 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "3.2.1",
-    "@objectstack/core": "3.2.1",
-    "@objectstack/types": "3.2.1"
+    "@objectstack/core": "3.2.2",
+    "@objectstack/spec": "3.2.2",
+    "@objectstack/types": "3.2.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/engine.test.ts

@@ -239,20 +239,20 @@ describe('ObjectQL Engine', () => {
             // Primary find returns tasks with assignee IDs
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', title: 'Task 1', assignee: 'u1' },
-                    { _id: 't2', title: 'Task 2', assignee: 'u2' },
+                    { id: 't1', title: 'Task 1', assignee: 'u1' },
+                    { id: 't2', title: 'Task 2', assignee: 'u2' },
                 ])
                 // Second call (expand): returns user records
                 .mockResolvedValueOnce([
-                    { _id: 'u1', name: 'Alice' },
-                    { _id: 'u2', name: 'Bob' },
+                    { id: 'u1', name: 'Alice' },
+                    { id: 'u2', name: 'Bob' },
                 ]);
 
             const result = await engine.find('task', { populate: ['assignee'] });
 
             expect(result).toHaveLength(2);
-            expect(result[0].assignee).toEqual({ _id: 'u1', name: 'Alice' });
-            expect(result[1].assignee).toEqual({ _id: 'u2', name: 'Bob' });
+            expect(result[0].assignee).toEqual({ id: 'u1', name: 'Alice' });
+            expect(result[1].assignee).toEqual({ id: 'u2', name: 'Bob' });
 
             // Verify the expand query used $in
             expect(mockDriver.find).toHaveBeenCalledTimes(2);
@@ -260,7 +260,7 @@ describe('ObjectQL Engine', () => {
                 'user',
                 expect.objectContaining({
                     object: 'user',
-                    where: { _id: { $in: ['u1', 'u2'] } },
+                    where: { id: { $in: ['u1', 'u2'] } },
                 }),
             );
         });
@@ -282,14 +282,14 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 'oi1', order: 'o1' },
+                    { id: 'oi1', order: 'o1' },
                 ])
                 .mockResolvedValueOnce([
-                    { _id: 'o1', total: 100 },
+                    { id: 'o1', total: 100 },
                 ]);
 
             const result = await engine.find('order_item', { populate: ['order'] });
-            expect(result[0].order).toEqual({ _id: 'o1', total: 100 });
+            expect(result[0].order).toEqual({ id: 'o1', total: 100 });
         });
 
         it('should skip expand for fields without reference definition', async () => {
@@ -301,7 +301,7 @@ describe('ObjectQL Engine', () => {
             } as any);
 
             vi.mocked(mockDriver.find).mockResolvedValueOnce([
-                { _id: 't1', title: 'Task 1' },
+                { id: 't1', title: 'Task 1' },
             ]);
 
             const result = await engine.find('task', { populate: ['title'] });
@@ -313,7 +313,7 @@ describe('ObjectQL Engine', () => {
             vi.mocked(SchemaRegistry.getObject).mockReturnValue(undefined);
 
             vi.mocked(mockDriver.find).mockResolvedValueOnce([
-                { _id: 't1', assignee: 'u1' },
+                { id: 't1', assignee: 'u1' },
             ]);
 
             const result = await engine.find('task', { populate: ['assignee'] });
@@ -338,16 +338,16 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', assignee: null },
-                    { _id: 't2', assignee: 'u1' },
+                    { id: 't1', assignee: null },
+                    { id: 't2', assignee: 'u1' },
                 ])
                 .mockResolvedValueOnce([
-                    { _id: 'u1', name: 'Alice' },
+                    { id: 'u1', name: 'Alice' },
                 ]);
 
             const result = await engine.find('task', { populate: ['assignee'] });
             expect(result[0].assignee).toBeNull();
-            expect(result[1].assignee).toEqual({ _id: 'u1', name: 'Alice' });
+            expect(result[1].assignee).toEqual({ id: 'u1', name: 'Alice' });
         });
 
         it('should de-duplicate foreign key IDs in batch query', async () => {
@@ -367,13 +367,13 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', assignee: 'u1' },
-                    { _id: 't2', assignee: 'u1' }, // Same user
-                    { _id: 't3', assignee: 'u2' },
+                    { id: 't1', assignee: 'u1' },
+                    { id: 't2', assignee: 'u1' }, // Same user
+                    { id: 't3', assignee: 'u2' },
                 ])
                 .mockResolvedValueOnce([
-                    { _id: 'u1', name: 'Alice' },
-                    { _id: 'u2', name: 'Bob' },
+                    { id: 'u1', name: 'Alice' },
+                    { id: 'u2', name: 'Bob' },
                 ]);
 
             const result = await engine.find('task', { populate: ['assignee'] });
@@ -382,11 +382,11 @@ describe('ObjectQL Engine', () => {
             expect(mockDriver.find).toHaveBeenLastCalledWith(
                 'user',
                 expect.objectContaining({
-                    where: { _id: { $in: ['u1', 'u2'] } },
+                    where: { id: { $in: ['u1', 'u2'] } },
                 }),
             );
-            expect(result[0].assignee).toEqual({ _id: 'u1', name: 'Alice' });
-            expect(result[1].assignee).toEqual({ _id: 'u1', name: 'Alice' });
+            expect(result[0].assignee).toEqual({ id: 'u1', name: 'Alice' });
+            expect(result[1].assignee).toEqual({ id: 'u1', name: 'Alice' });
         });
 
         it('should keep raw ID when referenced record not found', async () => {
@@ -406,7 +406,7 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', assignee: 'u_deleted' },
+                    { id: 't1', assignee: 'u_deleted' },
                 ])
                 .mockResolvedValueOnce([]); // No records found
 
@@ -436,15 +436,15 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', assignee: 'u1', project: 'p1' },
+                    { id: 't1', assignee: 'u1', project: 'p1' },
                 ])
-                .mockResolvedValueOnce([{ _id: 'u1', name: 'Alice' }])
-                .mockResolvedValueOnce([{ _id: 'p1', name: 'Project X' }]);
+                .mockResolvedValueOnce([{ id: 'u1', name: 'Alice' }])
+                .mockResolvedValueOnce([{ id: 'p1', name: 'Project X' }]);
 
             const result = await engine.find('task', { populate: ['assignee', 'project'] });
 
-            expect(result[0].assignee).toEqual({ _id: 'u1', name: 'Alice' });
-            expect(result[0].project).toEqual({ _id: 'p1', name: 'Project X' });
+            expect(result[0].assignee).toEqual({ id: 'u1', name: 'Alice' });
+            expect(result[0].project).toEqual({ id: 'p1', name: 'Project X' });
             expect(mockDriver.find).toHaveBeenCalledTimes(3);
         });
 
@@ -464,15 +464,15 @@ describe('ObjectQL Engine', () => {
             });
 
             vi.mocked(mockDriver.findOne as any).mockResolvedValueOnce(
-                { _id: 't1', title: 'Task 1', assignee: 'u1' },
+                { id: 't1', title: 'Task 1', assignee: 'u1' },
             );
             vi.mocked(mockDriver.find).mockResolvedValueOnce([
-                { _id: 'u1', name: 'Alice' },
+                { id: 'u1', name: 'Alice' },
             ]);
 
             const result = await engine.findOne('task', { populate: ['assignee'] });
 
-            expect(result.assignee).toEqual({ _id: 'u1', name: 'Alice' });
+            expect(result.assignee).toEqual({ id: 'u1', name: 'Alice' });
         });
 
         it('should handle already-expanded objects (skip re-expansion)', async () => {
@@ -492,14 +492,14 @@ describe('ObjectQL Engine', () => {
 
             // Driver returns an already-expanded object
             vi.mocked(mockDriver.find).mockResolvedValueOnce([
-                { _id: 't1', assignee: { _id: 'u1', name: 'Alice' } },
+                { id: 't1', assignee: { id: 'u1', name: 'Alice' } },
             ]);
 
             const result = await engine.find('task', { populate: ['assignee'] });
 
             // No expand query should have been made — the value was already an object
             expect(mockDriver.find).toHaveBeenCalledTimes(1);
-            expect(result[0].assignee).toEqual({ _id: 'u1', name: 'Alice' });
+            expect(result[0].assignee).toEqual({ id: 'u1', name: 'Alice' });
         });
 
         it('should gracefully handle expand errors and keep raw IDs', async () => {
@@ -519,7 +519,7 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', assignee: 'u1' },
+                    { id: 't1', assignee: 'u1' },
                 ])
                 .mockRejectedValueOnce(new Error('Driver connection failed'));
 
@@ -544,17 +544,17 @@ describe('ObjectQL Engine', () => {
 
             vi.mocked(mockDriver.find)
                 .mockResolvedValueOnce([
-                    { _id: 't1', watchers: ['u1', 'u2'] },
+                    { id: 't1', watchers: ['u1', 'u2'] },
                 ])
                 .mockResolvedValueOnce([
-                    { _id: 'u1', name: 'Alice' },
-                    { _id: 'u2', name: 'Bob' },
+                    { id: 'u1', name: 'Alice' },
+                    { id: 'u2', name: 'Bob' },
                 ]);
 
             const result = await engine.find('task', { populate: ['watchers'] });
             expect(result[0].watchers).toEqual([
-                { _id: 'u1', name: 'Alice' },
-                { _id: 'u2', name: 'Bob' },
+                { id: 'u1', name: 'Alice' },
+                { id: 'u2', name: 'Bob' },
             ]);
         });
 
@@ -570,14 +570,14 @@ describe('ObjectQL Engine', () => {
             });
 
             vi.mocked(mockDriver.find)
-                .mockResolvedValueOnce([{ _id: 't1', project: 'p1' }])  // find task
-                .mockResolvedValueOnce([{ _id: 'p1', org: 'o1' }]);     // expand project (depth 0)
+                .mockResolvedValueOnce([{ id: 't1', project: 'p1' }])  // find task
+                .mockResolvedValueOnce([{ id: 'p1', org: 'o1' }]);     // expand project (depth 0)
                 // org should NOT be expanded further — flat populate doesn't create nested expand
 
             const result = await engine.find('task', { populate: ['project'] });
 
             // Project expanded, but org inside project remains as raw ID
-            expect(result[0].project).toEqual({ _id: 'p1', org: 'o1' });
+            expect(result[0].project).toEqual({ id: 'p1', org: 'o1' });
             expect(mockDriver.find).toHaveBeenCalledTimes(2); // Only primary + 1 expand query
         });
 
@@ -588,11 +588,11 @@ describe('ObjectQL Engine', () => {
             } as any);
 
             vi.mocked(mockDriver.find).mockResolvedValueOnce([
-                { _id: 't1', title: 'Task 1' },
+                { id: 't1', title: 'Task 1' },
             ]);
 
             const result = await engine.find('task', {});
-            expect(result).toEqual([{ _id: 't1', title: 'Task 1' }]);
+            expect(result).toEqual([{ id: 't1', title: 'Task 1' }]);
             expect(mockDriver.find).toHaveBeenCalledTimes(1);
         });
     });

package/src/engine.ts

@@ -681,7 +681,7 @@ export class ObjectQL implements IDataEngine {
       try {
         const relatedQuery: QueryAST = {
           object: referenceObject,
-          where: { _id: { $in: uniqueIds } },
+          where: { id: { $in: uniqueIds } },
           ...(nestedAST.fields ? { fields: nestedAST.fields } : {}),
           ...(nestedAST.orderBy ? { orderBy: nestedAST.orderBy } : {}),
         };
@@ -692,7 +692,7 @@ export class ObjectQL implements IDataEngine {
         // Build a lookup map: id → record
         const recordMap = new Map<string, any>();
         for (const rec of relatedRecords) {
-          const id = rec._id ?? rec.id;
+          const id = rec.id;
           if (id != null) recordMap.set(String(id), rec);
         }
 
@@ -707,7 +707,7 @@ export class ObjectQL implements IDataEngine {
           // Rebuild map with expanded records
           recordMap.clear();
           for (const rec of expandedRelated) {
-            const id = rec._id ?? rec.id;
+            const id = rec.id;
             if (id != null) recordMap.set(String(id), rec);
           }
         }
@@ -921,10 +921,9 @@ export class ObjectQL implements IDataEngine {
      const driver = this.getDriver(object);
      
      // 1. Extract ID from data or filter if it's a single update by ID
-     let id = data.id || data._id;
+     let id = data.id;
      if (!id && options?.filter) {
          if (typeof options.filter === 'string') id = options.filter;
-         else if (options.filter._id) id = options.filter._id;
          else if (options.filter.id) id = options.filter.id;
      }
 
@@ -980,7 +979,6 @@ export class ObjectQL implements IDataEngine {
     let id: any = undefined;
     if (options?.filter) {
          if (typeof options.filter === 'string') id = options.filter;
-         else if (options.filter._id) id = options.filter._id;
          else if (options.filter.id) id = options.filter.id;
     }
 
@@ -1043,7 +1041,7 @@ export class ObjectQL implements IDataEngine {
            return driver.count(object, ast);
        }
        // Fallback to find().length
-       const res = await this.find(object, { filter: query?.filter, select: ['_id'] });
+       const res = await this.find(object, { filter: query?.filter, select: ['id'] });
        return res.length;
      });
 
@@ -1335,8 +1333,8 @@ export class ObjectRepository {
 
   /** Update a single record by ID */
   async updateById(id: string | number, data: any): Promise<any> {
-    return this.engine.update(this.objectName, { ...data, _id: id }, {
-      filter: { _id: id },
+    return this.engine.update(this.objectName, { ...data, id: id }, {
+      filter: { id: id },
       context: this.context,
     });
   }
@@ -1351,7 +1349,7 @@ export class ObjectRepository {
   /** Delete a single record by ID */
   async deleteById(id: string | number): Promise<any> {
     return this.engine.delete(this.objectName, {
-      filter: { _id: id },
+      filter: { id: id },
       context: this.context,
     });
   }

package/src/plugin.ts

@@ -129,35 +129,35 @@ export class ObjectQLPlugin implements Plugin {
   }
 
   /**
-   * Register built-in audit hooks for auto-stamping createdBy/modifiedBy
+   * Register built-in audit hooks for auto-stamping created_by/updated_by
    * and fetching previousData for update/delete operations.
    */
   private registerAuditHooks(ctx: PluginContext) {
     if (!this.ql) return;
 
-    // Auto-stamp createdBy/modifiedBy on insert
+    // Auto-stamp created_by/updated_by on insert
     this.ql.registerHook('beforeInsert', async (hookCtx) => {
       if (hookCtx.session?.userId && hookCtx.input?.data) {
         const data = hookCtx.input.data as Record<string, any>;
         if (typeof data === 'object' && data !== null) {
           data.created_by = data.created_by ?? hookCtx.session.userId;
-          data.modified_by = hookCtx.session.userId;
+          data.updated_by = hookCtx.session.userId;
           data.created_at = data.created_at ?? new Date().toISOString();
-          data.modified_at = new Date().toISOString();
+          data.updated_at = new Date().toISOString();
           if (hookCtx.session.tenantId) {
-            data.space_id = data.space_id ?? hookCtx.session.tenantId;
+            data.tenant_id = data.tenant_id ?? hookCtx.session.tenantId;
           }
         }
       }
     }, { object: '*', priority: 10 });
 
-    // Auto-stamp modifiedBy on update
+    // Auto-stamp updated_by on update
     this.ql.registerHook('beforeUpdate', async (hookCtx) => {
       if (hookCtx.session?.userId && hookCtx.input?.data) {
         const data = hookCtx.input.data as Record<string, any>;
         if (typeof data === 'object' && data !== null) {
-          data.modified_by = hookCtx.session.userId;
-          data.modified_at = new Date().toISOString();
+          data.updated_by = hookCtx.session.userId;
+          data.updated_at = new Date().toISOString();
         }
       }
     }, { object: '*', priority: 10 });
@@ -167,7 +167,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 }
+            filter: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -183,7 +183,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 }
+            filter: { id: hookCtx.input.id }
           });
           if (existing) {
             hookCtx.previous = existing;
@@ -194,11 +194,11 @@ export class ObjectQLPlugin implements Plugin {
       }
     }, { object: '*', priority: 5 });
 
-    ctx.logger.debug('Audit hooks registered (createdBy/modifiedBy, previousData)');
+    ctx.logger.debug('Audit hooks registered (created_by/updated_by, previousData)');
   }
 
   /**
-   * Register tenant isolation middleware that auto-injects space_id filter
+   * Register tenant isolation middleware that auto-injects tenant_id filter
    * for multi-tenant operations.
    */
   private registerTenantMiddleware(ctx: PluginContext) {
@@ -210,10 +210,10 @@ export class ObjectQLPlugin implements Plugin {
         return next();
       }
 
-      // Read operations: inject space_id filter into AST
+      // Read operations: inject tenant_id filter into AST
       if (['find', 'findOne', 'count', 'aggregate'].includes(opCtx.operation)) {
         if (opCtx.ast) {
-          const tenantFilter = { space_id: opCtx.context.tenantId };
+          const tenantFilter = { tenant_id: opCtx.context.tenantId };
           if (opCtx.ast.where) {
             opCtx.ast.where = { $and: [opCtx.ast.where, tenantFilter] };
           } else {

package/src/protocol-data.test.ts

@@ -129,14 +129,14 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
         });
 
         it('should return records and standard response shape', async () => {
-            mockEngine.find.mockResolvedValue([{ _id: 't1', name: 'Task 1' }]);
+            mockEngine.find.mockResolvedValue([{ id: 't1', name: 'Task 1' }]);
 
             const result = await protocol.findData({ object: 'task', query: {} });
 
             expect(result).toEqual(
                 expect.objectContaining({
                     object: 'task',
-                    records: [{ _id: 't1', name: 'Task 1' }],
+                    records: [{ id: 't1', name: 'Task 1' }],
                     total: 1,
                 }),
             );
@@ -149,21 +149,21 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
 
     describe('getData', () => {
         it('should convert expand string to populate array', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 'oi_1', name: 'Item 1' });
+            mockEngine.findOne.mockResolvedValue({ id: 'oi_1', name: 'Item 1' });
 
             await protocol.getData({ object: 'order_item', id: 'oi_1', expand: 'order,product' });
 
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'order_item',
                 expect.objectContaining({
-                    filter: { _id: 'oi_1' },
+                    filter: { id: 'oi_1' },
                     populate: ['order', 'product'],
                 }),
             );
         });
 
         it('should convert expand array to populate array', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 't1' });
+            mockEngine.findOne.mockResolvedValue({ id: 't1' });
 
             await protocol.getData({ object: 'task', id: 't1', expand: ['assignee', 'project'] });
 
@@ -176,7 +176,7 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
         });
 
         it('should convert select string to array', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 't1', name: 'Test' });
+            mockEngine.findOne.mockResolvedValue({ id: 't1', name: 'Test' });
 
             await protocol.getData({ object: 'task', id: 't1', select: 'name,status' });
 
@@ -189,7 +189,7 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
         });
 
         it('should pass both expand and select together', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 'oi_1' });
+            mockEngine.findOne.mockResolvedValue({ id: 'oi_1' });
 
             await protocol.getData({
                 object: 'order_item',
@@ -201,7 +201,7 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'order_item',
                 expect.objectContaining({
-                    filter: { _id: 'oi_1' },
+                    filter: { id: 'oi_1' },
                     populate: ['order'],
                     select: ['name', 'total'],
                 }),
@@ -209,25 +209,25 @@ describe('ObjectStackProtocolImplementation - Data Operations', () => {
         });
 
         it('should work without expand or select', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 't1' });
+            mockEngine.findOne.mockResolvedValue({ id: 't1' });
 
             await protocol.getData({ object: 'task', id: 't1' });
 
             expect(mockEngine.findOne).toHaveBeenCalledWith(
                 'task',
-                { filter: { _id: 't1' } },
+                { filter: { id: 't1' } },
             );
         });
 
         it('should return standard GetDataResponse shape', async () => {
-            mockEngine.findOne.mockResolvedValue({ _id: 'oi_1', name: 'Item 1' });
+            mockEngine.findOne.mockResolvedValue({ id: 'oi_1', name: 'Item 1' });
 
             const result = await protocol.getData({ object: 'order_item', id: 'oi_1' });
 
             expect(result).toEqual({
                 object: 'order_item',
                 id: 'oi_1',
-                record: { _id: 'oi_1', name: 'Item 1' },
+                record: { id: 'oi_1', name: 'Item 1' },
             });
         });
 

package/src/protocol.ts

@@ -246,7 +246,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
              // Form View Generation
              // Simple single-section layout for now
              const formFields = fieldKeys
-                .filter(k => k !== 'id' && k !== 'created_at' && k !== 'modified_at' && !fields[k].hidden)
+                .filter(k => k !== 'id' && k !== 'created_at' && k !== 'updated_at' && !fields[k].hidden)
                 .map(f => ({
                     field: f,
                     label: fields[f]?.label,
@@ -361,7 +361,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
 
     async getData(request: { object: string, id: string, expand?: string | string[], select?: string | string[] }) {
         const queryOptions: any = {
-            filter: { _id: request.id }
+            filter: { id: request.id }
         };
 
         // Support select for single-record retrieval
@@ -393,14 +393,14 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         const result = await this.engine.insert(request.object, request.data);
         return {
             object: request.object,
-            id: result._id || result.id,
+            id: result.id,
             record: result
         };
     }
 
     async updateData(request: { object: string, id: string, data: any }) {
         // Adapt: update(obj, id, data) -> update(obj, data, options)
-        const result = await this.engine.update(request.object, request.data, { filter: { _id: request.id } });
+        const result = await this.engine.update(request.object, request.data, { filter: { id: request.id } });
         return {
             object: request.object,
             id: request.id,
@@ -410,7 +410,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
 
     async deleteData(request: { object: string, id: string }) {
         // Adapt: delete(obj, id) -> delete(obj, options)
-        await this.engine.delete(request.object, { filter: { _id: request.id } });
+        await this.engine.delete(request.object, { filter: { id: request.id } });
         return {
             object: request.object,
             id: request.id,
@@ -478,13 +478,13 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                 switch (operation) {
                     case 'create': {
                         const created = await this.engine.insert(object, record.data || record);
-                        results.push({ id: created._id || created.id, success: true, record: created });
+                        results.push({ id: created.id, success: true, record: created });
                         succeeded++;
                         break;
                     }
                     case 'update': {
                         if (!record.id) throw new Error('Record id is required for update');
-                        const updated = await this.engine.update(object, record.data || {}, { filter: { _id: record.id } });
+                        const updated = await this.engine.update(object, record.data || {}, { filter: { id: record.id } });
                         results.push({ id: record.id, success: true, record: updated });
                         succeeded++;
                         break;
@@ -493,28 +493,28 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                         // Try update first, then create if not found
                         if (record.id) {
                             try {
-                                const existing = await this.engine.findOne(object, { filter: { _id: record.id } });
+                                const existing = await this.engine.findOne(object, { filter: { id: record.id } });
                                 if (existing) {
-                                    const updated = await this.engine.update(object, record.data || {}, { filter: { _id: record.id } });
+                                    const updated = await this.engine.update(object, record.data || {}, { filter: { id: record.id } });
                                     results.push({ id: record.id, success: true, record: updated });
                                 } else {
-                                    const created = await this.engine.insert(object, { _id: record.id, ...(record.data || {}) });
-                                    results.push({ id: created._id || created.id, success: true, record: created });
+                                    const created = await this.engine.insert(object, { id: record.id, ...(record.data || {}) });
+                                    results.push({ id: created.id, success: true, record: created });
                                 }
                             } catch {
-                                const created = await this.engine.insert(object, { _id: record.id, ...(record.data || {}) });
-                                results.push({ id: created._id || created.id, success: true, record: created });
+                                const created = await this.engine.insert(object, { id: record.id, ...(record.data || {}) });
+                                results.push({ id: created.id, success: true, record: created });
                             }
                         } else {
                             const created = await this.engine.insert(object, record.data || record);
-                            results.push({ id: created._id || created.id, success: true, record: created });
+                            results.push({ id: created.id, success: true, record: created });
                         }
                         succeeded++;
                         break;
                     }
                     case 'delete': {
                         if (!record.id) throw new Error('Record id is required for delete');
-                        await this.engine.delete(object, { filter: { _id: record.id } });
+                        await this.engine.delete(object, { filter: { id: record.id } });
                         results.push({ id: record.id, success: true });
                         succeeded++;
                         break;
@@ -563,7 +563,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
 
         for (const record of records) {
             try {
-                const updated = await this.engine.update(object, record.data, { filter: { _id: record.id } });
+                const updated = await this.engine.update(object, record.data, { filter: { id: record.id } });
                 results.push({ id: record.id, success: true, record: updated });
                 succeeded++;
             } catch (err: any) {
@@ -765,7 +765,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
     async deleteManyData(request: DeleteManyDataRequest): Promise<any> {
         // This expects deleting by IDs.
         return this.engine.delete(request.object, {
-            filter: { _id: { $in: request.ids } },
+            filter: { id: { $in: request.ids } },
             ...request.options
         });
     }