@hotfusion/modeller 0.0.7 → 0.0.9

package/dist/server.js

@@ -14,14 +14,11 @@ const eventemitter3_1 = require("eventemitter3");
 const jose_1 = require("jose");
 const socket_io_1 = require("socket.io");
 const keygen_js_1 = require("./utils/keygen.js");
+const koa_static_1 = __importDefault(require("koa-static"));
 class Utils {
     static trimPath(path) {
         return '/' + path.split('/').filter((x) => x).join('/');
     }
-    static postman(Event) {
-        if (Event.middleware === 'postman')
-            return Event.ctx.redirect(`/?access_token=${Event.profile.accessToken}&clientId=${Event.provider.clientId}&providerId=${Event.provider.id}&scopes=${Event.provider.scopes.join(' ')}`);
-    }
 }
 class Server extends eventemitter3_1.EventEmitter {
     port;
@@ -31,6 +28,18 @@ class Server extends eventemitter3_1.EventEmitter {
     providers = [];
     config;
     io;
+    registeredModels = [];
+    extensions = [];
+    extensionConfigs = new Map();
+    API_OPERATIONS = ['insert', 'update', 'delete', 'get', 'find', 'list'];
+    OPERATION_METHODS = {
+        insert: 'POST',
+        update: 'PUT',
+        delete: 'DELETE',
+        get: 'GET',
+        find: 'POST',
+        list: 'GET',
+    };
     constructor(port, config) {
         super();
         this.app = new koa_1.default();
@@ -52,125 +61,173 @@ class Server extends eventemitter3_1.EventEmitter {
         this.port = port;
         this.config = config;
     }
-    // TODO: IMPORTANT: Deprecated
+    // ?? Register model ??????????????????????????????????????????????????????????
+    registerModel(id, scope, model) {
+        this.registeredModels.push({ id, scope, model });
+        return this;
+    }
+    // ?? Register extension ??????????????????????????????????????????????????????
+    registerExtension(extension) {
+        this.extensions.push(extension);
+        return this;
+    }
+    // ?? Setup extensions ??????????????????????????????????????????????????????
+    async setupExtensions() {
+        console.log('[Server] Setting up extensions...');
+        for (const ext of this.extensions) {
+            console.log(`[Server] Setting up extension: ${ext.id}`);
+            const extConfig = this.extensionConfigs.get(ext.id) || {};
+            console.log(`[Server] Extension ${ext.id} config:`, extConfig);
+            await ext.setup(this, extConfig);
+            console.log(`[Server] Extension ${ext.id} setup complete`);
+        }
+        console.log('[Server] All extensions setup complete');
+    }
+    // ?? Auto-mount API routes ?????????????????????????????????????????????????????????
+    mountModelRoutes() {
+        for (const { id, scope, model } of this.registeredModels) {
+            this._mountModelRecursive(id, scope, model);
+        }
+    }
+    _mountModelRecursive(id, scope, model) {
+        this._mountModel(id, scope, model);
+        for (const ext of model.getExtensions?.() ?? []) {
+            this._mountModelRecursive(id, `${scope}/${ext.id}`, ext);
+        }
+    }
+    _mountModel(id, scope, model) {
+        // ?? CRUD operations ???????????????????????????????????????????????????
+        for (const operation of this.API_OPERATIONS) {
+            const routePath = `/${id}/${scope}/${operation}`;
+            const handler = async (ctx) => {
+                const { private: _priv, ...body } = { ...ctx.query, ...(ctx.request.body ?? {}) };
+                try {
+                    let result;
+                    if (operation === 'insert') {
+                        result = await model.insert(body, { private: true });
+                    }
+                    else if (operation === 'update') {
+                        const { key, data } = body;
+                        result = await model.update(key, data, { private: true });
+                    }
+                    else if (operation === 'delete') {
+                        const query = Object.keys(ctx.request.body ?? {}).length ? ctx.request.body : ctx.query;
+                        result = await model.delete(query);
+                    }
+                    else if (operation === 'get') {
+                        result = await model.get(body, { private: true });
+                    }
+                    else if (operation === 'list') {
+                        const { private: _p, start, count, ...query } = body;
+                        result = await model.list(query, { start: Number(start) || 0, count: Number(count) || 10000, private: true });
+                    }
+                    else {
+                        const { private: _p, max, ...query } = body;
+                        result = await model.find(query, { max, private: true });
+                    }
+                    ctx.status = 200;
+                    ctx.body = { ok: true, entry: result };
+                }
+                catch (err) {
+                    ctx.status = err?.status ?? 500;
+                    ctx.body = { ok: false, error: err?.message ?? err };
+                }
+            };
+            if (operation === 'insert')
+                this.router.post(routePath, handler);
+            else if (operation === 'update')
+                this.router.put(routePath, handler);
+            else if (operation === 'delete')
+                this.router.delete(routePath, handler);
+            else if (operation === 'get')
+                this.router.get(routePath, handler);
+            else if (operation === 'find')
+                this.router.post(routePath, handler);
+            else if (operation === 'list')
+                this.router.get(routePath, handler);
+        }
+        // ?? Custom methods ????????????????????????????????????????????????????
+        for (const method of model.getMethods?.() ?? []) {
+            this.router.post(`/${id}/${scope}/${method}`, async (ctx) => {
+                const { _id, ...rest } = ctx.request.body ?? {};
+                try {
+                    const result = await model.call(method, { _id, ...rest });
+                    ctx.status = 200;
+                    ctx.body = { ok: true, entry: result };
+                }
+                catch (err) {
+                    ctx.status = err?.status ?? 500;
+                    ctx.body = { ok: false, error: err?.message ?? err };
+                }
+            });
+        }
+        // ?? Upload methods (multipart HTTP) ???????????????????????????????????
+        for (const uploadId of model.getUploads?.() ?? []) {
+            this.upload(`/${id}/${scope}/${uploadId}`, async (ctx, file, fields) => {
+                try {
+                    return await model.callUpload(uploadId, file, fields);
+                }
+                catch (err) {
+                    throw err;
+                }
+            });
+        }
+        // ?? View routes ??????????????????????????????????????????????????????????????????????
+        for (const view of model.getViews?.() ?? []) {
+            const routePath = `/${id}/${scope}${view.path}`.replace(/\/$/, '') || '/';
+            console.log('[View] Mounting route:', routePath);
+            this.router.get(routePath, async (ctx) => {
+                try {
+                    ctx.type = 'text/html';
+                    ctx.body = await view.render(ctx.query);
+                }
+                catch (err) {
+                    ctx.status = err?.status ?? 500;
+                    ctx.body = { ok: false, error: err?.message ?? err };
+                }
+            });
+        }
+        // ?? Static folders ????????????????????????????????????????????????????
+        for (const [urlPath, { path: folderPath }] of model.getFolders?.() ?? new Map()) {
+            const staticMiddleware = (0, koa_static_1.default)(folderPath);
+            this.app.use(async (ctx, next) => {
+                if (ctx.path.startsWith(urlPath)) {
+                    ctx.path = ctx.path.slice(urlPath.length) || '/';
+                    return staticMiddleware(ctx, next);
+                }
+                return next();
+            });
+        }
+        // ?? Stream methods (binary socket) ????????????????????????????????????
+        for (const streamId of model.getStreams?.() ?? []) {
+            // Streams are registered globally in _setupStream
+            // Store them for later reference
+        }
+    }
+    // ?? OIDC Providers ?????????????????????????????????????????????????????
+    authPath;
     setOIDCProviders(path, providers) {
+        console.log('[Server] setOIDCProviders called with path:', path, 'providers:', providers?.map(p => p.id));
+        this.authPath = path;
         if (this.config.domain)
             path = `${this.config.domain}/${path}`;
-        path
-            = path.split('/').filter((x) => x).join('/');
+        path = path.split('/').filter((x) => x).join('/');
         providers?.forEach?.((provider) => {
             if (!this.providers.find(x => x.clientId === provider.clientId))
                 this.providers.push({ ...provider });
         });
-        if (!this.routes.find(x => x.path === Utils.trimPath(path) + '/:provider')) {
-            this.routes.push({
-                method: 'post',
-                path: Utils.trimPath(path) + '/:provider/logout',
-                callback: async (ctx, next) => {
-                    if (ctx.params.provider === 'callback' || !ctx.path.includes('/logout'))
-                        return await next();
-                    let provider = this.providers.find(x => x.id === ctx.params.provider);
-                    if (provider) {
-                        let SESSION = ctx.headers.authorization || '';
-                        if (!SESSION)
-                            ctx.throw(401, 'Unauthorized');
-                        if (SESSION) {
-                            SESSION = SESSION.split(' ').pop() || '';
-                            let token;
-                            try {
-                                token = (await (0, jose_1.jwtVerify)(SESSION, new TextEncoder().encode(Array.isArray(this.app?.keys) ? this.app.keys[0] : undefined))).payload;
-                            }
-                            catch (e) {
-                                token = (0, jose_1.decodeJwt)(SESSION);
-                            }
-                            let body = {};
-                            await new Promise(resolve => setTimeout(resolve, 1000));
-                            ctx.body = body;
-                        }
-                    }
-                }
-            });
-            /*this.routes.push({
-                method: 'get',
-                path: Utils.trimPath(path) + '/:provider',
-                callback: async (ctx, next) => {
-                    if (ctx.params.provider === 'callback')
-                        return await next();
-
-                    let provider:IOIDCProvider | undefined
-                        = this.providers.find(x => x.id === ctx.params.provider);
-
-                    if (provider) {
-                        try{
-                            let {url, code_verifier, state}
-                                = await new OIDCClient(provider as any ).buildURL(provider.scopes.join(' '));
-
-                            let {middleware} = ctx.request.query || {};
-                            ctx.session!.oidc = {
-                                __SID : ctx.query.__SID,
-                                provider,
-                                code_verifier,
-                                state,
-                                middleware: middleware || false,
-                                query : (ctx.request.querystring || '').replace(/^\?/, '')
-                                    .split('&')
-                                    .filter(Boolean)
-                                    .reduce<Record<string, string>>((acc, pair) => {
-                                        const [key, value = ''] = pair.split('=');
-                                        acc[decodeURIComponent(key as any )] = decodeURIComponent(value);
-                                        return acc;
-                                    }, {})
-                            };
-
-                            await ctx.session!.save?.();
-                            ctx.redirect(url.toString());
-                        }catch (e:any){
-                            console.error(e);
-                            ctx.body = e.message;
-                        }
-                    }
-                }
-            })*/
-            /*this.routes.push({
-                method   : 'get',
-                path     : Utils.trimPath(path.replace(this.config.domain + '/', '') + '/callback'),
-                callback : async (ctx) => {
-                    let origin
-                        = ctx.session?.oidc?.query?.origin || '';
-
-                    const session
-                        = ctx.session?.oidc;
-
-                    const code
-                        = ctx.query.code as string;
-
-                    const oidcClient
-                        = new OIDCClient(session.provider);
-
-                    const TokenCollection
-                        = await oidcClient.getToken(code,session.code_verifier)
-
-                    this.emit('provider',{token:TokenCollection,sid:session.__SID,session});
-                    ctx.type = 'html';
-                    ctx.body = `<script>window?.close?.()</script>`
-                }
-            })*/
-        }
+        // Store OIDC config for extension
+        this.extensionConfigs.set('oidc', {
+            providers: providers || [],
+            authPath: path,
+        });
         return this;
     }
-    // ── upload ───────────────────────────────────────────────────────────────
-    //
-    // Registers a multipart/form-data route. The handler receives the parsed
-    // file as a Buffer along with any other form fields.
-    //
-    // Example:
-    //   server.upload('/system/filesystem/upload', async (ctx, file, fields) => {
-    //       return { ok: true };
-    //   });
+    // ?? Upload ????????????????????????????????????????????????????????????????
     upload(path, handler) {
         this.routes.push({
             method: 'post',
-            path,
+            path: Utils.trimPath(path),
             callback: async (ctx) => {
                 return new Promise((resolve, reject) => {
                     const fields = {};
@@ -204,17 +261,7 @@ class Server extends eventemitter3_1.EventEmitter {
         });
         return this;
     }
-    // ── stream ───────────────────────────────────────────────────────────────
-    //
-    // Registers socket handlers for chunked binary file streaming with resume.
-    // The handler receives the complete reassembled Buffer and the upload metadata.
-    // Call this once — it handles all uploads for any model/scope.
-    //
-    // Example:
-    //   server.stream(async (buffer, meta) => {
-    //       // meta = { _id, path, id, scope, ... }
-    //       return { ok: true };
-    //   });
+    // ?? Stream ????????????????????????????????????????????????????????????????
     _streamHandler;
     _uploadTmp = '/tmp/hotfusion-uploads';
     stream(handler) {
@@ -224,9 +271,7 @@ class Server extends eventemitter3_1.EventEmitter {
     _setupStream(socket) {
         const handler = this._streamHandler;
         const uploadTmp = this._uploadTmp;
-        // uploadId → { meta, totalChunks, received }
         const uploads = new Map();
-        // Check disk for existing chunks (resume support)
         socket.on('upload:resume', async ({ uploadId }) => {
             const uploadDir = `${uploadTmp}/${uploadId}`;
             let fromChunk = 0;
@@ -240,10 +285,8 @@ class Server extends eventemitter3_1.EventEmitter {
             catch { }
             socket.emit(`upload:resume:${uploadId}`, { fromChunk });
         });
-        // Client announces upload metadata — make this synchronous so chunks can't race it
         socket.on('upload:start', ({ uploadId, id, scope, method, meta, totalChunks }) => {
             const fullMeta = { ...meta, id, scope, method };
-            // Synchronous mkdir — no awaits before uploads.set()
             const fs = require('node:fs');
             fs.mkdirSync(`${uploadTmp}/${uploadId}`, { recursive: true });
             const received = new Set();
@@ -254,10 +297,8 @@ class Server extends eventemitter3_1.EventEmitter {
             }
             catch { }
             uploads.set(uploadId, { meta: fullMeta, totalChunks, received });
-            // Ack so client knows it's safe to send chunks
             socket.emit(`upload:started:${uploadId}`);
         });
-        // Client sends a raw binary chunk
         socket.on('upload:chunk', async ({ uploadId, index, data }) => {
             const upload = uploads.get(uploadId);
             if (!upload) {
@@ -292,70 +333,179 @@ class Server extends eventemitter3_1.EventEmitter {
             }
         });
     }
+    // ?? Socket subscriptions ????????????????????????????????????????????????????
+    _setupSubscriptions(socket) {
+        const socketSubs = new Map();
+        const resolveModel = (id, scope) => {
+            const [baseScope, ext] = scope.split('.');
+            const entry = this.registeredModels.find(m => m.id === id && m.scope === baseScope);
+            return ext ? entry?.model[ext] : entry?.model;
+        };
+        socket.on('subscribe', ({ id, scope, query, reqId }) => {
+            const model = resolveModel(id, scope);
+            if (!model) {
+                socket.emit('error', { code: 'MODEL_NOT_FOUND', id, scope });
+                return;
+            }
+            const { subscription, subId } = model.subscribe(query);
+            const channel = [id, scope, subId].join('.');
+            const existing = socketSubs.get(subId);
+            if (existing)
+                existing.subscription.off('publish', existing.listener);
+            const listener = (payload) => socket.emit(channel, payload);
+            subscription.on('publish', listener);
+            socketSubs.set(subId, { model, subscription, listener });
+            socket.emit('subscribed', { id, scope, query, subId, events: subscription.getEvents(), reqId });
+        });
+        socket.on('event:call', async ({ id, scope, query, event, args, callId }) => {
+            const model = resolveModel(id, scope);
+            if (!model) {
+                socket.emit('event:result', { callId, error: { code: 'MODEL_NOT_FOUND' } });
+                return;
+            }
+            try {
+                const { subscription } = model.subscribe(query);
+                const result = await subscription.dispatch(event, args, { socket, scope });
+                socket.emit('event:result', { callId, result });
+            }
+            catch (error) {
+                socket.emit('event:result', { callId, error });
+            }
+        });
+        socket.on('unsubscribe', ({ id, scope, query }) => {
+            const model = resolveModel(id, scope);
+            if (!model)
+                return;
+            const subId = JSON.stringify(Object.fromEntries(Object.entries(query).sort()));
+            const existing = socketSubs.get(subId);
+            if (existing) {
+                existing.subscription.off('publish', existing.listener);
+                socketSubs.delete(subId);
+            }
+        });
+        socket.on('disconnect', () => {
+            for (const { subscription, listener } of socketSubs.values()) {
+                subscription.off('publish', listener);
+            }
+            socketSubs.clear();
+            this.registeredModels.forEach(m => m.model.emit('disconnect', socket));
+        });
+    }
+    // ?? Metadata endpoint ??????????????????????????????????????????????????????
+    _setupMetadataRoute() {
+        this.router.get('/@metadata', async (ctx) => {
+            const buildMeta = (id, scope, model) => ({
+                id,
+                scope,
+                schema: model.getSchema?.(),
+                schemes: model.getSchemes?.(),
+                operations: this.API_OPERATIONS.map(op => ({
+                    operation: op,
+                    method: this.OPERATION_METHODS[op],
+                    path: `/${id}/${scope}/${op}`,
+                    url: `http://localhost:${this.port}/${id}/${scope}/${op}`,
+                    schema: op === 'insert' || op === 'update' ? model.getSchema?.() : { type: 'object', properties: { _id: { type: 'string' } } },
+                })),
+                methods: (model.getMethods?.() ?? []).map((m) => ({
+                    method: m,
+                    path: `/${id}/${scope}/${m}`,
+                    url: `http://localhost:${this.port}/${id}/${scope}/${m}`,
+                })),
+                extensions: (model.getExtensions?.() ?? []).map((ext) => buildMeta(id, `${scope}/${ext.id}`, ext)),
+            });
+            ctx.body = { api: this.registeredModels.map(m => buildMeta(m.id, m.scope, m.model)) };
+        });
+    }
+    // ?? Route helper (kept for backward compatibility) ??????????????????????????
     route(route) {
         route.path = Utils.trimPath(route.path);
         this.routes.push(route);
         return this;
     }
-    start() {
-        setTimeout(() => {
-            this.app.use(async (ctx, next) => {
-                try {
-                    await next();
-                }
-                catch (err) {
-                    ctx.status = err.status || 500;
-                    ctx.body = {
-                        error: err.message || 'Internal error',
-                        status: err.status
+    // ?? Start server ????????????????????????????????????????????????????????????
+    async start() {
+        console.log('[Server] Start called');
+        // Wait a bit then start the server setup
+        await new Promise(resolve => setTimeout(resolve, 100));
+        console.log('[Server] Setting up app');
+        // Error handling middleware
+        this.app.use(async (ctx, next) => {
+            try {
+                await next();
+            }
+            catch (err) {
+                ctx.status = err.status || 500;
+                ctx.body = {
+                    error: err.message || 'Internal error',
+                    status: err.status
+                };
+            }
+        });
+        // Mount auto-generated model routes
+        this.mountModelRoutes();
+        // Setup extensions FIRST (before any routes)
+        console.log('[Server] Before setupExtensions');
+        await this.setupExtensions();
+        console.log('[Server] After setupExtensions');
+        // Mount metadata endpoint
+        this._setupMetadataRoute();
+        // Mount manually registered routes
+        for (let i = 0; i < this.routes.length; i++) {
+            let { method, path, callback } = this.routes[i] || {};
+            if (method && path && callback) {
+                const handler = async (ctx, next) => {
+                    let flags = {
+                        protected: this.routes?.[i]?.protected || false
                     };
-                }
-            });
-            for (let i = 0; i < this.routes.length; i++) {
-                let { method, path, callback } = this.routes[i] || {};
-                if (method && path && callback)
-                    this.router[method](path, async (ctx, next) => {
-                        let flags = {
-                            protected: this.routes?.[i]?.protected || false
-                        };
-                        try {
-                            if (flags.protected) {
-                                let TOKEN = ctx.headers.authorization;
-                                if (!TOKEN)
-                                    ctx.throw(401, 'Unauthorized');
-                                ctx.token
-                                    = (await (0, jose_1.jwtVerify)(TOKEN.split(' ').pop(), new TextEncoder().encode(Array.isArray(this.app?.keys) ? this.app.keys[0] : undefined))).payload;
-                            }
-                            let body = await callback(ctx, next);
-                            if (!ctx.body) {
-                                ctx.status = 200;
-                                ctx.body = body;
-                            }
+                    try {
+                        if (flags.protected) {
+                            let TOKEN = ctx.headers.authorization;
+                            if (!TOKEN)
+                                ctx.throw(401, 'Unauthorized');
+                            ctx.token = (await (0, jose_1.jwtVerify)(TOKEN.split(' ').pop(), new TextEncoder().encode(Array.isArray(this.app?.keys) ? this.app.keys[0] : undefined))).payload;
                         }
-                        catch (err) {
-                            ctx.status = 500;
-                            ctx.body = {
-                                error: err.message || err.code || err.details || 'Internal error',
-                            };
+                        let body = await callback(ctx, next);
+                        if (!ctx.body) {
+                            ctx.status = 200;
+                            ctx.body = body;
                         }
-                    });
+                    }
+                    catch (err) {
+                        ctx.status = 500;
+                        ctx.body = {
+                            error: err.message || err.code || err.details || 'Internal error',
+                        };
+                    }
+                };
+                if (method === 'get')
+                    this.router.get(path, handler);
+                else if (method === 'post')
+                    this.router.post(path, handler);
+                else if (method === 'put')
+                    this.router.put(path, handler);
+                else if (method === 'delete')
+                    this.router.delete(path, handler);
+                else if (method === 'patch')
+                    this.router.patch(path, handler);
             }
-            this.app.use(this.router.routes());
-            this.app.use(this.router.allowedMethods());
-            const server = this.app.listen(this.port, '0.0.0.0', () => {
-                this.emit("mounted", this);
-            });
-            this.io = new socket_io_1.Server(server, {
-                cors: { origin: "*", methods: ["GET", "POST"] },
-            });
-            this.io.use((socket, next) => {
-                next();
-            });
-            this.io.on("connection", (socket) => {
-                this._setupStream(socket);
-                this.emit('connection', { socket });
-            });
-        }, 100);
+        }
+        this.app.use(this.router.routes());
+        this.app.use(this.router.allowedMethods());
+        const server = this.app.listen(this.port, '0.0.0.0', () => {
+            this.emit("mounted", this);
+        });
+        this.io = new socket_io_1.Server(server, {
+            cors: { origin: "*", methods: ["GET", "POST"] },
+        });
+        this.io.use((socket, next) => {
+            next();
+        });
+        this.io.on("connection", (socket) => {
+            this._setupStream(socket);
+            this._setupSubscriptions(socket);
+            this.emit('connection', { socket });
+        });
+        console.log('[Server] Start complete, listening on port', this.port);
         return this;
     }
 }