@objectql/server 1.8.3 → 1.9.0

package/test/metadata.test.ts

@@ -0,0 +1,259 @@
+import { createMetadataHandler } from '../src/metadata';
+import { ObjectQL } from '@objectql/core';
+import { IncomingMessage, ServerResponse } from 'http';
+import { EventEmitter } from 'events';
+
+// Mock IncomingMessage
+class MockRequest extends EventEmitter {
+    url: string;
+    method: string;
+    headers: Record<string, string> = {};
+
+    constructor(method: string, url: string) {
+        super();
+        this.method = method;
+        this.url = url;
+    }
+
+    // Simulate sending data
+    sendData(data: string) {
+        this.emit('data', Buffer.from(data));
+        this.emit('end');
+    }
+
+    sendJson(data: any) {
+        this.sendData(JSON.stringify(data));
+    }
+}
+
+// Mock ServerResponse
+class MockResponse {
+    statusCode: number = 200;
+    headers: Record<string, string> = {};
+    body: string = '';
+    ended: boolean = false;
+
+    setHeader(name: string, value: string) {
+        this.headers[name] = value;
+    }
+
+    end(data?: string) {
+        if (data) this.body = data;
+        this.ended = true;
+    }
+
+    getBody() {
+        return this.body ? JSON.parse(this.body) : null;
+    }
+}
+
+describe('Metadata Handler', () => {
+    let app: ObjectQL;
+    let handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+    beforeEach(async () => {
+        app = new ObjectQL({
+            datasources: {},
+            objects: {
+                user: {
+                    name: 'user',
+                    label: 'User',
+                    icon: 'user-icon',
+                    description: 'User object',
+                    fields: {
+                        name: { type: 'text', required: true },
+                        email: { type: 'text', required: true }
+                    }
+                },
+                task: {
+                    name: 'task',
+                    label: 'Task',
+                    fields: {
+                        title: { type: 'text' },
+                        completed: { type: 'boolean' }
+                    }
+                }
+            }
+        });
+        await app.init();
+        handler = createMetadataHandler(app);
+    });
+
+    describe('OPTIONS Requests', () => {
+        it('should handle OPTIONS request for CORS', async () => {
+            const req = new MockRequest('OPTIONS', '/api/metadata');
+            const res = new MockResponse();
+
+            await handler(req as any, res as any);
+
+            expect(res.statusCode).toBe(200);
+            expect(res.headers['Access-Control-Allow-Origin']).toBe('*');
+            expect(res.headers['Access-Control-Allow-Methods']).toBe('GET, POST, PUT, OPTIONS');
+            expect(res.ended).toBe(true);
+        });
+    });
+
+    describe('GET /api/metadata', () => {
+        it('should list all objects (root endpoint)', async () => {
+            const req = new MockRequest('GET', '/api/metadata');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.items).toBeDefined();
+            expect(body.items).toHaveLength(2);
+            expect(body.items.find((o: any) => o.name === 'user')).toBeDefined();
+            expect(body.items.find((o: any) => o.name === 'task')).toBeDefined();
+        });
+
+        it('should include object metadata', async () => {
+            const req = new MockRequest('GET', '/api/metadata');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            const user = body.items.find((o: any) => o.name === 'user');
+            
+            expect(user.name).toBe('user');
+            expect(user.label).toBe('User');
+            expect(user.icon).toBe('user-icon');
+            expect(user.description).toBe('User object');
+            expect(user.fields).toBeDefined();
+            expect(user.fields.name).toBeDefined();
+            expect(user.fields.email).toBeDefined();
+        });
+    });
+
+    describe('GET /api/metadata/:type', () => {
+        it('should list objects with /api/metadata/object', async () => {
+            const req = new MockRequest('GET', '/api/metadata/object');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.items).toBeDefined();
+            expect(body.items).toHaveLength(2);
+        });
+
+        it('should list objects with /api/metadata/objects (alias)', async () => {
+            const req = new MockRequest('GET', '/api/metadata/objects');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.items).toBeDefined();
+            expect(body.items).toHaveLength(2);
+        });
+
+        it('should list custom metadata types', async () => {
+            // Register custom metadata
+            app.metadata.register('action', {
+                type: 'action',
+                id: 'sendEmail',
+                content: { name: 'sendEmail', handler: 'email.handler' }
+            });
+
+            const req = new MockRequest('GET', '/api/metadata/action');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.items).toBeDefined();
+            expect(body.items).toHaveLength(1);
+            expect(body.items[0].name).toBe('sendEmail');
+        });
+
+        it('should return empty array for non-existent type', async () => {
+            const req = new MockRequest('GET', '/api/metadata/nonexistent');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.items).toEqual([]);
+        });
+    });
+
+    describe('GET /api/metadata/:type/:id', () => {
+        it('should get specific object by name', async () => {
+            const req = new MockRequest('GET', '/api/metadata/object/user');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.name).toBe('user');
+            expect(body.label).toBe('User');
+            expect(body.fields).toBeDefined();
+        });
+
+        it('should return 404 for non-existent object', async () => {
+            const req = new MockRequest('GET', '/api/metadata/object/nonexistent');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            expect(res.statusCode).toBe(404);
+            const body = res.getBody();
+            expect(body.error).toBeDefined();
+            expect(body.error.code).toBe('NOT_FOUND');
+        });
+
+        it('should get custom metadata by id', async () => {
+            app.metadata.register('action', {
+                type: 'action',
+                id: 'sendEmail',
+                content: { name: 'sendEmail', description: 'Send email action' }
+            });
+
+            const req = new MockRequest('GET', '/api/metadata/action/sendEmail');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            const body = res.getBody();
+            expect(body.name).toBe('sendEmail');
+            expect(body.description).toBe('Send email action');
+        });
+    });
+
+    describe('CORS Headers', () => {
+        it('should include CORS headers on all responses', async () => {
+            const req = new MockRequest('GET', '/api/metadata');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            expect(res.headers['Access-Control-Allow-Origin']).toBe('*');
+            expect(res.headers['Access-Control-Allow-Methods']).toBeDefined();
+            expect(res.headers['Access-Control-Allow-Headers']).toBeDefined();
+        });
+    });
+
+    describe('Content-Type Header', () => {
+        it('should set Content-Type to application/json', async () => {
+            const req = new MockRequest('GET', '/api/metadata');
+            const res = new MockResponse();
+
+            req.sendData('');
+            await handler(req as any, res as any);
+
+            expect(res.headers['Content-Type']).toBe('application/json');
+        });
+    });
+});

