remult 0.16.3-exp.4 → 0.17.0-exp.1

package/README.md

@@ -3,7 +3,6 @@
     <img src="https://github.com/remult/remult/raw/master/docs/.vuepress/public/logo.png" width="140" height="140">
   </a>
   <h1>Remult</h1>
-  <p>A CRUD framework for full-stack TypeScript</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
 		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
 	</a>
@@ -25,28 +24,14 @@
   <a href="https://twitter.com/intent/tweet?text=Remult%20-%20open-source%20CRUD%20framework%20for%20full-stack%20TypeScript%0A%0A%40remultjs%0A&url=https%3A%2F%2Fgithub.com%2Fremult%2Fremult">
     <img alt="Twitter URL" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Ftext%3DRemult%2520-%2520open-source%2520CRUD%2520framework%2520for%2520full-stack%2520TypeScript%250A%250A%2540remultjs%250A%26url%3Dhttps%253A%252F%252Fgithub.com%252Fremult%252Fremult">
   </a>
+	<a href="https://twitter.com/remultjs" rel="nofollow">
+	  <img alt="Twitter Follow" src="https://img.shields.io/twitter/url.svg?label=Follow%20%40remultjs&style=social&url=https%3A%2F%2Ftwitter.com%2FRemultJs">
+	</a>
 </div>
-
-<br/>
-
-<div align="center">
-  <a href="#getting-started">Getting Started</a> |
-  <a href="#documentation">Documentation</a> |
-  <a href="#example-apps">Example Apps</a>
-</div>
-
 <hr/>
-<br/>
 
-<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
-  <p align="center">
-    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail" width="320" />
-  </p>
-</a>
-
-<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
-  <p align="center">Watch code demo on YouTube here</p>
-</a>
+[Getting Started](#getting-started) | [Documentation](#documentation) |
+[Example Apps](#example-apps)
 
 ## What is Remult?
 
@@ -54,13 +39,6 @@
 as a single source of truth for your API, frontend type-safe API client and
 backend ORM**.
 
-* :zap: Zero-boilerplate CRUD API routes with paging, sorting, and filtering for Express / Fastify / Next.js / NestJS / Koa / others...
-* :ok_hand: Fullstack type-safety for API queries, mutations and RPC, without code generation
-* :sparkles: Input validation, defined once, runs both on the backend and on the frontend for best UX
-* :lock: Fine-grained code-based API authorization
-* :relieved: Incrementally adoptable
-* :rocket: Production ready
-
 ### Status
 
 Remult is **production-ready** and, in fact, used in production apps since 2018.

package/esm/index.d.ts

@@ -1,4 +1,5 @@
-export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';

package/esm/remult-express.d.ts

@@ -1,6 +1,38 @@
 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';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
+    messageChannels?: AMessageChannel<any>[];
 }): express.RequestHandler & RemultServer;
+export declare class ServerEventsController implements ServerEventDispatcher {
+    private channels;
+    private messageHistoryLength;
+    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;
+    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);
+    sendLiveMessage(): void;
+}
+export {};

package/esm/remult-express.js

@@ -1,6 +1,8 @@
 import * as express from 'express';
 import { createRemultServer } from './server/expressBridge';
-import { initAsyncHooks } from './server/initAsyncHooks';
+import { streamUrl } from './src/live-query/LiveQuery';
+import { LiveQueryManager } from './src/live-query/LiveQueryManager';
+import { remult } from './src/remult-proxy';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -13,9 +15,21 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    initAsyncHooks();
     const server = createRemultServer(options);
     server.registerRouter(app);
