remult 0.18.1-exp.2 → 0.18.1-exp.21

package/esm/server/expressBridge.js

@@ -5,8 +5,10 @@ import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
+import { LiveQueryPublisher, InMemoryLiveQueryStorage } from '../src/live-query/SubscriptionServer';
+import { liveQueryKeepAliveRoute } from '../src/live-query/SubscriptionChannel';
 ;
-export function createRemultServer(options) {
+export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }
@@ -30,30 +32,12 @@ 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;
-        });
-    }
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -95,10 +79,22 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-class RemultAsyncLocalStorage {
+export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    static enable() {
+        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");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -107,21 +103,27 @@ class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw "can't use static remult in this environment, `async_hooks` were not found";
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     }
 }
-let remultObjectStorage;
+RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
+/* @internal*/
 export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.liveQueryStorage = new InMemoryLiveQueryStorage();
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
+        if (options.liveQueryStorage)
+            this.liveQueryStorage = options.liveQueryStorage;
+        if (options.subscriptionServer)
+            this.subscriptionServer = options.subscriptionServer;
     }
     withRemult(req, res, next) {
         this.process(async () => { next(); })(req, res);
@@ -167,6 +169,14 @@ export class RemultServerImplementation {
                     },
                     doWork: undefined
                 }, r);
+            this.addAction({
+                __register: x => {
+                    x(liveQueryKeepAliveRoute, false, () => true, async (data, req, res) => {
+                        res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(data));
+                    });
+                },
+                doWork: undefined
+            }, r);
         }
         this.options.entities.forEach(e => {
             let key = getEntityKey(e);
@@ -197,10 +207,12 @@ export class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.liveQueryPublisher = this.liveQueryManager;
+            remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithRequest);
             remult.dataProvider = (await this.dataProvider);
+            remult.subscriptionServer = this.subscriptionServer;
+            remult.liveQueryStorage = this.liveQueryStorage;
             await new Promise(res => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)
@@ -214,7 +226,15 @@ export class RemultServerImplementation {
                             remult.user = (user);
                     }
                     if (this.options.initRequest) {
-                        await this.options.initRequest(remult, req);
+                        await this.options.initRequest(req, {
+                            remult,
+                            get liveQueryStorage() {
+                                return remult.liveQueryStorage;
+                            },
+                            set liveQueryStorage(value) {
+                                remult.liveQueryStorage = value;
+                            }
+                        });
                     }
                     await what(remult, myReq, myRes, req);
                     res({});
@@ -242,7 +262,9 @@ export class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.info("[remult] " + myUrl);
+                //TODO - should I hide this route in the list of routes
+                if (url !== liveQueryKeepAliveRoute)
+                    console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);
@@ -606,7 +628,11 @@ class inProcessQueueHandler {
         this.actions.get(url)(body, req, {
             error: error => job.setErrorResult(serializeError(error)),
             success: result => job.setResult(result),
-            progress: progress => job.setProgress(progress)
+            progress: progress => job.setProgress(progress),
+            created: () => { throw Error("Created response not expected for queue"); },
+            deleted: () => { throw Error("deleted response not expected for queue"); },
+            notFound: () => { throw Error("notFound response not expected for queue"); },
+            forbidden: () => job.setErrorResult("Forbidden")
         });
         return id;
     }

package/esm/server/index.d.ts

@@ -1,2 +1,4 @@
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,2 +1,7 @@
-export { createRemultServer } from './expressBridge';
+import { createRemultServerCore, } from './expressBridge';
+import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export function createRemultServer(options) {
+    initAsyncHooks();
+    return createRemultServerCore(options);
+}

package/esm/src/column-interfaces.d.ts

@@ -2,7 +2,10 @@ import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
-    /**A human readable name for the field */
+    /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
+    * @example
+    * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+    */
     caption?: string;
     /** If it can store null in the database */
     allowNull?: boolean;
