remult 0.18.1-exp.24 → 0.18.1-exp.26

package/SseSubscriptionServer.d.ts

@@ -0,0 +1,23 @@
+import { GenericResponse } from './server/index';
+import { Remult } from './src/context';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+export declare class SseSubscriptionServer implements SubscriptionServer {
+    private canUserConnectToChannel?;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    publishMessage<T>(channel: string, message: any): void;
+}
+export interface ResponseRequiredForSSE {
+    write(data: string): void;
+    writeHead(status: number, headers: any): void;
+    flush?(): void;
+}
+export declare class clientConnection {
+    response: GenericResponse & ResponseRequiredForSSE;
+    channels: Record<string, boolean>;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: GenericResponse & ResponseRequiredForSSE);
+    sendLiveMessage(): void;
+}

package/SseSubscriptionServer.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientConnection = exports.SseSubscriptionServer = void 0;
+var tslib_1 = require("tslib");
+var uuid_1 = require("uuid");
+var SseSubscriptionServer = /** @class */ (function () {
+    function SseSubscriptionServer(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
+        this.connections = [];
+        //@internal
+        this.debugMessageFileSaver = function (id, channel, message) { };
+        //@internal
+        this.debugFileSaver = function () { };
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = function () { return true; };
+        }
+    }
+    //@internal
+    SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
+        var e_1, _b;
+        var channel = _a.channel, clientId = _a.clientId;
+        if (remove === void 0) { remove = false; }
+        try {
+            for (var _c = tslib_1.__values(this.connections), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var c = _d.value;
+                if (c.connectionId === clientId) {
+                    if (this.canUserConnectToChannel(channel, remult)) {
+                        if (remove)
+                            delete c.channels[channel];
+                        else
+                            c.channels[channel] = true;
+                        res.success("ok");
+                        this.debug();
+                        return;
+                    }
+                    else {
+                        res.forbidden();
+                        this.debug();
+                        return;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        res.error({ message: "client connection not found" });
+    };
+    SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
+        var e_2, _a;
+        var data = JSON.stringify({ channel: channel, data: message });
+        try {
+            for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var sc = _c.value;
+                if (sc.channels[channel]) {
+                    this.debugMessageFileSaver(sc.connectionId, channel, message);
+                    sc.write(data);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    //@internal
+    SseSubscriptionServer.prototype.openHttpServerStream = function (req, res) {
+        var _this = this;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        var cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
+        this.connections.push(cc);
+        this.debug();
+        //@ts-ignore
+        req.on("close", function () {
+            cc.close();
+            _this.connections = _this.connections.filter(function (s) { return s !== cc; });
+            _this.debug();
+        });
+        return cc;
+    };
+    //@internal
+    SseSubscriptionServer.prototype.debug = function () {
+        this.debugFileSaver(this.connections.map(function (x) { return ({
+            id: x.connectionId,
+            channels: x.channels
+        }); }));
+    };
+    return SseSubscriptionServer;
+}());
+exports.SseSubscriptionServer = SseSubscriptionServer;
+var clientConnection = /** @class */ (function () {
+    function clientConnection(response) {
+        this.response = response;
+        this.channels = {};
+        this.closed = false;
+        this.connectionId = uuid_1.v4();
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    clientConnection.prototype.close = function () {
+        this.closed = true;
+    };
+    clientConnection.prototype.write = function (eventData, eventType) {
+        if (eventType === void 0) { eventType = "message"; }
+        var event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
+        if (this.response.flush)
+            this.response.flush();
+    };
+    clientConnection.prototype.sendLiveMessage = function () {
+        var _this = this;
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        setTimeout(function () {
+            _this.sendLiveMessage();
+        }, 45000);
+    };
+    return clientConnection;
+}());
+exports.clientConnection = clientConnection;

package/esm/SseSubscriptionServer.d.ts

@@ -0,0 +1,23 @@
+import { GenericResponse } from './server/index';
+import { Remult } from './src/context';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
+export declare class SseSubscriptionServer implements SubscriptionServer {
+    private canUserConnectToChannel?;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    publishMessage<T>(channel: string, message: any): void;
+}
+export interface ResponseRequiredForSSE {
+    write(data: string): void;
+    writeHead(status: number, headers: any): void;
+    flush?(): void;
+}
+export declare class clientConnection {
+    response: GenericResponse & ResponseRequiredForSSE;
+    channels: Record<string, boolean>;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: GenericResponse & ResponseRequiredForSSE);
+    sendLiveMessage(): void;
+}

package/esm/SseSubscriptionServer.js

@@ -0,0 +1,101 @@
+import { v4 as uuid } from 'uuid';
+export class SseSubscriptionServer {
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
+        this.connections = [];
+        //@internal
+        this.debugMessageFileSaver = (id, channel, message) => { };
+        //@internal
+        this.debugFileSaver = () => { };
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    //@internal
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    if (remove)
+                        delete c.channels[channel];
+                    else
+                        c.channels[channel] = true;
+                    res.success("ok");
+                    this.debug();
+                    return;
+                }
+                else {
+                    res.forbidden();
+                    this.debug();
+                    return;
+                }
+            }
+        }
+        res.error({ message: "client connection not found" });
+    }
+    publishMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
+        for (const sc of this.connections) {
+            if (sc.channels[channel]) {
+                this.debugMessageFileSaver(sc.connectionId, channel, message);
+                sc.write(data);
+            }
+        }
+    }
+    //@internal
+    openHttpServerStream(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        const cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
+        this.connections.push(cc);
+        this.debug();
+        //@ts-ignore
+        req.on("close", () => {
+            cc.close();
+            this.connections = this.connections.filter(s => s !== cc);
+            this.debug();
+        });
+        return cc;
+    }
+    //@internal
+    debug() {
+        this.debugFileSaver(this.connections.map(x => ({
+            id: x.connectionId,
+            channels: x.channels
+        })));
+    }
+}
+export class clientConnection {
+    constructor(response) {
+        this.response = response;
+        this.channels = {};
+        this.closed = false;
+        this.connectionId = uuid();
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    close() {
+        this.closed = true;
+    }
+    write(eventData, eventType = "message") {
+        let event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
+        if (this.response.flush)
+            this.response.flush();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}

package/esm/graphql.js

@@ -1,17 +1,24 @@
 import { Remult } from ".";
 import { allEntities } from "./src/context";
-import { getEntityKey } from "./src/remult3";
 import { DataApi } from "./src/data-api";
 export function remultGraphql(api) {
     let r = new Remult();
-    let types = '';
+    let types = [];
+    let filterTypes = '';
     let query = '';
     let root = {};
+    function getType(key) {
+        let t = types.find(t => t.key === key);
+        if (!t)
+            types.push((t = ({ fields: "", key, moreFields: "", resultProcessors: [] })));
+        return t;
+    }
     for (const e of allEntities) {
         let meta = r.repo(e).metadata;
-        let fields = '';
         let filterFields = '';
-        let key = getEntityKey(e);
+        let key = meta.key;
+        const t = getType(key);
+        let q = "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
         if (key) {
             for (const f of meta.fields) {
                 {
@@ -19,6 +26,7 @@ export function remultGraphql(api) {
                     switch (f.valueType) {
                         case Boolean:
                             type = "Boolean";
+                            break;
                         case Number:
                             {
                                 if (f.valueConverter?.fieldTypeInDb == 'integer')
@@ -26,8 +34,31 @@ export function remultGraphql(api) {
                                 else
                                     type = "Float";
                             }
+                            break;
+                    }
+                    if (allEntities.includes(f.valueType)) {
+                        const refKey = r.repo(f.valueType).metadata.key;
+                        t.fields += "\n\t" + f.key + ":" + refKey;
+                        t.resultProcessors.push(r => {
+                            const val = r[f.key];
+                            r[f.key] = async (args, req, gqlInfo) => {
+                                const queryResult = await root[refKey]({ ...args.filter, filter: { id: val }, options: { limit: 1 } }, req, gqlInfo);
+                                if (queryResult.length > 0)
+                                    return queryResult[0];
+                                return null;
+                            };
+                        });
+                        let refT = getType(refKey);
+                        refT.moreFields += q;
+                        refT.resultProcessors.push(r => {
+                            const val = r.id;
+                            r[key] = async (args, req, gqlInfo) => {
+                                return await root[key]({ filter: { ...args.filter, [f.key]: val }, options: args.options }, req, gqlInfo);
+                            };
+                        });
                     }
-                    fields += "\n\t" + f.key + ":" + type;
+                    else
+                        t.fields += "\n\t" + f.key + ":" + type;
                     for (const operator of ["", "_ne"]) {
                         filterFields += "\n\t" + f.key + operator + ":" + type;
                     }
@@ -44,41 +75,49 @@ export function remultGraphql(api) {
                     filterFields += "\n\t" + f.key + "_in:[" + type + "]";
                 }
             }
-            types += "type " + key + "{" + fields + "\n}\n";
-            types += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
-            query += "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
-            root[key] = async ({ options, filter }, req) => {
-                let remult = await api.getRemult(req);
-                let repo = remult.repo(e);
-                let dApi = new DataApi(repo, remult);
-                let result;
-                let err;
-                await dApi.getArray({
-                    success: x => result = x,
-                    created: undefined,
-                    deleted: undefined,
-                    error: x => err = x,
-                    forbidden: () => err = 'forbidden',
-                    notFound: () => err = 'not found',
-                    progress: undefined
-                }, {
-                    get: key => {
-                        if (options)
-                            switch (key) {
-                                case "_limit":
-                                    return options.limit;
-                                case "_page":
-                                    return options.page;
-                                case "_sort":
-                                    return options.sort;
-                                case "_order":
-                                    return options.order;
+            filterTypes += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
+            query += q;
+            root[key] = async ({ options, filter }, req, a) => {
+                return new Promise(async (res, error) => {
+                    api.withRemult(req, undefined, async () => {
+                        let remult = await api.getRemult(req);
+                        let repo = remult.repo(e);
+                        let dApi = new DataApi(repo, remult);
+                        let result;
+                        let err;
+                        await dApi.getArray({
+                            success: x => result = x.map(y => {
+                                t.resultProcessors.forEach(z => z(y));
+                                return y;
+                            }),
+                            created: undefined,
+                            deleted: undefined,
+                            error: x => err = x,
+                            forbidden: () => err = 'forbidden',
+                            notFound: () => err = 'not found',
+                            progress: undefined
+                        }, {
+                            get: key => {
+                                if (options)
+                                    switch (key) {
+                                        case "_limit":
+                                            return options.limit;
+                                        case "_page":
+                                            return options.page;
+                                        case "_sort":
+                                            return options.sort;
+                                        case "_order":
+                                            return options.order;
+                                    }
                             }
-                    }
-                }, filter);
-                if (err)
-                    throw err;
-                return result;
+                        }, filter);
+                        if (err) {
+                            error(err);
+                            return;
+                        }
+                        res(result);
+                    });
+                });
             };
         }
     }
@@ -88,15 +127,15 @@ export function remultGraphql(api) {
     }
     return {
         rootValue: root,
-        schema: `
+        schema: `${types.map(({ key, fields, moreFields }) => "type " + key + "{" + fields + moreFields + "\n}\n").join('')}
+${query}
+${filterTypes}
 input options{
     limit:Int
     page:Int
     sort:String
     order:String
 }
-${types}
-${query}
 `
     };
 }

package/esm/live-query/ably.js

@@ -7,10 +7,13 @@ export class AblySubscriptionClient {
             close: () => {
                 this.ably.connection.close();
             },
-            subscribe: (channel, handler) => {
+            subscribe: async (channel, handler) => {
                 let myHandler = (y) => handler(y.data);
-                this.ably.channels.get(channel).subscribe(y => myHandler(y));
-                return () => { myHandler = () => { }; };
+                await this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => {
+                    myHandler = () => { };
+                    this.ably.channels.get(channel).unsubscribe();
+                };
             }
         };
     }

package/esm/remult-express.d.ts

@@ -1,14 +1,6 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
-import { Remult } from './src/context';
-import { SubscriptionServer } from './src/live-query/SubscriptionServer';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
 }): express.RequestHandler & RemultServer;
-export declare class SseSubscriptionServer implements SubscriptionServer {
-    private canUserConnectToChannel?;
-    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
-    publishMessage<T>(channel: string, message: any): void;
-    registerRoutes(router: express.Router, apiPath: string, server: RemultServer): void;
-}

package/esm/remult-express.js

@@ -1,8 +1,5 @@
 import * as express from 'express';
 import { createRemultServer } from './server/index';
-import { streamUrl } from './src/live-query/SubscriptionChannel';
-import { v4 as uuid } from 'uuid';
-import { remult } from './src/remult-proxy';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -15,15 +12,8 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    if (!options.subscriptionServer) {
-        options.subscriptionServer = new SseSubscriptionServer();
-    }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    const canRegisterRoute = options.subscriptionServer;
-    if (canRegisterRoute.registerRoutes) {
-        canRegisterRoute.registerRoutes(app, options.rootPath, server);
-    }
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -31,115 +21,3 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
-export class SseSubscriptionServer {
-    constructor(canUserConnectToChannel) {
-        this.canUserConnectToChannel = canUserConnectToChannel;
-        //@internal
-        this.connections = [];
-        //@internal
-        this.debugMessageFileSaver = (id, channel, message) => { };
-        //@internal
-        this.debugFileSaver = () => { };
-        if (!this.canUserConnectToChannel) {
-            this.canUserConnectToChannel = () => true;
-        }
-    }
-    //@internal
-    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
-        for (const c of this.connections) {
-            if (c.connectionId === clientId) {
-                if (this.canUserConnectToChannel(channel, remult)) {
-                    if (remove)
-                        delete c.channels[channel];
-                    else
-                        c.channels[channel] = true;
-                    res.json("ok");
-                    this.debug();
-                    return;
-                }
-                else {
-                    res.sendStatus(403);
-                    this.debug();
-                    return;
-                }
-            }
-        }
-        res.sendStatus(404);
-    }
-    publishMessage(channel, message) {
-        const data = JSON.stringify({ channel, data: message });
-        for (const sc of this.connections) {
-            if (sc.channels[channel]) {
-                this.debugMessageFileSaver(sc.connectionId, channel, message);
-                sc.write(data);
-            }
-        }
-    }
-    //@internal
-    openHttpServerStream(req, res) {
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive'
-        });
-        const cc = new clientConnection(res);
-        //const lastEventId = req.headers['last-event-id'];
-        this.connections.push(cc);
-        this.debug();
-        req.on("close", () => {
-            cc.close();
-            this.connections = this.connections.filter(s => s !== cc);
-            this.debug();
-        });
-        return cc;
-    }
-    //@internal
-    debug() {
-        this.debugFileSaver(this.connections.map(x => ({
-            id: x.connectionId,
-            channels: x.channels
-        })));
-    }
-    registerRoutes(router, apiPath, server) {
-        const streamPath = apiPath + '/' + streamUrl;
-        router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-            remult.subscriptionServer.openHttpServerStream(req, res);
-        });
-        router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-            remult.subscriptionServer.subscribeToChannel(req.body, res, remult);
-        });
-        router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-            remult.subscriptionServer.subscribeToChannel(req.body, res, remult, true);
-        });
-    }
-}
-class clientConnection {
-    constructor(response) {
-        this.response = response;
-        this.channels = {};
-        this.closed = false;
-        this.connectionId = uuid();
-        this.write(this.connectionId, "connectionId");
-        this.sendLiveMessage();
-    }
-    close() {
-        this.closed = true;
-    }
-    write(eventData, eventType = "message") {
-        let event = "event:" + eventType;
-        // if (id != undefined)
-        //     event += "\nid:" + id;
-        this.response.write(event + "\ndata:" + eventData + "\n\n");
-        let r = this.response;
-        if (r.flush)
-            r.flush();
-    }
-    sendLiveMessage() {
-        if (this.closed)
-            return;
-        this.write("", "keep-alive");
-        setTimeout(() => {
-            this.sendLiveMessage();
-        }, 45000);
-    }
-}

package/esm/server/core.d.ts

@@ -1,2 +1,3 @@
 export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';

package/esm/server/core.js

@@ -1,2 +1,3 @@
 export { createRemultServerCore } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';