+    let httpServerEvents = new ServerEventsController(options.messageChannels);
+    server.liveQueryManager = new LiveQueryManager(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");
+    });
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -23,3 +37,117 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
+export class ServerEventsController {
+    constructor(channels, messageHistoryLength = 1000) {
+        this.channels = channels;
+        this.messageHistoryLength = messageHistoryLength;
+        this.connections = [];
+        this.messages = [];
+        if (channels) {
+            for (const c of channels) {
+                c.dispatcher = this;
+            }
+        }
+    }
+    consoleInfo() {
+        console.log(this.connections.map(x => ({
+            client: x.clientId,
+            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) {
+        for (const sc of this.connections) {
+            if (sc.channels[channel]) {
+                sc.write(undefined, message, channel);
+            }
+        }
+    }
+    openHttpServerStream(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            '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));
+        }
+        this.connections.push(cc);
+        req.on("close", () => {
+            cc.close();
+            this.connections = this.connections.filter(s => s !== cc);
+        });
+        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) {
+        this.response = response;
+        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) {
+        let event = "event:message";
+        if (id != undefined)
+            event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + JSON.stringify({ event: eventType, data: message }) + "\n\n");
+        let r = this.response;
+        if (r.flush)
+            r.flush();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.response.write("event:keep-alive\ndata:\n\n");
+        let r = this.response;
+        if (r.flush)
+            r.flush();
+        setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}
+let i = 0;

package/esm/remult-fastify.js

@@ -1,5 +1,4 @@
 import { createRemultServer } from './server/expressBridge';
-import { initAsyncHooks } from './server/initAsyncHooks';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {
@@ -19,7 +18,6 @@ export function remultFastify(options) {
         };
         return response;
     }
-    initAsyncHooks();
     const api = createRemultServer(options);
     const pluginFunction = async (instance, op) => {
         //@ts-ignore

package/esm/server/expressBridge.d.ts

@@ -1,9 +1,11 @@
-import { queuedJobInfoResponse } from '../src/server-action';
+import { ActionInterface, queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { Remult, UserInfo } from '../src/context';
+import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
+import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
+import { LiveQueryManager } from '../src/live-query/LiveQueryManager';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -57,12 +59,39 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare class RemultAsyncLocalStorage {
-    private readonly remultObjectStorage;
-    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: VoidFunction): void;
-    getRemult(): Remult;
-    static instance: RemultAsyncLocalStorage;
+export declare class RemultServerImplementation implements RemultServer {
+    queue: inProcessQueueHandler;
+    options: RemultServerOptions<GenericRequest>;
+    dataProvider: DataProvider | Promise<DataProvider>;
+    constructor(queue: inProcessQueueHandler, options: RemultServerOptions<GenericRequest>, dataProvider: DataProvider | Promise<DataProvider>);
+    liveQueryManager: LiveQueryManager;
+    withRemult<T>(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
+    routeImpl: RouteImplementation;
+    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse>;
+    registeredRouter: boolean;
+    registerRouter(r: GenericRouter): void;
+    add(key: string, dataApiFactory: ((req: Remult) => DataApi), r: GenericRouter): void;
+    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, origReq: GenericRequest) => Promise<void>): (req: GenericRequest, res: GenericResponse) => Promise<void>;
+    getRemult(req: GenericRequest): Promise<Remult>;
+    hasQueue: boolean;
+    addAction(action: ActionInterface, r: GenericRouter): void;
+    openApiDoc(options: {
+        title: string;
+        version?: string;
+    }): any;
+    backendMethodsOpenApi: {
+        path: string;
+        allowed: AllowedForInstance<any>;
+        tag: string;
+    }[];
+}
+declare class inProcessQueueHandler {
+    private storage;
+    constructor(storage: QueueStorage);
+    submitJob(url: string, req: Remult, body: any): Promise<string>;
+    mapQueuedAction(url: string, what: (data: any, r: Remult, res: ApiActionResponse) => void): void;
+    actions: Map<string, (data: any, r: Remult, res: ApiActionResponse) => void>;
+    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
 }
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
@@ -88,6 +117,12 @@ export declare class EntityQueueStorage implements QueueStorage {
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
     createJob(url: string, userId: string): Promise<string>;
 }
+declare class RouteImplementation {
+    map: Map<string, Map<string, GenericRequestHandler>>;
+    route(path: string): SpecificRoute;
+    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    middleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
+}
 export declare class JobsInQueueEntity extends IdEntity {
     userId: string;
     url: string;
@@ -98,3 +133,4 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
+export {};

package/esm/server/expressBridge.js

@@ -30,11 +30,30 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
+    if (!remultObjectStorage) {
+        dataProvider = dataProvider.then(async (dp) => {
+            try {
+                const asyncHooks = await import('async_hooks');
+                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
+            }
+            catch {
+                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
+            }
+            remult.remultFactory = () => {
+                const r = remultObjectStorage.getRemult();
+                if (r)
+                    return r;
+                else
+                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+            };
+            return dp;
+        });
+    }
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+                remultObjectStorage.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -59,7 +78,7 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-export class RemultAsyncLocalStorage {
+class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
@@ -71,20 +90,13 @@ export class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw new Error("can't use static remult in this environment, `async_hooks` were not found");
+            throw "can't use static remult in this environment, `async_hooks` were not found";
         }
         return this.remultObjectStorage.getStore();
     }
 }
-RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
-remult.remultFactory = () => {
-    const r = RemultAsyncLocalStorage.instance.getRemult();
-    if (r)
-        return r;
-    else
-        throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-};
-class RemultServerImplementation {
+let remultObjectStorage;
+export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
@@ -143,7 +155,7 @@ class RemultServerImplementation {
             let key = getEntityKey(e);
             if (key != undefined)
                 this.add(key, c => {
-                    return new DataApi(c.repo(e), c);
+                    return new DataApi(c.repo(e), c, this.liveQueryManager);
                 }, r);
         });
     }
@@ -168,9 +180,10 @@ class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
+            remult._changeListener = this.liveQueryManager;
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+                remultObjectStorage.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)

package/esm/src/column.d.ts

@@ -1,7 +1,7 @@
 import { ClassType } from '../classType';
 import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
 import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, Repository, RepositoryImplementation } from './remult3';
