@objectql/server 1.3.1 → 1.4.0

package/src/adapters/node.ts

@@ -1,6 +1,6 @@
 import { IObjectQL } from '@objectql/types';
 import { ObjectQLServer } from '../server';
-import { ObjectQLRequest } from '../types';
+import { ObjectQLRequest, ErrorCode } from '../types';
 import { IncomingMessage, ServerResponse } from 'http';
 import { generateOpenAPI } from '../openapi';
 
@@ -21,12 +21,6 @@ export function createNodeHandler(app: IObjectQL) {
             return;
         }
 
-        if (req.method !== 'POST') {
-            res.statusCode = 405;
-            res.end('Method Not Allowed');
-            return;
-        }
-
         const handleRequest = async (json: any) => {
              try {
                 // TODO: Parse user from header or request override
@@ -34,20 +28,82 @@ export function createNodeHandler(app: IObjectQL) {
                     op: json.op,
                     object: json.object,
                     args: json.args,
-                    user: json.user // For dev/testing, allowing user injection
+                    user: json.user, // For dev/testing, allowing user injection
+                    ai_context: json.ai_context // Support AI context
                 };
 
                 const result = await server.handle(qlReq);
                 
+                // Determine HTTP status code based on error
+                let statusCode = 200;
+                if (result.error) {
+                    switch (result.error.code) {
+                        case ErrorCode.INVALID_REQUEST:
+                        case ErrorCode.VALIDATION_ERROR:
+                            statusCode = 400;
+                            break;
+                        case ErrorCode.UNAUTHORIZED:
+                            statusCode = 401;
+                            break;
+                        case ErrorCode.FORBIDDEN:
+                            statusCode = 403;
+                            break;
+                        case ErrorCode.NOT_FOUND:
+                            statusCode = 404;
+                            break;
+                        case ErrorCode.CONFLICT:
+                            statusCode = 409;
+                            break;
+                        case ErrorCode.RATE_LIMIT_EXCEEDED:
+                            statusCode = 429;
+                            break;
+                        default:
+                            statusCode = 500;
+                    }
+                }
+
                 res.setHeader('Content-Type', 'application/json');
-                res.statusCode = result.error ? 500 : 200;
+                res.statusCode = statusCode;
                 res.end(JSON.stringify(result));
             } catch (e) {
                 res.statusCode = 500;
-                res.end(JSON.stringify({ error: { code: 'INTERNAL_ERROR', message: 'Internal Server Error' }}));
+                res.end(JSON.stringify({ 
+                    error: { 
+                        code: ErrorCode.INTERNAL_ERROR, 
+                        message: 'Internal Server Error' 
+                    }
+                }));
             }
         };
 
+        if (req.method !== 'POST') {
+            // Attempt to handle GET requests for simple queries like /api/objectql/table
+            // We map this to a find operation
+            // URL pattern: /api/objectql/:objectName
+            const match = req.url?.match(/\/([^\/?]+)(\?.*)?$/);
+            if (req.method === 'GET' && match) {
+                const objectName = match[1];
+                // Ignore special paths
+                if (objectName !== 'openapi.json' && objectName !== 'metadata') {
+                     await handleRequest({
+                        op: 'find',
+                        object: objectName,
+                        args: {} // TODO: Parse query params to args
+                     });
+                     return;
+                }
+            }
+
+            res.statusCode = 405;
+            res.end(JSON.stringify({
+                error: {
+                    code: ErrorCode.INVALID_REQUEST,
+                    message: 'Method Not Allowed'
+                }
+            }));
+            return;
+        }
+
         // 1. Check if body is already parsed (e.g. by express.json())
         if (req.body && typeof req.body === 'object') {
             await handleRequest(req.body);
@@ -63,7 +119,12 @@ export function createNodeHandler(app: IObjectQL) {
                 await handleRequest(json);
             } catch (e) {
                 res.statusCode = 400;
-                res.end('Invalid JSON');
+                res.end(JSON.stringify({
+                    error: {
+                        code: ErrorCode.INVALID_REQUEST,
+                        message: 'Invalid JSON'
+                    }
+                }));
             }
         });
     };

