@objectql/server 0.2.0

package/dist/server.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectQLServer = void 0;
+class ObjectQLServer {
+    constructor(app) {
+        this.app = app;
+    }
+    /**
+     * The core handler that processes a JSON request object and returns a result.
+     * This is framework-agnostic.
+     */
+    async handle(req) {
+        try {
+            // 1. Build Context
+            // TODO: integrate with real session/auth
+            const contextOptions = {
+                userId: req.user?.id,
+                roles: req.user?.roles || [],
+                // TODO: spaceId
+            };
+            // Note: Currently IObjectQL.createContext implies we have access to it.
+            // But IObjectQL interface in @objectql/types usually doesn't expose createContext (it's on the class).
+            // We need to cast or fix the interface. Assuming 'app' behaves like ObjectQL class.
+            const app = this.app;
+            if (typeof app.createContext !== 'function') {
+                throw new Error("The provided ObjectQL instance does not support createContext.");
+            }
+            const ctx = app.createContext(contextOptions);
+            const repo = ctx.object(req.object);
+            let result;
+            switch (req.op) {
+                case 'find':
+                    result = await repo.find(req.args);
+                    break;
+                case 'findOne':
+                    result = await repo.findOne(req.args);
+                    break;
+                case 'create':
+                    result = await repo.create(req.args);
+                    break;
+                case 'update':
+                    result = await repo.update(req.args.id, req.args.data);
+                    break;
+                case 'delete':
+                    result = await repo.delete(req.args.id);
+                    break;
+                case 'count':
+                    result = await repo.count(req.args);
+                    break;
+                case 'action':
+                    // TODO: The repo interface might not expose 'executeAction' directly yet,
+                    // usually it's on the app level or via special method.
+                    // For now, let's assume app.executeAction
+                    result = await app.executeAction(req.object, req.args.action, {
+                        ...ctx, // Pass context with user info
+                        params: req.args.params
+                    });
+                    break;
+                default:
+                    throw new Error(`Unknown operation: ${req.op}`);
+            }
+            return { data: result };
+        }
+        catch (e) {
+            console.error('[ObjectQL Server] Error:', e);
+            return {
+                error: {
+                    code: 'INTERNAL_ERROR',
+                    message: e.message || 'An error occurred'
+                }
+            };
+        }
+    }
+}
+exports.ObjectQLServer = ObjectQLServer;
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":";;;AAGA,MAAa,cAAc;IACvB,YAAoB,GAAc;QAAd,QAAG,GAAH,GAAG,CAAW;IAAG,CAAC;IAEtC;;;OAGG;IACH,KAAK,CAAC,MAAM,CAAC,GAAoB;QAC7B,IAAI,CAAC;YACD,mBAAmB;YACnB,yCAAyC;YACzC,MAAM,cAAc,GAAG;gBACnB,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,EAAE;gBACpB,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAC5B,gBAAgB;aACnB,CAAC;YAEF,wEAAwE;YACxE,uGAAuG;YACvG,oFAAoF;YACpF,MAAM,GAAG,GAAG,IAAI,CAAC,GAAU,CAAC;YAC5B,IAAI,OAAO,GAAG,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;gBAC1C,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;YACtF,CAAC;YAED,MAAM,GAAG,GAAoB,GAAG,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YAC/D,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAEpC,IAAI,MAAW,CAAC;YAEhB,QAAQ,GAAG,CAAC,EAAE,EAAE,CAAC;gBACb,KAAK,MAAM;oBACP,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACnC,MAAM;gBACV,KAAK,SAAS;oBACV,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACtC,MAAM;gBACV,KAAK,QAAQ;oBACT,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACrC,MAAM;gBACV,KAAK,QAAQ;oBACT,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBACvD,MAAM;gBACV,KAAK,QAAQ;oBACT,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBACxC,MAAM;gBACV,KAAK,OAAO;oBACR,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACpC,MAAM;gBACV,KAAK,QAAQ;oBACT,0EAA0E;oBAC1E,uDAAuD;oBACvD,0CAA0C;oBAC1C,MAAM,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE;wBACzD,GAAG,GAAG,EAAE,8BAA8B;wBACtC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM;qBAC3B,CAAC,CAAC;oBACH,MAAM;gBACV;oBACI,MAAM,IAAI,KAAK,CAAC,sBAAsB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;YACxD,CAAC;YAED,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAE5B,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YACd,OAAO,CAAC,KAAK,CAAC,0BAA0B,EAAE,CAAC,CAAC,CAAC;YAC7C,OAAO;gBACH,KAAK,EAAE;oBACH,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,CAAC,CAAC,OAAO,IAAI,mBAAmB;iBAC5C;aACJ,CAAC;QACN,CAAC;IACL,CAAC;CACJ;AA1ED,wCA0EC"}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export interface ObjectQLRequest {
+    user?: {
+        id: string;
+        roles: string[];
+        [key: string]: any;
+    };
+    op: 'find' | 'findOne' | 'create' | 'update' | 'delete' | 'count' | 'action';
+    object: string;
+    args: any;
+}
+export interface ObjectQLResponse {
+    data?: any;
+    error?: {
+        code: string;
+        message: string;
+    };
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/*.test.ts'],
+    moduleNameMapper: {
+        '^@objectql/(.*)$': '<rootDir>/../$1/src'
+    }
+};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@objectql/server",
+  "version": "0.2.0",
+  "description": "HTTP Server Adapter for ObjectQL",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@objectql/core": "1.2.0",
+    "@objectql/types": "1.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.10.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  }
+}

package/src/adapters/node.ts

@@ -0,0 +1,70 @@
+import { IObjectQL } from '@objectql/types';
+import { ObjectQLServer } from '../server';
+import { ObjectQLRequest } from '../types';
+import { IncomingMessage, ServerResponse } from 'http';
+import { generateOpenAPI } from '../openapi';
+
+/**
+ * Creates a standard Node.js HTTP request handler.
+ */
+export function createNodeHandler(app: IObjectQL) {
+    const server = new ObjectQLServer(app);
+
+
+    return async (req: IncomingMessage & { body?: any }, res: ServerResponse) => {
+        // Handle OpenAPI spec request
+        if (req.method === 'GET' && req.url?.endsWith('/openapi.json')) {
+            const spec = generateOpenAPI(app);
+            res.setHeader('Content-Type', 'application/json');
+            res.statusCode = 200;
+            res.end(JSON.stringify(spec));
+            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
+                const qlReq: ObjectQLRequest = {
+                    op: json.op,
+                    object: json.object,
+                    args: json.args,
+                    user: json.user // For dev/testing, allowing user injection
+                };
+
+                const result = await server.handle(qlReq);
+                
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = result.error ? 500 : 200;
+                res.end(JSON.stringify(result));
+            } catch (e) {
+                res.statusCode = 500;
+                res.end(JSON.stringify({ error: { code: 'INTERNAL_ERROR', message: 'Internal Server Error' }}));
+            }
+        };
+
+        // 1. Check if body is already parsed (e.g. by express.json())
+        if (req.body && typeof req.body === 'object') {
+            await handleRequest(req.body);
+            return;
+        }
+
+        // 2. Parse Body from stream
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+            try {
+                const json = JSON.parse(body);
+                await handleRequest(json);
+            } catch (e) {
+                res.statusCode = 400;
+                res.end('Invalid JSON');
+            }
+        });
+    };
+}

