remult 0.17.0-exp.2 → 0.17.0-exp.4

package/esm/live-query/ably.d.ts

@@ -0,0 +1,13 @@
+import type * as Ably from 'ably';
+import { ServerEventDispatcher } from '../src/live-query/LiveQueryPublisher';
+import { LiveQueryProvider, PubSubClient } from '../src/live-query/LiveQuerySubscriber';
+export declare class AblyLiveQueryProvider implements LiveQueryProvider {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
+}
+export declare class AblyServerEventDispatcher implements ServerEventDispatcher {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    sendChannelMessage<T>(channel: string, message: T): void;
+}

package/esm/live-query/ably.js

@@ -0,0 +1,25 @@
+export class AblyLiveQueryProvider {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openStreamAndReturnCloseFunction(onReconnect) {
+        return {
+            disconnect: () => {
+                this.ably.connection.close();
+            },
+            subscribe: (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => { myHandler = () => { }; };
+            }
+        };
+    }
+}
+export class AblyServerEventDispatcher {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    sendChannelMessage(channel, message) {
+        this.ably.channels.get(channel).publish({ data: message });
+    }
+}

package/esm/live-query/ablyLiveQuery.d.ts

@@ -0,0 +1,13 @@
+import type * as Ably from 'ably';
+import { ServerEventDispatcher } from './LiveQueryPublisher';
+import { LiveQueryProvider, PubSubClient } from './LiveQuerySubscriber';
+export declare class AblyLiveQueryProvider implements LiveQueryProvider {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
+}
+export declare class AblyServerEventDispatcher implements ServerEventDispatcher {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    sendChannelMessage<T>(channel: string, message: T): void;
+}

package/esm/live-query/ablyLiveQuery.js

@@ -0,0 +1,25 @@
+export class AblyLiveQueryProvider {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openStreamAndReturnCloseFunction(onReconnect) {
+        return {
+            disconnect: () => {
+                this.ably.connection.close();
+            },
+            subscribe: (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => { myHandler = () => { }; };
+            }
+        };
+    }
+}
+export class AblyServerEventDispatcher {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    sendChannelMessage(channel, message) {
+        this.ably.channels.get(channel).publish({ data: message });
+    }
+}

package/esm/live-query/index.d.ts

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "../src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from '../src/live-query/LiveQuerySubscriber';

package/esm/live-query/index.js

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher } from "../src/live-query/LiveQueryPublisher";
+export { LiveQueryClient } from '../src/live-query/LiveQuerySubscriber';

package/esm/live-query/live-query.d.ts

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';
+export {};

package/esm/live-query/live-query.js

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';

package/esm/live-query.d.ts

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';
+export {};

package/esm/live-query.js

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher } from "./src/live-query/LiveQueryPublisher";
+export { LiveQueryClient } from './src/live-query/LiveQuerySubscriber';

package/esm/postgres/schema-builder.js

@@ -43,7 +43,7 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.log("start verify structure"); //keep me
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
             let e = await getDbNameProvider(entity);
@@ -56,7 +56,7 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + e.entityName + " ", err);
+                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
             }
         }
     }
@@ -102,7 +102,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
     async verifyAllColumns(entity) {
@@ -122,7 +122,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/remult-express.d.ts

@@ -1,38 +1,30 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
 import { Remult } from './src/context';
-import { AMessageChannel, ChannelSubscribe } from './src/live-query/LiveQuery';
-import { ServerEventDispatcher, ServerEventMessage } from './src/live-query/LiveQueryManager';
+import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
+import { ServerEventDispatcher } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    messageChannels?: AMessageChannel<any>[];
+    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
 }): express.RequestHandler & RemultServer;
 export declare class ServerEventsController implements ServerEventDispatcher {
-    private channels;
-    private messageHistoryLength;
+    private canUserConnectToChannel?;
+    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
     consoleInfo(): void;
-    subscribeToChannel(remult: Remult, info: ChannelSubscribe, res: import('express').Response): void;
     connections: clientConnection[];
-    constructor(channels: AMessageChannel<any>[], messageHistoryLength?: number);
-    sendQueryMessage({ message, clientId, queryId }: ServerEventMessage): void;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
     sendChannelMessage<T>(channel: string, message: any): void;
     openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
-    messages: {
-        id: number;
-        message: any;
-        eventType: string;
-    }[];
-    SendMessage(message: any, eventType?: string): void;
 }
 declare class clientConnection {
     response: import('express').Response;
-    clientId: string;
     channels: Record<string, boolean>;
     close(): void;
     closed: boolean;
-    write(id: number, message: any, eventType: string): void;
-    constructor(response: import('express').Response, clientId: string);
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: import('express').Response);
     sendLiveMessage(): void;
 }
 export {};