package/src/adapters/rest.ts

@@ -0,0 +1,271 @@
+import { IObjectQL } from '@objectql/types';
+import { ObjectQLServer } from '../server';
+import { ObjectQLRequest, ErrorCode } from '../types';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * Parse query string parameters
+ */
+function parseQueryParams(url: string): Record<string, any> {
+    const params: Record<string, any> = {};
+    const queryIndex = url.indexOf('?');
+    if (queryIndex === -1) return params;
+
+    const queryString = url.substring(queryIndex + 1);
+    const pairs = queryString.split('&');
+
+    for (const pair of pairs) {
+        const [key, value] = pair.split('=');
+        if (!key) continue;
+
+        const decodedKey = decodeURIComponent(key);
+        const decodedValue = decodeURIComponent(value || '');
+
+        // Try to parse JSON values
+        try {
+            params[decodedKey] = JSON.parse(decodedValue);
+        } catch {
+            params[decodedKey] = decodedValue;
+        }
+    }
+
+    return params;
+}
+
+/**
+ * Read request body as JSON
+ */
+function readBody(req: IncomingMessage): Promise<any> {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => body += chunk.toString());
+        req.on('end', () => {
+            if (!body) return resolve({});
+            try {
+                resolve(JSON.parse(body));
+            } catch (e) {
+                reject(new Error('Invalid JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+
+/**
+ * Send JSON response
+ */
+function sendJSON(res: ServerResponse, statusCode: number, data: any) {
+    res.setHeader('Content-Type', 'application/json');
+    res.statusCode = statusCode;
+    res.end(JSON.stringify(data));
+}
+
+/**
+ * Creates a REST-style HTTP request handler for ObjectQL
+ * 
+ * Endpoints:
+ * - GET    /api/data/:object       - List records
+ * - GET    /api/data/:object/:id   - Get single record
+ * - POST   /api/data/:object       - Create record
+ * - PUT    /api/data/:object/:id   - Update record
+ * - DELETE /api/data/:object/:id   - Delete record
+ */
+export function createRESTHandler(app: IObjectQL) {
+    const server = new ObjectQLServer(app);
+
+    return async (req: IncomingMessage & { body?: any }, res: ServerResponse) => {
+        try {
+            // CORS headers
+            const requestOrigin = req.headers.origin;
+            const configuredOrigin = process.env.OBJECTQL_CORS_ORIGIN;
+            const isProduction = process.env.NODE_ENV === 'production';
+
+            // In development, allow all origins by default (or use configured override).
+            // In production, require an explicit OBJECTQL_CORS_ORIGIN to be set.
+            if (!isProduction) {
+                res.setHeader('Access-Control-Allow-Origin', configuredOrigin || '*');
+            } else if (configuredOrigin && (!requestOrigin || requestOrigin === configuredOrigin)) {
+                res.setHeader('Access-Control-Allow-Origin', configuredOrigin);
+            }
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+            if (req.method === 'OPTIONS') {
+                res.statusCode = 200;
+                res.end();
+                return;
+            }
+
+            const url = req.url || '';
+            const method = req.method || 'GET';
+
+            // Parse URL: /api/data/:object or /api/data/:object/:id
+            const match = url.match(/^\/api\/data\/([^\/\?]+)(?:\/([^\/\?]+))?(\?.*)?$/);
+
+            if (!match) {
+                sendJSON(res, 404, {
+                    error: {
+                        code: ErrorCode.NOT_FOUND,
+                        message: 'Invalid REST API endpoint'
+                    }
+                });
+                return;
+            }
+
+            const [, objectName, id, queryString] = match;
+            const queryParams = queryString ? parseQueryParams(queryString) : {};
+
+            let qlRequest: ObjectQLRequest;
+
+            switch (method) {
+                case 'GET':
+                    if (id) {
+                        // GET /api/data/:object/:id - Get single record
+                        qlRequest = {
+                            op: 'findOne',
+                            object: objectName,
+                            args: id
+                        };
+                    } else {
+                        // GET /api/data/:object - List records
+                        const args: any = {};
+
+                        // Parse query parameters
+                        if (queryParams.filter) {
+                            args.filters = queryParams.filter;
+                        }
+                        if (queryParams.fields) {
+                            args.fields = queryParams.fields;
+                        }
+                        if (queryParams.sort) {
+                            args.sort = Array.isArray(queryParams.sort) 
+                                ? queryParams.sort 
+                                : [[queryParams.sort, 'asc']];
+                        }
+                        if (queryParams.top || queryParams.limit) {
+                            args.top = queryParams.top || queryParams.limit;
+                        }
+                        if (queryParams.skip || queryParams.offset) {
+                            args.skip = queryParams.skip || queryParams.offset;
+                        }
+                        if (queryParams.expand) {
+                            args.expand = queryParams.expand;
+                        }
+
+                        qlRequest = {
+                            op: 'find',
+                            object: objectName,
+                            args
+                        };
+                    }
+                    break;
+
+                case 'POST':
+                    // POST /api/data/:object - Create record
+                    const createBody = req.body || await readBody(req);
+                    qlRequest = {
+                        op: 'create',
+                        object: objectName,
+                        args: createBody
+                    };
+                    break;
+
+                case 'PUT':
+                case 'PATCH':
+                    // PUT /api/data/:object/:id - Update record
+                    if (!id) {
+                        sendJSON(res, 400, {
+                            error: {
+                                code: ErrorCode.INVALID_REQUEST,
+                                message: 'ID is required for update operation'
+                            }
+                        });
+                        return;
+                    }
+
+                    const updateBody = req.body || await readBody(req);
+                    qlRequest = {
+                        op: 'update',
+                        object: objectName,
+                        args: {
+                            id,
+                            data: updateBody
+                        }
+                    };
+                    break;
+
+                case 'DELETE':
+                    // DELETE /api/data/:object/:id - Delete record
+                    if (!id) {
+                        sendJSON(res, 400, {
+                            error: {
+                                code: ErrorCode.INVALID_REQUEST,
+                                message: 'ID is required for delete operation'
+                            }
+                        });
+                        return;
+                    }
+
+                    qlRequest = {
+                        op: 'delete',
+                        object: objectName,
+                        args: { id }
+                    };
+                    break;
+
+                default:
+                    sendJSON(res, 405, {
+                        error: {
+                            code: ErrorCode.INVALID_REQUEST,
+                            message: 'Method not allowed'
+                        }
+                    });
+                    return;
+            }
+
+            // Execute the request
+            const result = await server.handle(qlRequest);
+
+            // Determine HTTP status code
+            let statusCode = 200;
+            if (result.error) {
+                switch (result.error.code) {
+                    case ErrorCode.INVALID_REQUEST:
+                    case ErrorCode.VALIDATION_ERROR:
+                        statusCode = 400;
+                        break;
+                    case ErrorCode.UNAUTHORIZED:
+                        statusCode = 401;
+                        break;
+                    case ErrorCode.FORBIDDEN:
+                        statusCode = 403;
+                        break;
+                    case ErrorCode.NOT_FOUND:
+                        statusCode = 404;
+                        break;
+                    case ErrorCode.CONFLICT:
+                        statusCode = 409;
+                        break;
+                    case ErrorCode.RATE_LIMIT_EXCEEDED:
+                        statusCode = 429;
+                        break;
+                    default:
+                        statusCode = 500;
+                }
+            } else if (method === 'POST') {
+                statusCode = 201; // Created
+            }
+
+            sendJSON(res, statusCode, result);
+
+        } catch (e: any) {
+            console.error('[REST Handler] Error:', e);
+            sendJSON(res, 500, {
+                error: {
+                    code: ErrorCode.INTERNAL_ERROR,
+                    message: 'Internal server error'
+                }
+            });
+        }
+    };
+}

package/src/index.ts

@@ -2,7 +2,9 @@ export * from './types';
 export * from './openapi';
 export * from './server';
 export * from './metadata';
-export * from './console';
+export * from './studio';
 // We export createNodeHandler from root for convenience, 
 // but in the future we might encourage 'import ... from @objectql/server/node'
 export * from './adapters/node';
+// Export REST adapter
+export * from './adapters/rest';

package/src/metadata.ts

@@ -1,5 +1,22 @@
 import { IObjectQL } from '@objectql/types';
 import { IncomingMessage, ServerResponse } from 'http';
+import { ErrorCode } from './types';
+
+function readBody(req: IncomingMessage): Promise<any> {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => body += chunk.toString());
+        req.on('end', () => {
+            if (!body) return resolve({});
+            try {
+                resolve(JSON.parse(body));
+            } catch (e) {
+                reject(e);
+            }
+        });
+        req.on('error', reject);
+    });
+}
 
 /**
  * Creates a handler for metadata endpoints.
@@ -9,10 +26,11 @@ export function createMetadataHandler(app: IObjectQL) {
     return async (req: IncomingMessage, res: ServerResponse) => {
         // Parse the URL
         const url = req.url || '';
+        const method = req.method;
         
         // CORS headers for development
         res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
         
         if (req.method === 'OPTIONS') {
@@ -22,14 +40,15 @@ export function createMetadataHandler(app: IObjectQL) {
         }
 
         try {
-            // GET /api/metadata/objects - List all objects
-            if (url === '/api/metadata/objects') {
+            // GET /api/metadata or /api/metadata/objects - List all objects
+            if (method === 'GET' && (url === '/api/metadata' || url === '/api/metadata/objects')) {
                 const configs = app.getConfigs();
                 const objects = Object.values(configs).map(obj => ({
                     name: obj.name,
                     label: obj.label || obj.name,
                     icon: obj.icon,
-                    fields: obj.fields ? Object.keys(obj.fields) : []
+                    description: obj.description,
+                    fields: obj.fields || {}
                 }));
                 
                 res.setHeader('Content-Type', 'application/json');
@@ -39,13 +58,18 @@ export function createMetadataHandler(app: IObjectQL) {
             }
 
             // GET /api/metadata/objects/:name - Get object details
-            const match = url.match(/^\/api\/metadata\/objects\/([^\/]+)$/);
-            if (match) {
-                const objectName = match[1];
+            const objectMatch = url.match(/^\/api\/metadata\/objects\/([^\/\?]+)$/);
+            if (method === 'GET' && objectMatch) {
+                const objectName = objectMatch[1];
                 const metadata = app.getObject(objectName);
                 if (!metadata) {
                     res.statusCode = 404;
-                    res.end(JSON.stringify({ error: 'Object not found' }));
+                    res.end(JSON.stringify({ 
+                        error: {
+                            code: ErrorCode.NOT_FOUND,
+                            message: `Object '${objectName}' not found`
+                        }
+                    }));
                     return;
                 }
                 
@@ -56,7 +80,14 @@ export function createMetadataHandler(app: IObjectQL) {
                         type: field.type,
                         label: field.label,
                         required: field.required,
-                        defaultValue: field.defaultValue
+                        defaultValue: field.defaultValue,
+                        unique: field.unique,
+                        options: field.options,
+                        min: field.min,
+                        max: field.max,
+                        min_length: field.min_length,
+                        max_length: field.max_length,
+                        regex: field.regex
                     }))
                     : [];
                 
@@ -69,13 +100,137 @@ export function createMetadataHandler(app: IObjectQL) {
                 return;
             }
 
+            // GET /api/metadata/objects/:name/fields/:field - Get field metadata
+            const fieldMatch = url.match(/^\/api\/metadata\/objects\/([^\/]+)\/fields\/([^\/\?]+)$/);
+            if (method === 'GET' && fieldMatch) {
+                const [, objectName, fieldName] = fieldMatch;
+                const metadata = app.getObject(objectName);
+                
+                if (!metadata) {
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({ 
+                        error: {
+                            code: ErrorCode.NOT_FOUND,
+                            message: `Object '${objectName}' not found`
+                        }
+                    }));
+                    return;
+                }
+
+                const field = metadata.fields?.[fieldName];
+                if (!field) {
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({ 
+                        error: {
+                            code: ErrorCode.NOT_FOUND,
+                            message: `Field '${fieldName}' not found in object '${objectName}'`
+                        }
+                    }));
+                    return;
+                }
+
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = 200;
+                res.end(JSON.stringify({
+                    name: field.name || fieldName,
+                    type: field.type,
+                    label: field.label,
+                    required: field.required,
+                    unique: field.unique,
+                    defaultValue: field.defaultValue,
+                    options: field.options,
+                    min: field.min,
+                    max: field.max,
+                    min_length: field.min_length,
+                    max_length: field.max_length,
+                    regex: field.regex
+                }));
+                return;
+            }
+
+            // GET /api/metadata/objects/:name/actions - List actions
+            const actionsMatch = url.match(/^\/api\/metadata\/objects\/([^\/]+)\/actions$/);
+            if (method === 'GET' && actionsMatch) {
+                const [, objectName] = actionsMatch;
+                const metadata = app.getObject(objectName);
+                
+                if (!metadata) {
+                    res.statusCode = 404;
+                    res.end(JSON.stringify({ 
+                        error: {
+                            code: ErrorCode.NOT_FOUND,
+                            message: `Object '${objectName}' not found`
+                        }
+                    }));
+                    return;
+                }
+
+                const actions = metadata.actions || {};
+                const formattedActions = Object.entries(actions).map(([key, action]) => {
+                    const actionConfig = action as {
+                        type?: string;
+                        label?: string;
+                        params?: Record<string, unknown>;
+                        description?: string;
+                        fields?: Record<string, unknown>;
+                    };
+                    const hasFields = !!actionConfig.fields && Object.keys(actionConfig.fields).length > 0;
+                    return {
+                        name: key,
+                        type: actionConfig.type || (hasFields ? 'record' : 'global'),
+                        label: actionConfig.label || key,
+                        params: actionConfig.params || {},
+                        description: actionConfig.description
+                    };
+                });
+
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = 200;
+                res.end(JSON.stringify({ actions: formattedActions }));
+                return;
+            }
+
+            // POST/PUT /api/metadata/:type/:id - Update metadata
+            const updateMatch = url.match(/^\/api\/metadata\/([^\/]+)\/([^\/]+)$/);
+            if ((method === 'POST' || method === 'PUT') && updateMatch) {
+                const [, type, id] = updateMatch;
+                const body = await readBody(req);
+                
+                try {
+                    await app.updateMetadata(type, id, body);
+                    res.setHeader('Content-Type', 'application/json');
+                    res.statusCode = 200;
+                    res.end(JSON.stringify({ success: true }));
+                } catch (e: any) {
+                    const isUserError = e.message.startsWith('Cannot update') || e.message.includes('not found');
+                    res.statusCode = isUserError ? 400 : 500;
+                    res.end(JSON.stringify({ 
+                        error: {
+                            code: isUserError ? ErrorCode.INVALID_REQUEST : ErrorCode.INTERNAL_ERROR,
+                            message: e.message
+                        }
+                    }));
+                }
+                return;
+            }
+
             // Not found
             res.statusCode = 404;
-            res.end('Not Found');
+            res.end(JSON.stringify({
+                error: {
+                    code: ErrorCode.NOT_FOUND,
+                    message: 'Not Found'
+                }
+            }));
         } catch (e: any) {
             console.error('[Metadata Handler] Error:', e);
             res.statusCode = 500;
-            res.end(JSON.stringify({ error: 'Internal Server Error' }));
+            res.end(JSON.stringify({ 
+                error: {
+                    code: ErrorCode.INTERNAL_ERROR,
+                    message: 'Internal Server Error'
+                }
+            }));
         }
     };
 }