@@ -32,14 +35,23 @@ export interface FieldOptions<entityType = any, valueType = any> {
      *   }
      * })
      */
-    validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
     /** Will be fired before this field is saved to the server/database */
-    saving?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>));
+    saving?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>));
     /**  An expression that will determine this fields value on the backend and be provided to the front end*/
     serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
     /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
     dbName?: string;
-    /** Used or fields that are based on an sql expressions, instead of a physical table column */
+    /** Used or fields that are based on an sql expressions, instead of a physical table column
+     * @example
+     *
+     * @Fields.integer({
+     *   sqlExpression:e=> 'length(title)'
+     * })
+     * titleLength = 0;
+     * @Fields.string()
+     * title='';
+    */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
@@ -62,18 +74,42 @@ export interface FieldOptions<entityType = any, valueType = any> {
     /** The key to be used for this field */
     key?: string;
 }
+/**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
 export interface FieldMetadata<valueType = any> {
+    /** The field's member name in an object.
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * console.log(taskRepo.metadata.fields.title.key);
+     * // result: title
+     */
     readonly key: string;
-    readonly target: ClassType<valueType>;
-    readonly valueType: any;
+    /** A human readable caption for the field. Can be used to achieve a consistent caption for a field throughout the app
+     * @example
+     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+     */
     readonly caption: string;
+    /** The field's value type (number,string etc...) */
+    readonly valueType: any;
+    /** The options sent to this field's decorator */
+    readonly options: FieldOptions;
+    /** The `inputType` relevant for this field, determined by the options sent to it's decorator and the valueConverter in these options */
     readonly inputType: string;
+    /** if null is allowed for this field */
     readonly allowNull: boolean;
+    /** The class that contains this field
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * Task == taskRepo.metadata.fields.title.target //will return true
+    */
+    readonly target: ClassType<valueType>;
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
+    /** Indicates if this field is based on a server express */
     readonly isServerExpression: boolean;
+    /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
     readonly dbReadOnly: boolean;
+    /** the Value converter for this field */
     readonly valueConverter: ValueConverter<valueType>;
