@objectstack/objectql 3.2.1 → 3.2.3

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
         });
     }