@objectql/server 1.7.2 → 1.8.0

package/src/server.ts

@@ -58,17 +58,27 @@ export class ObjectQLServer {
             switch (req.op) {
                 case 'find':
                     result = await repo.find(req.args);
-                    break;
+                    // For find operations, return items array with pagination metadata
+                    return this.buildListResponse(result, req.args, repo);
                 case 'findOne':
                     // Support both string ID and query object
                     result = await repo.findOne(req.args);
-                    break;
+                    if (result) {
+                        return { ...result, '@type': req.object };
+                    }
+                    return result;
                 case 'create':
                     result = await repo.create(req.args);
-                    break;
+                    if (result) {
+                        return { ...result, '@type': req.object };
+                    }
+                    return result;
                 case 'update':
                     result = await repo.update(req.args.id, req.args.data);
-                    break;
+                    if (result) {
+                        return { ...result, '@type': req.object };
+                    }
+                    return result;
                 case 'delete':
                     result = await repo.delete(req.args.id);
                     if (!result) {
@@ -77,12 +87,15 @@ export class ObjectQLServer {
                             `Record with id '${req.args.id}' not found for delete`
                         );
                     }
-                    // Return standardized delete response on success
-                    result = { id: req.args.id, deleted: true };
-                    break;
+                    // Return standardized delete response with object type
+                    return { 
+                        id: req.args.id,
+                        deleted: true,
+                        '@type': req.object
+                    };
                 case 'count':
                     result = await repo.count(req.args);
-                    break;
+                    return { count: result, '@type': req.object };
                 case 'action':
                     // Map generic args to ActionContext
                     result = await app.executeAction(req.object, req.args.action, {
@@ -90,7 +103,52 @@ export class ObjectQLServer {
                          id: req.args.id,
                          input: req.args.input || req.args.params // Support both for convenience
                     });
-                    break;
+                    if (result && typeof result === 'object') {
+                        return { ...result, '@type': req.object };
+                    }
+                    return result;
+                case 'createMany':
+                    // Bulk create operation
+                    if (!Array.isArray(req.args)) {
+                        return this.errorResponse(
+                            ErrorCode.INVALID_REQUEST,
+                            'createMany expects args to be an array of records'
+                        );
+                    }
+                    result = await repo.createMany(req.args);
+                    return { 
+                        items: result,
+                        count: Array.isArray(result) ? result.length : 0,
+                        '@type': req.object
+                    };
+                case 'updateMany':
+                    // Bulk update operation
+                    // args should be { filters, data }
+                    if (!req.args || typeof req.args !== 'object' || !req.args.data) {
+                        return this.errorResponse(
+                            ErrorCode.INVALID_REQUEST,
+                            'updateMany expects args to be an object with { filters, data }'
+                        );
+                    }
+                    result = await repo.updateMany(req.args.filters || {}, req.args.data);
+                    return { 
+                        count: result,
+                        '@type': req.object
+                    };
+                case 'deleteMany':
+                    // Bulk delete operation
+                    // args should be { filters }
+                    if (!req.args || typeof req.args !== 'object') {
+                        return this.errorResponse(
+                            ErrorCode.INVALID_REQUEST,
+                            'deleteMany expects args to be an object with { filters }'
+                        );
+                    }
+                    result = await repo.deleteMany(req.args.filters || {});
+                    return { 
+                        count: result,
+                        '@type': req.object
+                    };
                 default:
                     return this.errorResponse(
                         ErrorCode.INVALID_REQUEST,
@@ -98,13 +156,44 @@ export class ObjectQLServer {
                     );
             }
 
-            return { data: result };
-
         } catch (e: any) {
             return this.handleError(e);
         }
     }
 
+    /**
+     * Build a standardized list response with pagination metadata
+     */
+    private async buildListResponse(items: any[], args: any, repo: any): Promise<ObjectQLResponse> {
+        const response: ObjectQLResponse = {
+            items
+        };
+
+        // Calculate pagination metadata if limit/skip are present
+        if (args && (args.limit || args.skip)) {
+            const skip = args.skip || 0;
+            const limit = args.limit || items.length;
+            
+            // Get total count - use the same arguments as the query to ensure consistency
+            const total = await repo.count(args || {});
+            
+            const size = limit;
+            const page = limit > 0 ? Math.floor(skip / limit) + 1 : 1;
+            const pages = limit > 0 ? Math.ceil(total / limit) : 1;
+            const has_next = skip + items.length < total;
+
+            response.meta = {
+                total,
+                page,
+                size,
+                pages,
+                has_next
+            };
+        }
+
+        return response;
+    }
+
     /**
      * Handle errors and convert them to appropriate error responses
      */

package/src/types.ts

@@ -37,7 +37,7 @@ export interface ObjectQLRequest {
     };
     
     // The actual operation
-    op: 'find' | 'findOne' | 'create' | 'update' | 'delete' | 'count' | 'action';
+    op: 'find' | 'findOne' | 'create' | 'update' | 'delete' | 'count' | 'action' | 'createMany' | 'updateMany' | 'deleteMany';
     object: string;
     
     // Arguments
@@ -60,19 +60,35 @@ export interface ErrorDetails {
     [key: string]: unknown;
 }
 
+/**
+ * Pagination metadata
+ */
+export interface PaginationMeta {
+    total: number;        // Total number of records
+    page?: number;        // Current page number (1-indexed, e.g. page 1 corresponds to skip=0)
+    size?: number;        // Number of items per page
+    pages?: number;       // Total number of pages
+    has_next?: boolean;   // Whether there is a next page
+}
+
 /**
  * ObjectQL API response
  */
 export interface ObjectQLResponse {
-    data?: any;
+    // For list operations (find)
+    items?: any[];
+    
+    // Pagination metadata (for list operations)
+    meta?: PaginationMeta;
+    
+    // Error information
     error?: {
         code: ErrorCode | string;
         message: string;
-        details?: ErrorDetails;
-    };
-    meta?: {
-        total?: number;
-        page?: number;
-        per_page?: number;
+        details?: ErrorDetails | any; // Allow flexible details structure
     };
+    
+    // For single item operations, the response is the object itself with '@type' field
+    // This allows any additional fields from the actual data object
+    [key: string]: any;
 }

package/test/graphql.test.ts

@@ -0,0 +1,439 @@
+import request from 'supertest';
+import { createServer } from 'http';
+import { ObjectQL } from '@objectql/core';
+import { createGraphQLHandler } from '../src/adapters/graphql';
+import { Driver } from '@objectql/types';
+
+// Simple Mock Driver
+class MockDriver implements Driver {
+    private initialData: Record<string, any[]> = {
+        user: [
+            { _id: '1', name: 'Alice', email: 'alice@example.com', age: 30 },
+            { _id: '2', name: 'Bob', email: 'bob@example.com', age: 25 }
+        ],
+        task: [
+            { _id: 'task1', title: 'Task 1', status: 'open', priority: 'high' },
+            { _id: 'task2', title: 'Task 2', status: 'closed', priority: 'low' }
+        ]
+    };
+    private data: Record<string, any[]>;
+    private nextId = 3;
+
+    constructor() {
+        // Create a deep copy of initialData
+        this.data = JSON.parse(JSON.stringify(this.initialData));
+    }
+
+    reset() {
+        // Reset data to initial state
+        this.data = JSON.parse(JSON.stringify(this.initialData));
+        this.nextId = 3;
+    }
+
+    async init() {}
+    
+    async find(objectName: string, query: any) {
+        let items = this.data[objectName] || [];
+        
+        // Apply skip and limit if provided
+        if (query) {
+            if (query.skip) {
+                items = items.slice(query.skip);
+            }
+            if (query.limit) {
+                items = items.slice(0, query.limit);
+            }
+        }
+        
+        return items;
+    }
+    
+    async findOne(objectName: string, id: string | number, query?: any, options?: any) {
+        const items = this.data[objectName] || [];
+        if (id !== undefined && id !== null) {
+            const found = items.find(item => item._id === String(id));
+            return found || null;
+        }
+        return items[0] || null;
+    }
+    
+    async create(objectName: string, data: any) {
+        const newItem = { _id: String(this.nextId++), ...data };
+        if (!this.data[objectName]) {
+            this.data[objectName] = [];
+        }
+        this.data[objectName].push(newItem);
+        return newItem;
+    }
+    
+    // Note: update() returns the updated object to match the behavior of the SQL driver,
+    // which returns { id, ...data }. This is different from the affected row count pattern.
+    async update(objectName: string, id: string, data: any) {
+        const items = this.data[objectName] || [];
+        const index = items.findIndex(item => item._id === id);
+        if (index >= 0) {
+            this.data[objectName][index] = { ...items[index], ...data };
+            return this.data[objectName][index];
+        }
+        return null;
+    }
+    
+    async delete(objectName: string, id: string) {
+        const items = this.data[objectName] || [];
+        const index = items.findIndex(item => item._id === id);
+        if (index >= 0) {
+            this.data[objectName].splice(index, 1);
+            return 1;
+        }
+        return 0;
+    }
+    
+    async count(objectName: string, query: any) {
+        return (this.data[objectName] || []).length;
+    }
+    
+    async execute(sql: string) {}
+}
+
+describe('GraphQL API Adapter', () => {
+    let app: ObjectQL;
+    let server: any;
+    let handler: any;
+    let mockDriver: MockDriver;
+
+    beforeAll(async () => {
+        mockDriver = new MockDriver();
+        app = new ObjectQL({
+            datasources: {
+                default: mockDriver
+            }
+        });
+        
+        // Register user object schema
+        app.metadata.register('object', {
+            type: 'object',
+            id: 'user',
+            content: {
+                name: 'user',
+                label: 'User',
+                fields: {
+                    name: { type: 'text', label: 'Name' },
+                    email: { type: 'email', label: 'Email' },
+                    age: { type: 'number', label: 'Age' }
+                }
+            }
+        });
+
+        // Register task object schema
+        app.metadata.register('object', {
+            type: 'object',
+            id: 'task',
+            content: {
+                name: 'task',
+                label: 'Task',
+                fields: {
+                    title: { type: 'text', label: 'Title', required: true },
+                    status: { type: 'select', label: 'Status', options: ['open', 'closed'] },
+                    priority: { type: 'select', label: 'Priority', options: ['low', 'medium', 'high'] }
+                }
+            }
+        });
+
+        // Create handler and server once for all tests
+        handler = createGraphQLHandler(app);
+        server = createServer(handler);
+    });
+
+    beforeEach(() => {
+        // Reset mock data before each test
+        mockDriver.reset();
+    });
+
+    describe('Queries', () => {
+        it('should query a single user by ID', async () => {
+            const query = `
+                query {
+                    user(id: "1") {
+                        id
+                        name
+                        email
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data.user).toEqual({
+                id: '1',
+                name: 'Alice',
+                email: 'alice@example.com'
+            });
+        });
+
+        it('should query list of users', async () => {
+            const query = `
+                query {
+                    userList {
+                        id
+                        name
+                        email
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data.userList).toHaveLength(2);
+            expect(response.body.data.userList[0].name).toBe('Alice');
+        });
+
+        it('should support pagination with limit and skip', async () => {
+            const query = `
+                query {
+                    userList(limit: 1, skip: 1) {
+                        id
+                        name
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.userList).toHaveLength(1);
+            expect(response.body.data.userList[0].name).toBe('Bob');
+        });
+
+        it('should support field selection', async () => {
+            const query = `
+                query {
+                    userList(fields: ["name"]) {
+                        id
+                        name
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.userList).toBeDefined();
+        });
+
+        it('should query tasks', async () => {
+            const query = `
+                query {
+                    taskList {
+                        id
+                        title
+                        status
+                        priority
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.taskList).toHaveLength(2);
+            expect(response.body.data.taskList[0].title).toBe('Task 1');
+        });
+
+        it('should support GET requests with query parameter', async () => {
+            const query = encodeURIComponent('{ user(id: "1") { id name } }');
+
+            const response = await request(server)
+                .get(`/api/graphql?query=${query}`)
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.user.name).toBe('Alice');
+        });
+    });
+
+    describe('Mutations', () => {
+        it('should create a new user', async () => {
+            const mutation = `
+                mutation {
+                    createUser(input: { name: "Charlie", email: "charlie@example.com", age: 35 }) {
+                        id
+                        name
+                        email
+                        age
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query: mutation })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data.createUser.name).toBe('Charlie');
+            expect(response.body.data.createUser.email).toBe('charlie@example.com');
+            expect(response.body.data.createUser.id).toBeDefined();
+        });
+
+        it('should update an existing user', async () => {
+            const mutation = `
+                mutation {
+                    updateUser(id: "1", input: { name: "Alice Updated" }) {
+                        id
+                        name
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query: mutation })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data.updateUser.name).toBe('Alice Updated');
+        });
+
+        it('should delete a user', async () => {
+            const mutation = `
+                mutation {
+                    deleteUser(id: "2") {
+                        id
+                        deleted
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query: mutation })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data.deleteUser.id).toBe('2');
+            expect(response.body.data.deleteUser.deleted).toBe(true);
+        });
+
+        it('should create a task', async () => {
+            const mutation = `
+                mutation {
+                    createTask(input: { title: "New Task", status: "open", priority: "medium" }) {
+                        id
+                        title
+                        status
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query: mutation })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.createTask.title).toBe('New Task');
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should return error for invalid query', async () => {
+            const query = `query { invalid }`;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({ query })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.errors).toBeDefined();
+        });
+
+        it('should return error when query is missing', async () => {
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({})
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(400);
+            expect(response.body.errors).toBeDefined();
+            expect(response.body.errors[0].message).toContain('query');
+        });
+
+        it('should reject non-POST/GET methods', async () => {
+            const response = await request(server)
+                .put('/api/graphql')
+                .send({ query: '{ userList { id } }' })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(405);
+        });
+    });
+
+    describe('Variables', () => {
+        it('should support GraphQL variables', async () => {
+            const query = `
+                query GetUser($userId: String!) {
+                    user(id: $userId) {
+                        id
+                        name
+                    }
+                }
+            `;
+
+            const response = await request(server)
+                .post('/api/graphql')
+                .send({
+                    query,
+                    variables: { userId: '1' }
+                })
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.user.name).toBe('Alice');
+        });
+
+        it('should support variables in GET requests', async () => {
+            const query = encodeURIComponent('query GetUser($id: String!) { user(id: $id) { name } }');
+            const variables = encodeURIComponent(JSON.stringify({ id: '1' }));
+
+            const response = await request(server)
+                .get(`/api/graphql?query=${query}&variables=${variables}`)
+                .set('Accept', 'application/json');
+
+            expect(response.status).toBe(200);
+            expect(response.body.data.user.name).toBe('Alice');
+        });
+    });
+
+    describe('CORS', () => {
+        it('should handle OPTIONS preflight request', async () => {
+            const response = await request(server)
+                .options('/api/graphql');
+
+            expect(response.status).toBe(200);
+            expect(response.headers['access-control-allow-methods']).toContain('POST');
+        });
+    });
+});