+import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
 export declare function makeTitle(name: string): string;
 export declare class CompoundIdField implements FieldMetadata<string> {
     fields: FieldMetadata[];
@@ -25,12 +25,12 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 }
 export declare class LookupColumn<T> {
     private repository;
-    id: string;
+    id: idType<T>;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: string);
+    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/context.d.ts

@@ -2,6 +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";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
@@ -65,6 +66,7 @@ export declare class Remult {
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** The current data provider */
     dataProvider: DataProvider;
+    liveQueryProvider: 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;

package/esm/src/context.js

@@ -1,6 +1,9 @@
 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 { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
+import { RemultProxy } from "./remult-proxy";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
     constructor(http) {
         this.http = http;
@@ -95,8 +98,14 @@ export class Remult {
     constructor(provider) {
         /* @internal */
         this.repCache = new Map();
+        /*@internal*/
+        this._changeListener = {
+            saved: (ref) => { },
+            deleted: (ref) => { }
+        };
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
+        this.liveQueryProvider = new LiveQueryClient(new EventSourceLiveQueryProvider());
         this.context = {};
         this.apiClient = {
             url: '/api'
@@ -187,6 +196,7 @@ export class Remult {
         else
             return this.isAllowed(allowed);
     }
+    //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
     call(backendMethod, classInstance, ...args) {
         const z = (backendMethod[serverActionField]);
         if (!z.doWork)
@@ -200,6 +210,7 @@ export class Remult {
 }
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
+RemultProxy.defaultRemult = new Remult();
 ;
 export const allEntities = [];
 export const classHelpers = new Map();

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

@@ -1,10 +1,14 @@
 import { Remult } from './context';
-import { Repository } from './remult3';
+import { FindOptions, 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;
-    constructor(repository: Repository<T>, remult: Remult);
+    private liveQueryProvider?;
+    constructor(repository: Repository<T>, remult: Remult, liveQueryProvider?: LiveQueryProvider);
     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,9 +1,10 @@
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
 import { Filter } from './filter/filter-interfaces';
 export class DataApi {
-    constructor(repository, remult) {
+    constructor(repository, remult, liveQueryProvider) {
         this.repository = repository;
         this.remult = remult;
+        this.liveQueryProvider = liveQueryProvider;
     }
     httpGet(res, req) {
         if (req.get("__action") == "count") {
@@ -13,7 +14,10 @@ export class DataApi {
             return this.getArray(res, req);
     }
     httpPost(res, req, body) {
-        switch (req.get("__action")) {
+        const action = req?.get("__action");
+        if (action?.startsWith("subscribe"))
+            return this.getArray(res, req, body);
+        switch (action) {
             case "get":
                 return this.getArray(res, req, body);
             case "count":
@@ -89,10 +93,19 @@ export class DataApi {
                 findOptions.limit = limit;
                 findOptions.page = +request.get("_page");
             }
-            await this.repository.find(findOptions)
+            const action = request?.get("__action");
+            const r = await this.repository.find(findOptions)
                 .then(async (r) => {
-                response.success(await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson())));
+                return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
             });
+            if (this.liveQueryProvider && action?.startsWith("subscribe")) {
+                response.success({
+                    id: this.liveQueryProvider.subscribe(this.repository, action.split('|')[1], findOptions, this.remult, r.map(y => this.repository.getEntityRef(y).getId())),
+                    result: r
+                });
+                return;
+            }
+            response.success(r);
         }
         catch (err) {
             response.error(err);

package/esm/src/data-providers/array-entity-data-provider.js

@@ -66,22 +66,7 @@ export class ArrayEntityDataProvider {
             }
             if (options.orderBy) {
                 rows = rows.sort((a, b) => {
-                    let r = 0;
-                    for (let i = 0; i < options.orderBy.Segments.length; i++) {
-                        let seg = options.orderBy.Segments[i];
-                        let left = a[seg.field.key];
-                        let right = b[seg.field.key];
-                        if (left > right)
-                            r = 1;
-                        else if (left < right)
-                            r = -1;
-                        if (r != 0) {
-                            if (seg.isDescending)
-                                r *= -1;
-                            return r;
-                        }
-                    }
-                    return r;
+                    return options.orderBy.compare(a, b);
                 });
             }
             rows = pageArray(rows, options);

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -19,6 +19,10 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;
     find(options: EntityDataProviderFindOptions): Promise<Array<any>>;
+    buildFindRequest(options: EntityDataProviderFindOptions): {
+        filterObject: any;
+        url: UrlBuilder;
+    };
     update(id: any, data: any): Promise<any>;
     delete(id: any): Promise<void>;
     insert(data: any): Promise<any>;

package/esm/src/data-providers/rest-data-provider.js

@@ -55,6 +55,16 @@ export class RestEntityDataProvider {
             return this.http().get(url.url).then(r => +(r.count));
     }
     find(options) {
+        let { filterObject, url } = this.buildFindRequest(options);
+        if (filterObject) {
+            url.add("__action", "get");
+            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
+        }
+        else
+            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
+        ;
+    }
+    buildFindRequest(options) {
         let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
@@ -82,13 +92,7 @@ export class RestEntityDataProvider {
             if (options.page)
                 url.add('_page', options.page);
         }
-        if (filterObject) {
-            url.add("__action", "get");
-            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
-        }
-        else
-            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
-        ;
+        return { filterObject, url };
     }
     update(id, data) {
         let result = {};

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

@@ -0,0 +1,5 @@
+import { LiveQueryClient } from './LiveQuery';
+export declare class EventSourceLiveQuery extends LiveQueryClient {
+    private wrapMessage?;
+    constructor(wrapMessage?: (what: () => void) => void);
+}