package/esm/remult-express.js

@@ -1,7 +1,8 @@
 import * as express from 'express';
 import { createRemultServer } from './server/expressBridge';
-import { streamUrl } from './src/live-query/LiveQuery';
-import { LiveQueryPublisher } from './src/live-query/LiveQueryManager';
+import { streamUrl } from './src/live-query/LiveQuerySubscriber';
+import { LiveQueryPublisher } from './src/live-query/LiveQueryPublisher';
+import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
 export function remultExpress(options) {
     let app = express.Router();
@@ -17,19 +18,12 @@ export function remultExpress(options) {
     }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    let httpServerEvents = new ServerEventsController(options.messageChannels);
-    server.liveQueryManager = new LiveQueryPublisher(httpServerEvents);
-    const streamPath = options.rootPath + '/' + streamUrl;
-    app.get(streamPath, (req, res) => {
-        httpServerEvents.openHttpServerStream(req, res);
-    });
-    app.post(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        httpServerEvents.subscribeToChannel(remult, req.body, res);
-    });
-    app.get(streamPath + '/stats', (req, res) => {
-        httpServerEvents.consoleInfo();
-        res.json("ok");
-    });
+    if (!options.serverEventDispatcher) {
+        options.serverEventDispatcher = (router, server) => {
+            return buildHttpServerEventDispatcher(router, options.rootPath, server);
+        };
+    }
+    server.liveQueryManager = new LiveQueryPublisher(options.serverEventDispatcher(app, server));
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -38,52 +32,40 @@ export function remultExpress(options) {
     });
 }
 export class ServerEventsController {
-    constructor(channels, messageHistoryLength = 1000) {
-        this.channels = channels;
-        this.messageHistoryLength = messageHistoryLength;
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
         this.connections = [];
-        this.messages = [];
-        if (channels) {
-            for (const c of channels) {
-                c.dispatcher = this;
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    c.channels[channel] = !remove;
+                    res.json("ok");
+                    return;
+                }
+                else {
+                    res.sendStatus(403);
+                    return;
+                }
             }
         }
+        res.sendStatus(404);
     }
     consoleInfo() {
-        console.log(this.connections.map(x => ({
-            client: x.clientId,
+        console.info(this.connections.map(x => ({
+            client: x.connectionId,
             channels: x.channels
         })));
     }
-    subscribeToChannel(remult, info, res) {
-        let ok = false;
-        if (this.channels)
-            for (const sc of this.connections) {
-                if (sc.clientId === info.clientId) {
-                    for (const c of this.channels) {
-                        if (c.userCanSubscribe(info.channel, remult)) {
-                            sc.channels[info.channel] = !info.remove;
-                            ok = true;
-                        }
-                    }
-                }
-            }
-        if (ok)
-            res.json("ok");
-        else
-            res.status(404).json(`Channel "${info.channel}" not found`);
-    }
-    sendQueryMessage({ message, clientId, queryId }) {
-        for (const sc of this.connections) {
-            if (sc.clientId === clientId) {
-                sc.write(undefined, message, queryId);
-            }
-        }
-    }
     sendChannelMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
         for (const sc of this.connections) {
             if (sc.channels[channel]) {
-                sc.write(undefined, message, channel);
+                sc.write(data);
             }
         }
     }
@@ -93,11 +75,8 @@ export class ServerEventsController {
             'Cache-Control': 'no-cache',
             'Connection': 'keep-alive'
         });
-        const cc = new clientConnection(res, req.headers["client-id"] || req.query['id']);
-        const lastEventId = req.headers['last-event-id'];
-        if (lastEventId) {
-            this.messages.filter(x => x.id > +lastEventId).forEach(m => cc.write(m.id, m.message, m.eventType));
-        }
+        const cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
         this.connections.push(cc);
         req.on("close", () => {
             cc.close();
@@ -105,35 +84,24 @@ export class ServerEventsController {
         });
         return cc;
     }
-    SendMessage(message, eventType = '') {
-        let z = this;
-        let id = i++;
-        z.messages.push({ id, message: message, eventType });
-        while (z.messages.length > z.messageHistoryLength)
-            z.messages.shift();
-        //console.log({ sendingTo: z.connections.length })
-        z.connections.forEach(y => y.write(id, message, eventType));
-    }
 }
 class clientConnection {
-    constructor(response, clientId) {
+    constructor(response) {
         this.response = response;
-        this.clientId = clientId;
         this.channels = {};
         this.closed = false;
-        //console.log("open connection");
-        response.write("event:authenticate\ndata:" + "key" + "\n\n");
+        this.connectionId = uuid();
+        this.write(this.connectionId, "connectionId");
         this.sendLiveMessage();
     }
     close() {
-        //console.log("close connection");
         this.closed = true;
     }
-    write(id, message, eventType) {
-        let event = "event:message";
-        if (id != undefined)
-            event += "\nid:" + id;
-        this.response.write(event + "\ndata:" + JSON.stringify({ event: eventType, data: message }) + "\n\n");
+    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();
@@ -141,13 +109,27 @@ class clientConnection {
     sendLiveMessage() {
         if (this.closed)
             return;
-        this.response.write("event:keep-alive\ndata:\n\n");
-        let r = this.response;
-        if (r.flush)
-            r.flush();
+        this.write("", "keep-alive");
         setTimeout(() => {
             this.sendLiveMessage();
         }, 45000);
     }
 }
-let i = 0;
+function buildHttpServerEventDispatcher(router, apiPath, server) {
+    const streamPath = apiPath + '/' + streamUrl;
+    let httpServerEvents = new ServerEventsController();
+    router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.openHttpServerStream(req, res);
+    });
+    router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult);
+    });
+    router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult, true);
+    });
+    router.get(streamPath + '/stats', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.consoleInfo();
+        res.json("ok");
+    });
+    return httpServerEvents;
+}

