@objectql/server 1.3.1 → 1.5.0

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,18 +1,36 @@
 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.
- * These endpoints expose information about registered objects.
+ * These endpoints expose information about registered objects and other metadata.
  */
 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,60 +40,184 @@ export function createMetadataHandler(app: IObjectQL) {
         }
 
         try {
-            // GET /api/metadata/objects - List all objects
-            if (url === '/api/metadata/objects') {
+            // Helper to send JSON
+            const sendJson = (data: any, status = 200) => {
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = status;
+                res.end(JSON.stringify(data));
+            };
+
+            const sendError = (code: ErrorCode, message: string, status = 400) => {
+                sendJson({ error: { code, message } }, status);
+            };
+
+            // ---------------------------------------------------------
+            // 1. List Entries (GET /api/metadata/:type)
+            // ---------------------------------------------------------
+            
+            // Legacy/Alias: /api/metadata or /api/metadata/objects -> list 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 || {}
                 }));
+                return sendJson({ objects });
+            }
+
+            // Generic List: /api/metadata/:type
+            const listMatch = url.match(/^\/api\/metadata\/([^\/]+)$/);
+            if (method === 'GET' && listMatch) {
+                let [, type] = listMatch;
+                if (type === 'objects') type = 'object'; // Should not hit due to order, but safe to keep.
                 
-                res.setHeader('Content-Type', 'application/json');
-                res.statusCode = 200;
-                res.end(JSON.stringify({ objects }));
-                return;
+                const entries = app.metadata.list(type);
+                // Return simple list
+                return sendJson({ 
+                    [type]: entries
+                });
             }
 
-            // GET /api/metadata/objects/:name - Get object details
-            const match = url.match(/^\/api\/metadata\/objects\/([^\/]+)$/);
-            if (match) {
-                const objectName = match[1];
-                const metadata = app.getObject(objectName);
-                if (!metadata) {
-                    res.statusCode = 404;
-                    res.end(JSON.stringify({ error: 'Object not found' }));
-                    return;
+            // ---------------------------------------------------------
+            // 2. Get Single Entry (GET /api/metadata/:type/:id)
+            // ---------------------------------------------------------
+            
+            const detailMatch = url.match(/^\/api\/metadata\/([^\/]+)\/([^\/\?]+)$/);
+            
+            if (method === 'GET' && detailMatch) {
+                let [, type, id] = detailMatch;
+
+                // Handle Object Special Logic (Field Formatting)
+                if (type === 'objects' || type === 'object') {
+                    const metadata = app.getObject(id);
+                    if (!metadata) {
+                        return sendError(ErrorCode.NOT_FOUND, `Object '${id}' not found`, 404);
+                    }
+                    
+                    // Convert fields object to array (Standard Object Response)
+                    const fields = metadata.fields 
+                        ? Object.entries(metadata.fields).map(([key, field]) => ({
+                            name: field.name || key,
+                            type: field.type,
+                            label: field.label,
+                            required: field.required,
+                            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
+                        }))
+                        : [];
+                    
+                    return sendJson({
+                        ...metadata,
+                        fields
+                    });
+                } else {
+                    // Generic Metadata (View, Form, etc.)
+                    const content = app.metadata.get(type, id);
+                    if (!content) {
+                         return sendError(ErrorCode.NOT_FOUND, `${type} '${id}' not found`, 404);
+                    }
+                    return sendJson(content);
+                }
+            }
+
+            // ---------------------------------------------------------
+            // 3. Update Entry (POST/PUT /api/metadata/:type/:id)
+            // ---------------------------------------------------------
+            if ((method === 'POST' || method === 'PUT') && detailMatch) {
+                let [, type, id] = detailMatch;
+                if (type === 'objects') type = 'object';
+
+                const body = await readBody(req);
+                try {
+                    await app.updateMetadata(type, id, body);
+                    return sendJson({ success: true });
+                } catch (e: any) {
+                    const isUserError = e.message.startsWith('Cannot update') || e.message.includes('not found');
+                    return sendError(
+                        isUserError ? ErrorCode.INVALID_REQUEST : ErrorCode.INTERNAL_ERROR,
+                        e.message,
+                        isUserError ? 400 : 500
+                    );
                 }
+            }
+
+            // ---------------------------------------------------------
+            // 4. Object Sub-resources (Fields, Actions)
+            // ---------------------------------------------------------
+            
+            // GET /api/metadata/objects/:name/fields/:field
+            // Legacy path support.
+            const fieldMatch = url.match(/^\/api\/metadata\/objects\/([^\/]+)\/fields\/([^\/\?]+)$/);
+            if (method === 'GET' && fieldMatch) {
+                const [, objectName, fieldName] = fieldMatch;
+                const metadata = app.getObject(objectName);
                 
-                // Convert fields object to array
-                const fields = metadata.fields 
-                    ? Object.entries(metadata.fields).map(([key, field]) => ({
-                        name: field.name || key,
-                        type: field.type,
-                        label: field.label,
-                        required: field.required,
-                        defaultValue: field.defaultValue
-                    }))
-                    : [];
+                if (!metadata) return sendError(ErrorCode.NOT_FOUND, `Object '${objectName}' not found`, 404);
+
+                const field = metadata.fields?.[fieldName];
+                if (!field) return sendError(ErrorCode.NOT_FOUND, `Field '${fieldName}' not found`, 404);
+
+                return sendJson({
+                    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
+                });
+            }
+
+            // GET /api/metadata/objects/:name/actions
+            const actionsMatch = url.match(/^\/api\/metadata\/objects\/([^\/]+)\/actions$/);
+            if (method === 'GET' && actionsMatch) {
+                const [, objectName] = actionsMatch;
+                const metadata = app.getObject(objectName);
                 
-                res.setHeader('Content-Type', 'application/json');
-                res.statusCode = 200;
-                res.end(JSON.stringify({
-                    ...metadata,
-                    fields
-                }));
-                return;
+                if (!metadata) return sendError(ErrorCode.NOT_FOUND, `Object '${objectName}' not found`, 404);
+
+                const actions = metadata.actions || {};
+                const formattedActions = Object.entries(actions).map(([key, action]) => {
+                    const actionConfig = action as any;
+                    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
+                    };
+                });
+
+                return sendJson({ actions: formattedActions });
             }
 
             // Not found
-            res.statusCode = 404;
-            res.end('Not Found');
+            sendError(ErrorCode.NOT_FOUND, 'Not Found', 404);
+            
         } 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'
+                }
+            }));
         }
     };
 }