package/src/console.ts

@@ -0,0 +1,150 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Creates a handler to serve the console UI static files.
+ */
+export function createConsoleHandler() {
+    // Try to find the built console files
+    const possiblePaths = [
+        path.join(__dirname, '../../console/dist'),
+        path.join(process.cwd(), 'node_modules/@objectql/console/dist'),
+        path.join(process.cwd(), 'packages/console/dist'),
+    ];
+    
+    let distPath: string | null = null;
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            distPath = p;
+            break;
+        }
+    }
+    
+    return async (req: IncomingMessage, res: ServerResponse) => {
+        if (!distPath) {
+            // Return placeholder page if console is not built
+            const html = getPlaceholderPage();
+            res.setHeader('Content-Type', 'text/html');
+            res.statusCode = 200;
+            res.end(html);
+            return;
+        }
+        
+        // Parse the URL and remove /console prefix
+        let urlPath = (req.url || '').replace(/^\/console/, '') || '/';
+        
+        // Default to index.html for SPA routing
+        if (urlPath === '/' || !urlPath.includes('.')) {
+            urlPath = '/index.html';
+        }
+        
+        const filePath = path.join(distPath, urlPath);
+        
+        // Security check: ensure the file is within distPath
+        if (!filePath.startsWith(distPath)) {
+            res.statusCode = 403;
+            res.end('Forbidden');
+            return;
+        }
+        
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            // For SPA, return index.html for any non-existent routes
+            const indexPath = path.join(distPath, 'index.html');
+            if (fs.existsSync(indexPath)) {
+                const content = fs.readFileSync(indexPath);
+                res.setHeader('Content-Type', 'text/html');
+                res.statusCode = 200;
+                res.end(content);
+                return;
+            }
+            
+            res.statusCode = 404;
+            res.end('Not Found');
+            return;
+        }
+        
+        // Read and serve the file
+        const content = fs.readFileSync(filePath);
+        const ext = path.extname(filePath);
+        const contentType = getContentType(ext);
+        
+        res.setHeader('Content-Type', contentType);
+        res.statusCode = 200;
+        res.end(content);
+    };
+}
+
+function getContentType(ext: string): string {
+    const types: Record<string, string> = {
+        '.html': 'text/html',
+        '.js': 'application/javascript',
+        '.css': 'text/css',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+    };
+    return types[ext] || 'application/octet-stream';
+}
+
+function getPlaceholderPage(): string {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ObjectQL Console</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+        }
+        .container {
+            text-align: center;
+            max-width: 600px;
+            padding: 2rem;
+        }
+        h1 { font-size: 3rem; margin-bottom: 1rem; }
+        p { font-size: 1.25rem; opacity: 0.9; line-height: 1.6; }
+        .info {
+            background: rgba(255, 255, 255, 0.1);
+            padding: 1.5rem;
+            border-radius: 8px;
+            margin-top: 2rem;
+            backdrop-filter: blur(10px);
+        }
+        code {
+            background: rgba(0, 0, 0, 0.2);
+            padding: 0.25rem 0.5rem;
+            border-radius: 4px;
+            font-family: monospace;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>ObjectQL Console</h1>
+        <p>Web-based admin console for database management</p>
+        <div class="info">
+            <p style="margin-bottom: 1rem;">
+                The console is available but needs to be built separately.
+            </p>
+            <p style="font-size: 1rem;">
+                To use the full console UI, run:<br>
+                <code>cd packages/console && pnpm run build</code>
+            </p>
+        </div>
+    </div>
+</body>
+</html>`;
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './openapi';
+export * from './server';
+export * from './metadata';
+export * from './console';
+// We export createNodeHandler from root for convenience, 
+// but in the future we might encourage 'import ... from @objectql/server/node'
+export * from './adapters/node';

package/src/metadata.ts

@@ -0,0 +1,81 @@
+import { IObjectQL } from '@objectql/types';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * Creates a handler for metadata endpoints.
+ * These endpoints expose information about registered objects.
+ */
+export function createMetadataHandler(app: IObjectQL) {
+    return async (req: IncomingMessage, res: ServerResponse) => {
+        // Parse the URL
+        const url = req.url || '';
+        
+        // CORS headers for development
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 200;
+            res.end();
+            return;
+        }
+
+        try {
+            // GET /api/metadata/objects - List all objects
+            if (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) : []
+                }));
+                
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = 200;
+                res.end(JSON.stringify({ objects }));
+                return;
+            }
+
+            // 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;
+                }
+                
+                // 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
+                    }))
+                    : [];
+                
+                res.setHeader('Content-Type', 'application/json');
+                res.statusCode = 200;
+                res.end(JSON.stringify({
+                    ...metadata,
+                    fields
+                }));
+                return;
+            }
+
+            // Not found
+            res.statusCode = 404;
+            res.end('Not Found');
+        } catch (e: any) {
+            console.error('[Metadata Handler] Error:', e);
+            res.statusCode = 500;
+            res.end(JSON.stringify({ error: 'Internal Server Error' }));
+        }
+    };
+}

package/src/openapi.ts

@@ -0,0 +1,150 @@
+import { IObjectQL, ObjectConfig, FieldType, FieldConfig } from '@objectql/types';
+
+interface OpenAPISchema {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    paths: Record<string, any>;
+    components: {
+        schemas: Record<string, any>;
+    };
+}
+
+export function generateOpenAPI(app: IObjectQL): OpenAPISchema {
+    const registry = (app as any).metadata; // Direct access or via interface
+    const objects = registry.list('object') as ObjectConfig[];
+
+    const paths: Record<string, any> = {};
+    const schemas: Record<string, any> = {};
+
+    
+    // 1. Generate Schemas
+    for (const obj of objects) {
+        const schemaName = obj.name;
+        const properties: Record<string, any> = {};
+        
+        for (const [fieldName, field] of Object.entries(obj.fields)) {
+            properties[fieldName] = mapFieldTypeToOpenAPI(field);
+        }
+
+        schemas[schemaName] = {
+            type: 'object',
+            properties
+        };
+
+        // 2. Generate Paths (RPC Style representation for documentation purposes)
+        // Since we only have one endpoint, we might document operations as descriptions
+        // Or if we support REST style in the future, we would add /object paths here.
+        // For now, let's document the "Virtual" REST API that could exist via a gateway
+        // OR just document the schema.
+        // Let's assume the user might want to see standard CRUD paths even if implementation is RPC,
+        // so they can pass it to frontend generators?
+        // No, that would be misleading if the server doesn't support it.
+        
+        // Let's DOCUMENT the RPC operations as if they were paths, 
+        // OR clearer: One path /api/objectql with polymorphic body?
+        // Swagger UI handles oneOf poorly for top level operations sometimes.
+    }
+    
+    // Let's do a "Virtual" REST path generation for better visualization
+    // Assuming we WILL support REST mapping in this update.
+    for (const obj of objects) {
+        const name = obj.name;
+        
+        // GET /name (List)
+        paths[`/${name}`] = {
+            get: {
+                summary: `List ${name}s`,
+                tags: [name],
+                parameters: [
+                    { name: 'filter', in: 'query', schema: { type: 'string' }, description: 'JSON filter args' }
+                ],
+                responses: {
+                    200: {
+                        description: `List of ${name}`,
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        data: { type: 'array', items: { $ref: `#/components/schemas/${name}` } }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            post: {
+                summary: `Create ${name}`,
+                tags: [name],
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    data: { $ref: `#/components/schemas/${name}` }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    200: { description: 'Created' }
+                }
+            }
+        };
+
+        // GET /name/{id}
+        paths[`/${name}/{id}`] = {
+            get: {
+                summary: `Get ${name}`,
+                tags: [name],
+                parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                responses: { 200: { description: 'Item' } }
+            },
+            patch: {
+                 summary: `Update ${name}`,
+                 tags: [name],
+                 parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                 requestBody: { content: { 'application/json': { schema: { type: 'object', properties: { data: { type: 'object' }} } } } },
+                 responses: { 200: { description: 'Updated' } }
+            },
+            delete: {
+                 summary: `Delete ${name}`,
+                 tags: [name],
+                 parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+                 responses: { 200: { description: 'Deleted' } }
+            }
+        };
+    }
+
+    return {
+        openapi: '3.0.0',
+        info: {
+            title: 'ObjectQL API',
+            version: '1.0.0'
+        },
+        paths,
+        components: {
+            schemas
+        }
+    };
+}
+
+function mapFieldTypeToOpenAPI(field: FieldConfig | string): any {
+    const type = typeof field === 'string' ? field : field.type;
+    
+    switch (type) {
+        case 'string': return { type: 'string' };
+        case 'integer': return { type: 'integer' };
+        case 'float': return { type: 'number' };
+        case 'boolean': return { type: 'boolean' };
+        case 'date': return { type: 'string', format: 'date-time' };
+        case 'json': return { type: 'object' };
+        default: return { type: 'string' }; // Fallback or relationship ID
+    }
+}

