remult 0.17.0-exp.2 → 0.17.0-exp.3

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,8 +1,8 @@
 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 { AMessageChannel, ChannelSubscribe } from './src/live-query/LiveQuerySubscriber';
+import { ServerEventDispatcher, ServerEventMessage } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;

package/esm/remult-express.js

@@ -1,8 +1,7 @@
 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 { remult } from './src/remult-proxy';
+import { streamUrl } from './src/live-query/LiveQuerySubscriber';
+import { LiveQueryPublisher } from './src/live-query/LiveQueryPublisher';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -24,7 +23,9 @@ export function remultExpress(options) {
         httpServerEvents.openHttpServerStream(req, res);
     });
     app.post(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        httpServerEvents.subscribeToChannel(remult, req.body, res);
+        server.liveQueryManager.unsubscribe(req.body);
+        res.json("ok");
+        //httpServerEvents.subscribeToChannel(remult, req.body, res)
     });
     app.get(streamPath + '/stats', (req, res) => {
         httpServerEvents.consoleInfo();
@@ -50,7 +51,7 @@ export class ServerEventsController {
         }
     }
     consoleInfo() {
-        console.log(this.connections.map(x => ({
+        console.info(this.connections.map(x => ({
             client: x.clientId,
             channels: x.channels
         })));
@@ -111,7 +112,6 @@ export class ServerEventsController {
         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));
     }
 }
@@ -121,12 +121,10 @@ class clientConnection {
         this.clientId = clientId;
         this.channels = {};
         this.closed = false;
-        //console.log("open connection");
         response.write("event:authenticate\ndata:" + "key" + "\n\n");
         this.sendLiveMessage();
     }
     close() {
-        //console.log("close connection");
         this.closed = true;
     }
     write(id, message, eventType) {

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

@@ -162,7 +162,7 @@ export class RemultServerImplementation {
     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, '')))
@@ -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,7 @@ 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";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;

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 {

package/esm/src/data-api.js

@@ -1,5 +1,6 @@
 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) {
         this.repository = repository;
@@ -175,17 +176,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) {

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

@@ -1,6 +1,6 @@
-import { LiveQueryProvider, MessageHandler } from "./LiveQuery";
+import { LiveQueryProvider, MessageHandler } from "./LiveQuerySubscriber";
 export declare class EventSourceLiveQueryProvider implements LiveQueryProvider {
     private wrapMessage?;
     constructor(wrapMessage?: (what: () => void) => void);
-    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler, onReconnect: VoidFunction): Promise<VoidFunction>;
 }

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

@@ -1,20 +1,27 @@
 import { remult } from "../remult-proxy";
-import { streamUrl } from "./LiveQuery";
+import { streamUrl } from "./LiveQuerySubscriber";
 export class EventSourceLiveQueryProvider {
     constructor(wrapMessage) {
         this.wrapMessage = wrapMessage;
         if (!this.wrapMessage)
             this.wrapMessage = x => x();
     }
-    openStreamAndReturnCloseFunction(clientId, onMessage) {
+    openStreamAndReturnCloseFunction(clientId, onMessage, onReconnect) {
         const source = new EventSource(remult.apiClient.url + '/' + streamUrl + "?id=" + clientId, {
             withCredentials: true
         });
         source.onmessage = e => {
             this.wrapMessage(() => onMessage(JSON.parse(e.data)));
         };
+        source.onerror = e => {
+            console.error("Live Query Event Source Error", e);
+        };
         return new Promise((res) => {
+            let connected = false;
             source.onopen = e => {
+                if (connected)
+                    onReconnect();
+                connected = true;
                 res(() => {
                     source.close();
                 });

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

@@ -1,6 +1,6 @@
 import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
 import { Allowed } from '../context';
-import { ServerEventDispatcher } from './LiveQueryManager';
+import { ServerEventDispatcher } from './LiveQueryPublisher';
 export declare const streamUrl = "stream1";
 export interface LiveQueryProvider {
     openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;

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

@@ -4,7 +4,7 @@ import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
 import { buildRestDataProvider } from '../context';
 import { getId } from '../remult3/getId';
 export const streamUrl = 'stream1';
-class LiveQueryOnFrontEnd {
+class LiveQuerySubscriber {
     constructor(repo, query) {
         this.repo = repo;
         this.query = query;
@@ -54,6 +54,7 @@ class LiveQueryOnFrontEnd {
                     this.forListeners(listener => listener(items => {
                         if (!items)
                             items = [];
+                        items = items.filter(x => getId(this.repo.metadata, x) !== getId(this.repo.metadata, item));
                         items.push(item);
                         return sort(items);
                     }));
@@ -141,7 +142,7 @@ export class LiveQueryClient {
             const eventTypeKey = JSON.stringify({ url, filterObject });
             let q = this.queries.get(eventTypeKey);
             if (!q) {
-                this.queries.set(eventTypeKey, q = new LiveQueryOnFrontEnd(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
+                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
                 url.add("__action", 'subscribe|' + this.clientId);
                 const thenResult = (r) => {
                     this.runPromise(q.setAllItems(r.result));

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

@@ -0,0 +1,33 @@
+import { Remult } from '../..';
+import { Repository, EntityRef, FindOptions } from '../remult3';
+import { LiveQueryProvider } from '../data-api';
+import { ChannelSubscribe, liveQueryMessage } from './LiveQuerySubscriber';
+export declare class LiveQueryPublisher implements LiveQueryProvider {
+    private dispatcher;
+    unsubscribe(data: ChannelSubscribe): void;
+    constructor(dispatcher: ServerEventDispatcher);
+    subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
+    clients: clientInfo[];
+    hasListeners(ref: EntityRef<any>): boolean;
+    runPromise(p: Promise<any>): void;
+    saved(ref: EntityRef<any>): void;
+    deleted(ref: EntityRef<any>): void;
+}
+export interface clientInfo {
+    clientId: string;
+    queries: ({
+        id: string;
+        repo: Repository<any>;
+        findOptions: FindOptions<any>;
+        ids: any[];
+    })[];
+}
+export interface ServerEventDispatcher {
+    sendQueryMessage(message: ServerEventMessage): void;
+    sendChannelMessage<T>(channel: string, message: any): void;
+}
+export interface ServerEventMessage {
+    clientId: string;
+    queryId: string;
+    message: liveQueryMessage;
+}

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

@@ -0,0 +1,102 @@
+import { v4 as uuid } from 'uuid';
+export class LiveQueryPublisher {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.clients = [];
+    }
+    unsubscribe(data) {
+        let client = this.clients.find(c => c.clientId === data.clientId);
+        if (client)
+            client.queries = client.queries.filter(q => q.id !== data.channel);
+    }
+    subscribe(repo, clientId, findOptions, remult, ids) {
+        let client = this.clients.find(c => c.clientId === clientId);
+        if (!client) {
+            this.clients.push(client = { clientId: clientId, queries: [] });
+        }
+        const id = uuid();
+        client.queries.push({
+            id,
+            findOptions: findOptions,
+            repo,
+            ids
+        });
+        return id;
+    }
+    hasListeners(ref) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key)
+                    return true;
+            }
+        }
+        return false;
+    }
+    runPromise(p) {
+    }
+    //TODO - reconsider usage of zone
+    saved(ref) {
+        const isNew = ref.isNew();
+        const origId = isNew ? ref.getId() : ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    this.runPromise(q.repo.find(q.findOptions).then(currentItems => {
+                        const currentIds = currentItems.map(x => q.repo.getEntityRef(x).getId());
+                        const sendMessage = (message) => {
+                            this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                        };
+                        for (const id of q.ids.filter(y => !currentIds.includes(y))) {
+                            if (id != origId || !currentIds.includes(ref.getId()))
+                                sendMessage({
+                                    type: "remove",
+                                    data: {
+                                        id: id
+                                    }
+                                });
+                        }
+                        for (const item of currentItems) {
+                            const itemRef = q.repo.getEntityRef(item);
+                            if (itemRef.getId() == ref.getId() && q.ids.includes(origId)) {
+                                sendMessage({
+                                    type: "replace",
+                                    data: {
+                                        oldId: origId,
+                                        item: itemRef.toApiJson()
+                                    }
+                                });
+                            }
+                            else if (!q.ids.includes(itemRef.getId())) {
+                                sendMessage({
+                                    type: "add",
+                                    data: { item: itemRef.toApiJson() }
+                                });
+                            }
+                        }
+                        q.ids = currentIds;
+                    }));
+                }
+            }
+        }
+    }
+    deleted(ref) {
+        const id = ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    if (q.ids.includes(id)) {
+                        this.dispatcher.sendQueryMessage({
+                            clientId: c.clientId, queryId: q.id, message: {
+                                type: "remove",
+                                data: {
+                                    id: id
+                                }
+                            }
+                        });
+                        q.ids = q.ids.filter(y => y != id);
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
+import { Allowed } from '../context';
+import { ServerEventDispatcher } from './LiveQueryPublisher';
+export declare const streamUrl = "stream1";
+export interface LiveQueryProvider {
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler, onReconnect: VoidFunction): Promise<VoidFunction>;
+}
+export declare type MessageHandler = (message: {
+    data: any;
+    event: string;
+}) => void;
+export declare class LiveQueryClient {
+    lqp: LiveQueryProvider;
+    private provider?;
+    clientId: any;
+    private queries;
+    private channels;
+    constructor(lqp: LiveQueryProvider, provider?: RestDataProviderHttpProvider);
+    runPromise(p: Promise<any>): Promise<any>;
+    close(): void;
+    subscribeChannel<T>(key: string, onResult: (item: T) => void): () => void;
+    private closeIfNoListeners;
+    subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
+    closeListener: Promise<VoidFunction>;
+    private openIfNoOpened;
+}
+export declare type listener = (message: any) => void;
+export interface SubscribeToQueryArgs<entityType = any> {
+    entityKey: string;
+    orderBy?: EntityOrderBy<entityType>;
+}
+export declare type liveQueryMessage = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export interface SubscribeResult {
+    result: [];
+    id: string;
+}
+export interface ChannelSubscribe {
+    clientId: string;
+    channel: string;
+    remove: boolean;
+}
+export declare class AMessageChannel<messageType> {
+    private subscribedAllowed;
+    userCanSubscribe(channel: string, remult: Remult): boolean;
+    private key;
+    constructor(key: (string | ((remult: Remult) => string)), subscribedAllowed: Allowed);
+    send(what: messageType, remult?: Remult): void;
+    subscribe(client: LiveQueryClient, onValue: (value: messageType) => void, remult?: Remult): void;
+    dispatcher: ServerEventDispatcher;
+}