remult 0.18.1-exp.9 → 0.18.1

package/README.md

@@ -61,6 +61,7 @@ backend ORM**.
 * :lock: Fine-grained code-based API authorization
 * :relieved: Incrementally adoptable
 * :rocket: Production ready
+* :mega: **NEW - Zero-boilerplate realtime live-queries**
 
 ### Status
 

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): Promise<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,143 @@
+"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 SseSubscriptionClient_1 = require("./src/live-query/SseSubscriptionClient");
+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.success(SseSubscriptionClient_1.ConnectionNotFoundError);
+    };
+    SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, _a, _b, sc;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                data = JSON.stringify({ channel: channel, data: message });
+                try {
+                    for (_a = tslib_1.__values(this.connections), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        sc = _b.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 (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //@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/live-query/ably.d.ts → ably.d.ts}

@@ -1,6 +1,6 @@
-import type * as Ably from 'ably';
-import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
-import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
+import type * as Ably from '../../node_modules/ably';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
 export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
@@ -8,6 +8,6 @@ export declare class AblySubscriptionClient implements SubscriptionClient {
 }
 export declare class AblySubscriptionServer implements SubscriptionServer {
     private ably;
-    constructor(ably: Ably.Types.RealtimePromise);
-    publishMessage<T>(channel: string, message: T): void;
+    constructor(ably: Ably.Types.RestPromise);
+    publishMessage<T>(channel: string, message: T): Promise<void>;
 }

package/ably.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AblySubscriptionServer = exports.AblySubscriptionClient = void 0;
+var tslib_1 = require("tslib");
+var AblySubscriptionClient = /** @class */ (function () {
+    function AblySubscriptionClient(ably) {
+        this.ably = ably;
+    }
+    AblySubscriptionClient.prototype.openConnection = function (onReconnect) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, {
+                        close: function () {
+                            // Since we did not open the connection, we do not close it
+                        },
+                        subscribe: function (channel, handler) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var myHandler;
+                            var _this = this;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        myHandler = function (y) { return handler(y.data); };
+                                        return [4 /*yield*/, this.ably.channels.get(channel).subscribe(function (y) { return myHandler(y); })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/, function () {
+                                                myHandler = function () { };
+                                                _this.ably.channels.get(channel).unsubscribe();
+                                            }];
+                                }
+                            });
+                        }); }
+                    }];
+            });
+        });
+    };
+    return AblySubscriptionClient;
+}());
+exports.AblySubscriptionClient = AblySubscriptionClient;
+var AblySubscriptionServer = /** @class */ (function () {
+    function AblySubscriptionServer(ably) {
+        this.ably = ably;
+    }
+    AblySubscriptionServer.prototype.publishMessage = function (channel, message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ably.channels.get(channel).publish({ data: message })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AblySubscriptionServer;
+}());
+exports.AblySubscriptionServer = AblySubscriptionServer;

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): Promise<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,102 @@
+import { v4 as uuid } from 'uuid';
+import { ConnectionNotFoundError } from './src/live-query/SseSubscriptionClient';
+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.success(ConnectionNotFoundError);
+    }
+    async 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/{live-query → esm}/ably.d.ts

@@ -1,6 +1,6 @@
-import type * as Ably from 'ably';
-import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
-import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
+import type * as Ably from '../../node_modules/ably';
+import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from './src/live-query/SubscriptionChannel';
 export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
@@ -8,6 +8,6 @@ export declare class AblySubscriptionClient implements SubscriptionClient {
 }
 export declare class AblySubscriptionServer implements SubscriptionServer {
     private ably;
-    constructor(ably: Ably.Types.RealtimePromise);
-    publishMessage<T>(channel: string, message: T): void;
+    constructor(ably: Ably.Types.RestPromise);
+    publishMessage<T>(channel: string, message: T): Promise<void>;
 }

package/esm/ably.js

@@ -0,0 +1,28 @@
+export class AblySubscriptionClient {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openConnection(onReconnect) {
+        return {
+            close: () => {
+                // Since we did not open the connection, we do not close it
+            },
+            subscribe: async (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                await this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => {
+                    myHandler = () => { };
+                    this.ably.channels.get(channel).unsubscribe();
+                };
+            }
+        };
+    }
+}
+export class AblySubscriptionServer {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async publishMessage(channel, message) {
+        await this.ably.channels.get(channel).publish({ data: message });
+    }
+}

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/index.d.ts

@@ -14,7 +14,7 @@ export { SqlDatabase, } from './src/data-providers/sql-database';
 export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
-export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, UserInfo } from './src/context';
 export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';

package/esm/live-query/data-provider-live-query-storage.d.ts

@@ -0,0 +1,23 @@
+import { Storage, DataProvider } from "../src/data-interfaces";
+import { LiveQueryStorage, StoredQuery } from "../src/live-query/SubscriptionServer";
+import { EntityBase, Repository } from "../src/remult3";
+export declare class DataProviderLiveQueryStorage implements LiveQueryStorage, Storage {
+    repo: Promise<Repository<LiveQueryStorageEntity>>;
+    dataProvider: Promise<DataProvider>;
+    constructor(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>));
+    ensureSchema(): Promise<void>;
+    add({ id, entityKey, data }: StoredQuery): Promise<void>;
+    remove(queryId: string): Promise<void>;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+declare class LiveQueryStorageEntity extends EntityBase {
+    id: string;
+    entityKey: string;
+    data: any;
+    lastUsedIso: string;
+}
+export {};