package/test/openapi.test.ts

@@ -0,0 +1,354 @@
+import { generateOpenAPI } from '../src/openapi';
+import { ObjectQL } from '@objectql/core';
+import { ObjectConfig } from '@objectql/types';
+
+describe('OpenAPI Generator', () => {
+    let app: ObjectQL;
+
+    beforeEach(async () => {
+        app = new ObjectQL({
+            datasources: {},
+            objects: {
+                user: {
+                    name: 'user',
+                    label: 'User',
+                    fields: {
+                        name: { type: 'text', required: true },
+                        email: { type: 'text', required: true },
+                        age: { type: 'number' },
+                        active: { type: 'boolean' }
+                    }
+                },
+                task: {
+                    name: 'task',
+                    label: 'Task',
+                    fields: {
+                        title: { type: 'text' },
+                        completed: { type: 'boolean' },
+                        due_date: { type: 'date' }
+                    }
+                }
+            }
+        });
+        await app.init();
+    });
+
+    describe('Basic Structure', () => {
+        it('should generate valid OpenAPI structure', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.openapi).toBe('3.0.0');
+            expect(spec.info).toBeDefined();
+            expect(spec.info.title).toBeDefined();
+            expect(spec.info.version).toBeDefined();
+            expect(spec.paths).toBeDefined();
+            expect(spec.components).toBeDefined();
+            expect(spec.components.schemas).toBeDefined();
+        });
+
+        it('should have openapi version 3.0.0', () => {
+            const spec = generateOpenAPI(app);
+            expect(spec.openapi).toBe('3.0.0');
+        });
+
+        it('should have info section', () => {
+            const spec = generateOpenAPI(app);
+            expect(spec.info.title).toBeTruthy();
+            expect(spec.info.version).toBeTruthy();
+        });
+    });
+
+    describe('JSON-RPC Endpoint', () => {
+        it('should include JSON-RPC endpoint', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/objectql']).toBeDefined();
+            expect(spec.paths['/api/objectql'].post).toBeDefined();
+        });
+
+        it('should define JSON-RPC operations', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/objectql'].post;
+
+            expect(endpoint.summary).toBeDefined();
+            expect(endpoint.description).toBeDefined();
+            expect(endpoint.tags).toContain('System');
+        });
+
+        it('should define JSON-RPC request body schema', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/objectql'].post;
+            const schema = endpoint.requestBody.content['application/json'].schema;
+
+            expect(schema.properties.op).toBeDefined();
+            expect(schema.properties.object).toBeDefined();
+            expect(schema.properties.args).toBeDefined();
+            expect(schema.required).toContain('op');
+            expect(schema.required).toContain('object');
+        });
+
+        it('should define supported operations', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/objectql'].post;
+            const schema = endpoint.requestBody.content['application/json'].schema;
+            const operations = schema.properties.op.enum;
+
+            expect(operations).toContain('find');
+            expect(operations).toContain('findOne');
+            expect(operations).toContain('create');
+            expect(operations).toContain('update');
+            expect(operations).toContain('delete');
+            expect(operations).toContain('count');
+            expect(operations).toContain('action');
+        });
+    });
+
+    describe('Schemas Generation', () => {
+        it('should generate schema for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.components.schemas.user).toBeDefined();
+            expect(spec.components.schemas.task).toBeDefined();
+        });
+
+        it('should include all fields in schema', () => {
+            const spec = generateOpenAPI(app);
+            const userSchema = spec.components.schemas.user;
+
+            expect(userSchema.properties.name).toBeDefined();
+            expect(userSchema.properties.email).toBeDefined();
+            expect(userSchema.properties.age).toBeDefined();
+            expect(userSchema.properties.active).toBeDefined();
+        });
+
+        it('should map text fields to string type', () => {
+            const spec = generateOpenAPI(app);
+            const userSchema = spec.components.schemas.user;
+
+            expect(userSchema.properties.name.type).toBe('string');
+            expect(userSchema.properties.email.type).toBe('string');
+        });
+
+        it('should map number fields to string type (default mapping)', () => {
+            const spec = generateOpenAPI(app);
+            const userSchema = spec.components.schemas.user;
+
+            // Number type maps to string by default in current implementation
+            expect(userSchema.properties.age.type).toBe('string');
+        });
+
+        it('should map boolean fields to boolean type', () => {
+            const spec = generateOpenAPI(app);
+            const userSchema = spec.components.schemas.user;
+
+            expect(userSchema.properties.active.type).toBe('boolean');
+        });
+
+        it('should have object type for schemas', () => {
+            const spec = generateOpenAPI(app);
+            const userSchema = spec.components.schemas.user;
+
+            expect(userSchema.type).toBe('object');
+        });
+    });
+
+    describe('REST API Paths', () => {
+        it('should generate list endpoint for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/data/user']).toBeDefined();
+            expect(spec.paths['/api/data/user'].get).toBeDefined();
+            expect(spec.paths['/api/data/task']).toBeDefined();
+            expect(spec.paths['/api/data/task'].get).toBeDefined();
+        });
+
+        it('should generate create endpoint for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/data/user'].post).toBeDefined();
+            expect(spec.paths['/api/data/task'].post).toBeDefined();
+        });
+
+        it('should generate get by id endpoint for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/data/user/{id}']).toBeDefined();
+            expect(spec.paths['/api/data/user/{id}'].get).toBeDefined();
+        });
+
+        it('should generate update endpoint for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/data/user/{id}'].patch).toBeDefined();
+        });
+
+        it('should generate delete endpoint for each object', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(spec.paths['/api/data/user/{id}'].delete).toBeDefined();
+        });
+    });
+
+    describe('Path Parameters', () => {
+        it('should define id parameter for detail endpoints', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/data/user/{id}'].get;
+
+            expect(endpoint.parameters).toBeDefined();
+            const idParam = endpoint.parameters.find((p: any) => p.name === 'id');
+            expect(idParam).toBeDefined();
+            expect(idParam.in).toBe('path');
+            expect(idParam.required).toBe(true);
+        });
+    });
+
+    describe('Complex Field Types', () => {
+        it('should handle select fields', async () => {
+            const app2 = new ObjectQL({
+                datasources: {},
+                objects: {
+                    project: {
+                        name: 'project',
+                        fields: {
+                            status: { 
+                                type: 'select', 
+                                options: [
+                                    { label: 'Active', value: 'active' },
+                                    { label: 'Completed', value: 'completed' },
+                                    { label: 'Archived', value: 'archived' }
+                                ]
+                            }
+                        }
+                    }
+                }
+            });
+            await app2.init();
+
+            const spec = generateOpenAPI(app2);
+            const projectSchema = spec.components.schemas.project;
+
+            expect(projectSchema.properties.status).toBeDefined();
+            expect(projectSchema.properties.status.type).toBe('string');
+            // Current implementation doesn't extract enum values
+        });
+
+        it('should handle lookup fields', async () => {
+            const app2 = new ObjectQL({
+                datasources: {},
+                objects: {
+                    task: {
+                        name: 'task',
+                        fields: {
+                            owner: { 
+                                type: 'lookup', 
+                                reference_to: 'users' 
+                            }
+                        }
+                    }
+                }
+            });
+            await app2.init();
+
+            const spec = generateOpenAPI(app2);
+            const taskSchema = spec.components.schemas.task;
+
+            expect(taskSchema.properties.owner).toBeDefined();
+            // Lookup fields typically map to string (ID reference)
+            expect(taskSchema.properties.owner.type).toBe('string');
+        });
+
+        it('should handle datetime fields', async () => {
+            const app2 = new ObjectQL({
+                datasources: {},
+                objects: {
+                    event: {
+                        name: 'event',
+                        fields: {
+                            start_time: { type: 'datetime' }
+                        }
+                    }
+                }
+            });
+            await app2.init();
+
+            const spec = generateOpenAPI(app2);
+            const eventSchema = spec.components.schemas.event;
+
+            expect(eventSchema.properties.start_time).toBeDefined();
+            expect(eventSchema.properties.start_time.type).toBe('string');
+            // OpenAPI implementation may or may not add format
+        });
+    });
+
+    describe('Multiple Objects', () => {
+        it('should generate paths for all registered objects', () => {
+            const spec = generateOpenAPI(app);
+
+            const pathKeys = Object.keys(spec.paths);
+            const userPaths = pathKeys.filter(p => p.includes('/user'));
+            const taskPaths = pathKeys.filter(p => p.includes('/task'));
+
+            expect(userPaths.length).toBeGreaterThan(0);
+            expect(taskPaths.length).toBeGreaterThan(0);
+        });
+
+        it('should generate schemas for all registered objects', () => {
+            const spec = generateOpenAPI(app);
+
+            expect(Object.keys(spec.components.schemas)).toContain('user');
+            expect(Object.keys(spec.components.schemas)).toContain('task');
+        });
+    });
+
+    describe('Empty App', () => {
+        it('should generate valid spec even with no objects', async () => {
+            const emptyApp = new ObjectQL({
+                datasources: {}
+            });
+            await emptyApp.init();
+
+            const spec = generateOpenAPI(emptyApp);
+
+            expect(spec.openapi).toBe('3.0.0');
+            expect(spec.paths).toBeDefined();
+            expect(spec.paths['/api/objectql']).toBeDefined();
+            expect(spec.components.schemas).toBeDefined();
+        });
+    });
+
+    describe('Response Definitions', () => {
+        it('should define 200 responses for GET endpoints', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/data/user'].get;
+
+            expect(endpoint.responses).toBeDefined();
+            expect(endpoint.responses['200']).toBeDefined();
+            expect(endpoint.responses['200'].description).toBeDefined();
+        });
+
+        it('should define responses for POST endpoints', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/data/user'].post;
+
+            expect(endpoint.responses).toBeDefined();
+            expect(endpoint.responses['200']).toBeDefined();
+        });
+    });
+
+    describe('Tags', () => {
+        it('should tag endpoints by object name', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/data/user'].get;
+
+            expect(endpoint.tags).toBeDefined();
+            expect(endpoint.tags).toContain('user');
+        });
+
+        it('should have System tag for JSON-RPC endpoint', () => {
+            const spec = generateOpenAPI(app);
+            const endpoint = spec.paths['/api/objectql'].post;
+
+            expect(endpoint.tags).toContain('System');
+        });
+    });
+});