-    readonly options: FieldOptions;
 }
 export interface ValueConverter<valueType> {
     fromJson?(val: any): valueType;
@@ -86,7 +122,7 @@ export interface ValueConverter<valueType> {
     readonly fieldTypeInDb?: string;
     readonly inputType?: string;
 }
-export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, col: FieldRef<entityType, valueType>) => void | Promise<void>;
+export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => void | Promise<void>;
 export declare type ValueOrExpression<valueType> = valueType | (() => valueType);
 export declare function valueOrExpressionToValue<valueType>(f: ValueOrExpression<valueType>): valueType;
 export interface ValueListItem {

package/esm/src/context.d.ts

@@ -1,19 +1,20 @@
 import { DataProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQueryClient";
-import type { ServerEventDispatcher } from "../live-query";
-import { LiveQueryStorage } from "./live-query/LiveQueryPublisher";
+import type { SubscriptionServer } from "./live-query/SubscriptionServer";
 import { ExternalHttpProvider } from "./buildRestDataProvider";
+import { SubscriptionClient } from "./live-query/SubscriptionChannel";
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
      * @example
      * const taskRepo = remult.repo(Task);
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     *
+     * @param entity - the entity to use
+     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
     repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Returns the current user's info */
     user?: UserInfo;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
@@ -29,6 +30,8 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
+    /** The current data provider */
+    dataProvider: DataProvider;
     /** Creates a new instance of the `remult` object.
      *
      * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
@@ -38,25 +41,42 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
-    liveQueryPublisher: LiveQueryPublisherInterface;
+    subscriptionServer?: SubscriptionServer;
+    /** Used to call a `backendMethod` using a specific `remult` object
+     * @example
+     * await remult.call(TasksController.setAll, undefined, true);
+     * @param backendMethod - the backend method to call
+     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
+     * @param args - the arguments to send to the backend method
+    */
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
-    /** The current data provider */
-    dataProvider: DataProvider;
-    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;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
+    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
     readonly context: RemultContext;
+    /** The api client that will be used by `remult` to perform calls to the `api` */
     apiClient: ApiClient;
 }
 export declare type GetArguments<T> = T extends (...args: infer FirstArgument) => any ? FirstArgument : never;
 export interface RemultContext {
 }
 export interface ApiClient {
+    /** The http client to use when making api calls.
+     * @example
+     * remult.apiClient.httpClient = axios;
+     * @example
+     * remult.apiClient.httpClient = httpClient;//angular http client
+     * @example
+     * remult.apiClient.httpClient = fetch; //this is the default
+     */
     httpClient?: ExternalHttpProvider | typeof fetch;
+    /** The base url to for making api calls */
     url?: string;
+    subscriptionClient?: SubscriptionClient;
+    wrapMessageHandling?: (x: VoidFunction) => void;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
@@ -72,11 +92,11 @@ export interface UserInfo {
     name?: string;
     roles?: string[];
 }
-export declare type Allowed = boolean | string | string[] | ((c: Remult) => boolean);
-export declare type AllowedForInstance<T> = boolean | string | string[] | ((c: Remult, entity?: T) => boolean);
+export declare type Allowed = boolean | string | string[] | ((c?: Remult) => boolean);
+export declare type AllowedForInstance<T> = boolean | string | string[] | ((entity?: T, c?: Remult) => boolean);
 export declare class Allow {
     static everyone: () => boolean;
-    static authenticated: (remult: Remult) => boolean;
+    static authenticated: (...args: any[]) => any;
 }
 export declare const queryConfig: {
     defaultPageSize: number;
@@ -90,14 +110,6 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
-export interface LiveQueryPublisherInterface {
-    stopLiveQuery(id: any): void;
-    sendChannelMessage<messageType>(channel: string, message: messageType): void;
-    defineLiveQueryChannel(serializeRequest: () => any, entityKey: string, options: FindOptions<any>, ids: any[], userId: string, repo: Repository<any>): string;
-    itemChanged(entityKey: string, changes: itemChange[]): void;
-    dispatcher: ServerEventDispatcher;
-    storage: LiveQueryStorage;
-}
 export interface itemChange {
     id: any;
     oldId: any;

package/esm/src/context.js

@@ -2,7 +2,7 @@ import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 import { LiveQueryClient } from "./live-query/LiveQueryClient";
-import { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
+import { SseSubscriptionClient } from "./live-query/SseSubscriptionClient";
 import { RemultProxy } from "./remult-proxy";
 import { buildRestDataProvider, isExternalHttpProvider } from "./buildRestDataProvider";
 export function isBackend() {
@@ -10,26 +10,22 @@ export function isBackend() {
 }
 export class Remult {
     constructor(provider) {
+        /** The current data provider */
+        this.dataProvider = new RestDataProvider(() => this.apiClient);
         /* @internal */
         this.repCache = new Map();
+        /* @internal*/
         this.liveQueryPublisher = {
-            itemChanged: () => { },
-            defineLiveQueryChannel: () => "",
-            dispatcher: undefined,
-            sendChannelMessage: function (arg0, what) {
-                throw new Error("invalid publisher.");
-            },
-            stopLiveQuery: function (id) {
-                throw new Error("Function not implemented.");
-            },
-            storage: undefined
+            itemChanged: () => { }
         };
-        /** The current data provider */
-        this.dataProvider = new RestDataProvider(() => this.apiClient);
-        this.liveQuerySubscriber = new LiveQueryClient(new EventSourceLiveQueryProvider());
+        /* @internal*/
+        this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient);
+        /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
         this.context = {};
+        /** The api client that will be used by `remult` to perform calls to the `api` */
         this.apiClient = {
-            url: '/api'
+            url: '/api',
+            subscriptionClient: new SseSubscriptionClient()
         };
         if (provider && provider.getEntityDataProvider) {
             this.dataProvider = provider;
@@ -46,13 +42,18 @@ export class Remult {
                 this.apiClient.httpClient = apiClient.httpClient;
             if (apiClient.url)
                 this.apiClient.url = apiClient.url;
+            if (apiClient.subscriptionClient)
+                this.apiClient.subscriptionClient = apiClient.subscriptionClient;
+            if (apiClient.wrapMessageHandling)
+                this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
         }
     }
     /**Return's a `Repository` of the specific entity type
      * @example
      * const taskRepo = remult.repo(Task);
      * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     *
+     * @param entity - the entity to use
+     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
      */
     repo(entity, dataProvider) {
         if (dataProvider === undefined)
@@ -66,7 +67,6 @@ export class Remult {
         }
         return r;
     }
-    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
         return this.user?.id !== undefined;
@@ -112,12 +112,19 @@ export class Remult {
             }
         }
         else if (typeof (allowed) === "function") {
-            return allowed(this, instance);
+            return allowed(instance, this);
         }
         else
             return this.isAllowed(allowed);
     }
     //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
+    /** Used to call a `backendMethod` using a specific `remult` object
+     * @example
+     * await remult.call(TasksController.setAll, undefined, true);
+     * @param backendMethod - the backend method to call
+     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
+     * @param args - the arguments to send to the backend method
+    */
     call(backendMethod, classInstance, ...args) {
         const z = (backendMethod[serverActionField]);
         if (!z.doWork)
@@ -156,7 +163,16 @@ export function setControllerSettings(target, options) {
 export class Allow {
 }
 Allow.everyone = () => true;
-Allow.authenticated = (remult) => remult.authenticated();
+Allow.authenticated = (...args) => {
+    if (args.length > 1) {
+        return args[1].authenticated();
+    }
+    else if (args.length == 1) {
+        if (args[0].authenticated)
+            return args[0].authenticated();
+    }
+    return RemultProxy.defaultRemult.authenticated();
+};
 export const queryConfig = {
     defaultPageSize: 200
 };
@@ -188,22 +204,11 @@ export async function doTransaction(remult, what) {
         trans.flush();
     });
 }
-// TODO - talk about message size limit in ably - something that we may reach if we group the messages
 class transactionLiveQueryPublisher {
     constructor(orig) {
         this.orig = orig;
         this.transactionItems = new Map();
     }
-    get storage() {
-        return this.orig.storage;
-    }
-    ;
-    set storage(value) {
-        this.orig.storage = value;
-    }
-    stopLiveQuery(id) {
-        this.orig.stopLiveQuery(id);
-    }
     itemChanged(entityKey, changes) {
         let items = this.transactionItems.get(entityKey);
         if (!items) {
@@ -230,16 +235,4 @@ class transactionLiveQueryPublisher {
             this.orig.itemChanged(key, this.transactionItems.get(key));
         }
     }
-    sendChannelMessage(channel, message) {
-        this.orig.sendChannelMessage(channel, message);
-    }
-    defineLiveQueryChannel(serializeRequest, entityKey, options, ids, userId, repo) {
-        return this.orig.defineLiveQueryChannel(serializeRequest, entityKey, options, ids, userId, repo);
-    }
-    get dispatcher() {
-        return this.orig.dispatcher;
-    }
-    set dispatcher(value) {
-        this.orig.dispatcher = value;
-    }
 }

package/esm/src/data-api.js

@@ -1,8 +1,10 @@
+import { v4 as uuid } from 'uuid';
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
 import { doTransaction } from './context';
 import { Filter } from './filter/filter-interfaces';
 import { ForbiddenError } from './server-action';
 import { getId } from './remult3/getId';
+import { findOptionsToJson } from './data-providers/rest-data-provider';
 export class DataApi {
     constructor(repository, remult) {
         this.repository = repository;
@@ -29,7 +31,7 @@ export class DataApi {
             case "count":
                 return this.count(res, req, body);
             case "endLiveQuery":
-                this.remult.liveQueryPublisher.stopLiveQuery(body.id);
+                this.remult.liveQueryStorage.remove(body.id);
                 res.success("ok");
                 return;
             default:
@@ -127,8 +129,19 @@ export class DataApi {
         }
         try {
             const r = await this.getArrayImpl(response, request, filterBody);
+            const queryChannel = `users:${this.remult.user?.id}:queries:${uuid()}`;
+            const data = {
+                requestJson: serializeRequest(),
+                findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
+                lastIds: r.r.map(y => getId(this.repository.metadata, y))
+            };
+            this.remult.liveQueryStorage.add({
+                entityKey: this.repository.metadata.key,
+                id: queryChannel,
+                data
+            });
             response.success({
-                queryChannel: this.remult.liveQueryPublisher.defineLiveQueryChannel(serializeRequest, this.repository.metadata.key, r.findOptions, r.r.map(y => getId(this.repository.metadata, y)), this.remult.user?.id, this.repository),
+                queryChannel,
                 result: r.r
             });
         }
@@ -187,8 +200,8 @@ export class DataApi {
                 response.forbidden();
                 return;
             }
-            await this.repository.getEntityRef(row).save();
-            response.success(this.repository.getEntityRef(row).toApiJson());
+            await ref.save();
+            response.success(ref.toApiJson());
         });
     }
     async delete(response, id) {

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

@@ -4,7 +4,7 @@ import { EntityMetadata, OmitEB } from './remult3';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter?: boolean;
+    supportsrawFilter?: boolean;
 }
 export interface EntityDataProvider {
     count(where: Filter): Promise<number>;

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -4,7 +4,7 @@ import { EntityMetadata, EntityFilter } from '../remult3';
 export declare class ArrayEntityDataProvider implements EntityDataProvider {
     private entity;
     private rows?;
-    static customFilter(filter: CustomArrayFilter): EntityFilter<any>;
+    static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
     constructor(entity: EntityMetadata, rows?: any[]);
     private verifyThatRowHasAllNotNullColumns;
     count(where?: Filter): Promise<number>;

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

@@ -12,7 +12,7 @@ export class ArrayEntityDataProvider {
             }
         }
     }
-    static customFilter(filter) {
+    static rawFilter(filter) {
         return {
             [customDatabaseFilterToken]: {
                 arrayFilter: filter

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

@@ -1,22 +1,15 @@
 import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
 import { UrlBuilder } from '../../urlBuilder';
 import { Filter } from '../filter/filter-interfaces';
-import { EntityMetadata, FindOptions } from '../remult3';
+import { EntityMetadata } from '../remult3';
 import { ApiClient } from '../context';
 export declare class RestDataProvider implements DataProvider {
     private apiProvider;
     constructor(apiProvider: () => ApiClient);
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter: boolean;
+    supportsrawFilter: boolean;
 }
-export declare function findOptionsToJson(options: FindOptions<any>, meta: EntityMetadata): {
-    limit: number;
-    page: number;
-    where: any;
-    orderBy: import("../remult3").EntityOrderBy<any>;
-};
-export declare function findOptionsFromJson(json: any, meta: EntityMetadata): FindOptions<any>;
 export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;
     private http;
@@ -25,11 +18,7 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     translateFromJson(row: any): {};
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;
-    find(options: EntityDataProviderFindOptions): Promise<Array<any>>;
-    buildFindRequest(options: EntityDataProviderFindOptions): {
-        filterObject: any;
-        url: UrlBuilder;
-    };
+    find(options?: EntityDataProviderFindOptions): Promise<Array<any>>;
     update(id: any, data: any): Promise<any>;
     delete(id: any): Promise<void>;
     insert(data: any): Promise<any>;