package/esm/remult-knex/index.js

@@ -256,7 +256,7 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.info("start verify structure");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -319,7 +319,7 @@ export class KnexSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/server/expressBridge.d.ts

@@ -5,7 +5,7 @@ import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { LiveQueryPublisher } from '../src/live-query/LiveQueryManager';
+import { LiveQueryPublisher } from '../src/live-query/LiveQueryPublisher';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *

package/esm/server/expressBridge.js

@@ -155,14 +155,14 @@ export class RemultServerImplementation {
             let key = getEntityKey(e);
             if (key != undefined)
                 this.add(key, c => {
-                    return new DataApi(c.repo(e), c, this.liveQueryManager);
+                    return new DataApi(c.repo(e), c);
                 }, r);
         });
     }
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
             .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
@@ -180,7 +180,7 @@ export class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult._changeListener = this.liveQueryManager;
+            remult.liveQueryPublisher = this.liveQueryManager;
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
                 remultObjectStorage.run(remult, async () => {
@@ -225,7 +225,7 @@ export class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);

package/esm/src/context.d.ts

@@ -2,7 +2,8 @@ import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
 import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQuery";
+import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
+import type { ServerEventDispatcher } from "../live-query";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
@@ -63,10 +64,11 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
+    liveQueryPublisher: LiveQueryPublisherInterface;
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** The current data provider */
     dataProvider: DataProvider;
-    liveQueryProvider: LiveQueryClient;
+    liveQuerySubscriber: LiveQueryClient;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
@@ -115,3 +117,15 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
+export interface LiveQueryPublisherInterface {
+    stopLiveQuery(id: any): void;
+    sendChannelMessage<messageType>(channel: string, message: messageType): void;
+    defineLiveQueryChannel(repo: Repository<any>, options: FindOptions<any>, remult: Remult, ids: any[]): string;
+    itemChanged(entityKey: string, changes: itemChange[]): void;
+    dispatcher: ServerEventDispatcher;
+}
+export interface itemChange {
+    id: any;
+    oldId: any;
+    deleted: boolean;
+}

package/esm/src/context.js

@@ -1,7 +1,7 @@
 import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
-import { LiveQueryClient } from "./live-query/LiveQuery";
+import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
 import { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
 import { RemultProxy } from "./remult-proxy";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
@@ -98,14 +98,20 @@ export class Remult {
     constructor(provider) {
         /* @internal */
         this.repCache = new Map();
-        /*@internal*/
-        this._changeListener = {
-            saved: (ref) => { },
-            deleted: (ref) => { }
+        this.liveQueryPublisher = {
+            itemChanged: () => { },
+            defineLiveQueryChannel: () => "",
+            dispatcher: undefined,
+            sendChannelMessage: function (arg0, what) {
+                throw new Error("invalid publisher.");
+            },
+            stopLiveQuery: function (id) {
+                throw new Error("Function not implemented.");
+            }
         };
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
-        this.liveQueryProvider = new LiveQueryClient(new EventSourceLiveQueryProvider());
+        this.liveQuerySubscriber = new LiveQueryClient(new EventSourceLiveQueryProvider());
         this.context = {};
         this.apiClient = {
             url: '/api'

package/esm/src/data-api.d.ts

@@ -1,14 +1,10 @@
 import { Remult } from './context';
-import { FindOptions, Repository } from './remult3';
+import { Repository } from './remult3';
 import { ErrorInfo } from './data-interfaces';
-export interface LiveQueryProvider {
-    subscribe(repo: Repository<any>, id: string, options: FindOptions<any>, remult: Remult, ids: any[]): string;
-}
 export declare class DataApi<T = any> {
     private repository;
     private remult;
-    private liveQueryProvider?;
-    constructor(repository: Repository<T>, remult: Remult, liveQueryProvider?: LiveQueryProvider);
+    constructor(repository: Repository<T>, remult: Remult);
     httpGet(res: DataApiResponse, req: DataApiRequest): Promise<void>;
     httpPost(res: DataApiResponse, req: DataApiRequest, body: any): Promise<void>;
     static defaultGetLimit: number;

package/esm/src/data-api.js

@@ -1,10 +1,10 @@
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
 import { Filter } from './filter/filter-interfaces';
+import { ForbiddenError } from './server-action';
 export class DataApi {
-    constructor(repository, remult, liveQueryProvider) {
+    constructor(repository, remult) {
         this.repository = repository;
         this.remult = remult;
-        this.liveQueryProvider = liveQueryProvider;
     }
     httpGet(res, req) {
         if (req.get("__action") == "count") {
@@ -15,13 +15,17 @@ export class DataApi {
     }
     httpPost(res, req, body) {
         const action = req?.get("__action");
-        if (action?.startsWith("subscribe"))
+        if (action?.startsWith("liveQuery"))
             return this.getArray(res, req, body);
         switch (action) {
             case "get":
                 return this.getArray(res, req, body);
             case "count":
                 return this.count(res, req, body);
+            case "endLiveQuery":
+                this.remult.liveQueryPublisher.stopLiveQuery(body.id);
+                res.success("ok");
+                return;
             default:
                 return this.post(res, body);
         }
@@ -98,9 +102,9 @@ export class DataApi {
                 .then(async (r) => {
                 return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
             });
-            if (this.liveQueryProvider && action?.startsWith("subscribe")) {
+            if (this.remult.liveQueryPublisher && action?.startsWith("liveQuery")) {
                 response.success({
-                    id: this.liveQueryProvider.subscribe(this.repository, action.split('|')[1], findOptions, this.remult, r.map(y => this.repository.getEntityRef(y).getId())),
+                    queryChannel: this.remult.liveQueryPublisher.defineLiveQueryChannel(this.repository, findOptions, this.remult, r.map(y => this.repository.getEntityRef(y).getId())),
                     result: r
                 });
                 return;
@@ -175,17 +179,26 @@ export class DataApi {
     }
     async post(response, body) {
         try {
-            let newr = this.repository.create();
-            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body);
-            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
-                response.forbidden();
-                return;
+            const insert = async (what) => {
+                let newr = this.repository.create();
+                await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
+                if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                    throw new ForbiddenError();
+                }
+                await this.repository.getEntityRef(newr).save();
+                return this.repository.getEntityRef(newr).toApiJson();
+            };
+            if (Array.isArray(body)) {
+                response.created(await Promise.all(body.map(x => insert(x))));
             }
-            await this.repository.getEntityRef(newr).save();
-            response.created(this.repository.getEntityRef(newr).toApiJson());
+            else
+                response.created(await insert(body));
         }
         catch (err) {
-            response.error(err);
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
         }
     }
 }

package/esm/src/data-providers/sql-database.js

@@ -76,7 +76,7 @@ class LogSQLCommand {
             if (this.allQueries) {
                 var d = new Date().valueOf() - start.valueOf();
                 if (d > SqlDatabase.durationThreshold) {
-                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+                    console.info({ query: sql, arguments: this.args, duration: d / 1000 });
                 }
             }
             return r;

package/esm/src/data-providers/web-sql-data-provider.js

@@ -18,7 +18,7 @@ export class WebSqlDataProvider {
         let e = await getDbNameProvider(entity);
         let sql = 'drop  table if exists ' + e.entityName;
         if (SqlDatabase.LogToConsole)
-            console.log(sql);
+            console.info(sql);
         await this.createCommand().execute(sql);
     }
     async createTable(entity) {