package/src/server.ts

@@ -0,0 +1,78 @@
+import { IObjectQL, ObjectQLContext } from '@objectql/types';
+import { ObjectQLRequest, ObjectQLResponse } from './types';
+
+export class ObjectQLServer {
+    constructor(private app: IObjectQL) {}
+
+    /**
+     * The core handler that processes a JSON request object and returns a result.
+     * This is framework-agnostic.
+     */
+    async handle(req: ObjectQLRequest): Promise<ObjectQLResponse> {
+        try {
+            // 1. Build Context
+            // TODO: integrate with real session/auth
+            const contextOptions = {
+                userId: req.user?.id,
+                roles: req.user?.roles || [],
+                // TODO: spaceId
+            };
+            
+            // Note: Currently IObjectQL.createContext implies we have access to it.
+            // But IObjectQL interface in @objectql/types usually doesn't expose createContext (it's on the class).
+            // We need to cast or fix the interface. Assuming 'app' behaves like ObjectQL class.
+            const app = this.app as any; 
+            if (typeof app.createContext !== 'function') {
+                throw new Error("The provided ObjectQL instance does not support createContext.");
+            }
+            
+            const ctx: ObjectQLContext = app.createContext(contextOptions);
+            const repo = ctx.object(req.object);
+
+            let result: any;
+            
+            switch (req.op) {
+                case 'find':
+                    result = await repo.find(req.args);
+                    break;
+                case 'findOne':
+                    result = await repo.findOne(req.args);
+                    break;
+                case 'create':
+                    result = await repo.create(req.args);
+                    break;
+                case 'update':
+                    result = await repo.update(req.args.id, req.args.data);
+                    break;
+                case 'delete':
+                    result = await repo.delete(req.args.id);
+                    break;
+                case 'count':
+                    result = await repo.count(req.args);
+                    break;
+                case 'action':
+                    // TODO: The repo interface might not expose 'executeAction' directly yet,
+                    // usually it's on the app level or via special method.
+                    // For now, let's assume app.executeAction
+                    result = await app.executeAction(req.object, req.args.action, {
+                         ...ctx, // Pass context with user info
+                         params: req.args.params
+                    });
+                    break;
+                default:
+                    throw new Error(`Unknown operation: ${req.op}`);
+            }
+
+            return { data: result };
+
+        } catch (e: any) {
+            console.error('[ObjectQL Server] Error:', e);
+            return {
+                error: {
+                    code: 'INTERNAL_ERROR',
+                    message: e.message || 'An error occurred'
+                }
+            };
+        }
+    }
+}