remult 0.16.5 → 0.17.0-exp.2

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/LiveQuery.js

@@ -1,13 +1,14 @@
-import { getEntityRef, remult as defaultRemult, Sort } from '../../index';
+import { remult as defaultRemult, Sort } from '../../index';
 import { v4 as uuid } from 'uuid';
 import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
 import { buildRestDataProvider } from '../context';
+import { getId } from '../remult3/getId';
 export const streamUrl = 'stream1';
 class LiveQueryOnFrontEnd {
     constructor(repo, query) {
         this.repo = repo;
         this.query = query;
-        this.items = [];
+        this.defaultQueryState = [];
         this.listeners = [];
     }
     async setAllItems(result) {
@@ -19,6 +20,7 @@ class LiveQueryOnFrontEnd {
         });
     }
     forListeners(what) {
+        //   what(x => this.defaultQueryState = x(this.defaultQueryState));
         for (const l of this.listeners) {
             what(l);
         }
@@ -41,7 +43,7 @@ class LiveQueryOnFrontEnd {
                     listener(items => {
                         if (!items)
                             items = [];
-                        return sort(items.map(x => this.repo.getEntityRef(x).getId() === message.data.oldId ? item : x));
+                        return sort(items.map(x => getId(this.repo.metadata, x) === message.data.oldId ? item : x));
                     });
                 });
                 break;
@@ -61,7 +63,7 @@ class LiveQueryOnFrontEnd {
                 this.forListeners(listener => listener(items => {
                     if (!items)
                         items = [];
-                    return this.items.filter(x => getEntityRef(x).getId() !== message.data.id);
+                    return items.filter(x => getId(this.repo.metadata, x) !== message.data.id);
                 }));
                 break;
         }
@@ -152,7 +154,7 @@ export class LiveQueryClient {
                     this.runPromise(this.provider.get(url.url).then(thenResult));
             }
             else {
-                onResult(x => q.items);
+                onResult(x => [...q.defaultQueryState]);
             }
             q.listeners.push(onResult);
             onUnsubscribe = () => {

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

@@ -2,12 +2,11 @@ import { Remult } from '../..';
 import { Repository, EntityRef, FindOptions } from '../remult3';
 import { LiveQueryProvider } from '../data-api';
 import { liveQueryMessage } from './LiveQuery';
-export declare class LiveQueryManager implements LiveQueryProvider {
+export declare class LiveQueryPublisher implements LiveQueryProvider {
     private dispatcher;
     constructor(dispatcher: ServerEventDispatcher);
     subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
     clients: clientInfo[];
-    sendMessage(key: string, message: liveQueryMessage): void;
     hasListeners(ref: EntityRef<any>): boolean;
     runPromise(p: Promise<any>): void;
     saved(ref: EntityRef<any>): void;

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

@@ -1,5 +1,5 @@
 import { v4 as uuid } from 'uuid';
-export class LiveQueryManager {
+export class LiveQueryPublisher {
     constructor(dispatcher) {
         this.dispatcher = dispatcher;
         this.clients = [];
@@ -19,15 +19,6 @@ export class LiveQueryManager {
         });
         return id;
     }
-    sendMessage(key, message) {
-        for (const c of this.clients) {
-            for (const q of c.queries) {
-                if (q.repo.metadata.key === key) {
-                    this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
-                }
-            }
-        }
-    }
     hasListeners(ref) {
         for (const c of this.clients) {
             for (const q of c.queries) {
@@ -87,11 +78,22 @@ export class LiveQueryManager {
         }
     }
     deleted(ref) {
-        if (!this.hasListeners(ref))
-            return;
-        this.sendMessage(ref.metadata.key, {
-            type: "remove",
-            data: { id: ref.getId() }
-        });
+        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
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        }
     }
 }

package/esm/src/remult-proxy.d.ts

@@ -1,2 +1,2 @@
-import { Remult } from "./context";
+import type { Remult } from "./context";
 export declare const remult: Remult;

package/esm/src/remult-proxy.js

@@ -1,13 +1,20 @@
-import { Remult } from "./context";
-import { RepositoryImplementation } from "./remult3";
-let defaultRemult = new Remult();
 /*@internal*/
 export class RemultProxy {
     constructor() {
         /*@internal*/
-        this.remultFactory = () => defaultRemult;
+        this.remultFactory = () => RemultProxy.defaultRemult;
         this.repo = (...args) => this.remultFactory().repo(...args);
     }
+    get liveQueryProvider() { return this.remultFactory().liveQueryProvider; }
+    ;
+    set liveQueryProvider(val) { this.remultFactory().liveQueryProvider = val; }
+    ;
+    get _changeListener() {
+        return this.remultFactory()._changeListener;
+    }
+    set _changeListener(val) {
+        this.remultFactory()._changeListener = val;
+    }
     call(backendMethod, self, ...args) {
         return this.remultFactory().call(backendMethod, self, ...args);
     }
@@ -31,10 +38,6 @@ export class RemultProxy {
     clearAllCache() {
         return this.remultFactory().clearAllCache();
     }
-    /*@internal*/
-    resetFactory() {
-        this.remultFactory = () => defaultRemult;
-    }
     get user() {
         return this.remultFactory().user;
     }
@@ -49,4 +52,3 @@ export class RemultProxy {
     }
 }
 export const remult = new RemultProxy();
-RepositoryImplementation.defaultRemult = remult;

package/esm/src/remult3/RepositoryImplementation.d.ts

@@ -5,13 +5,12 @@ import { EntityMetadata, FieldRef, FieldsRef, EntityFilter, FindOptions, Reposit
 import { ClassType } from "../../classType";
 import { Remult, Unobserve } from "../context";
 import { entityEventListener } from "../__EntityValueProvider";
-import { DataProvider, EntityDataProvider } from "../data-interfaces";
+import { DataProvider, EntityDataProvider, EntityDataProviderFindOptions } from "../data-interfaces";
 import { RefSubscriber } from ".";
 export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
     private entity;
-    private remult;
+    remult: Remult;
     private dataProvider;
-    static defaultRemult: Remult;
     createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
     private _info;
     private __edp;
@@ -43,6 +42,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
     find(options: FindOptions<entityType>): Promise<entityType[]>;
+    buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
     private mapRawDataToResult;
     count(where?: EntityFilter<entityType>): Promise<number>;
     private cache;
@@ -89,6 +89,7 @@ declare abstract class rowHelperBase<T> {
     copyDataToObject(): any;
     originalValues: any;
     saveOriginalData(): void;
+    saveMoreOriginalData(): void;
     validate(): Promise<boolean>;
     __validateEntity(): Promise<void>;
     __performColumnAndEntityValidations(): Promise<void>;
@@ -106,6 +107,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     get apiInsertAllowed(): boolean;
     metadata: EntityMetadata<T>;
     getId(): any;
+    saveMoreOriginalData(): void;
     private _wasDeleted;
     wasDeleted(): boolean;
     undoChanges(): void;
@@ -118,6 +120,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     delete(): Promise<void>;
     loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;
     id: any;
+    originalId: any;
     getOriginalId(): any;
     private calcServerExpression;
     isNew(): boolean;

package/esm/src/remult3/RepositoryImplementation.js

@@ -6,6 +6,8 @@ import { v4 as uuid } from 'uuid';
 import { ValueConverters } from "../valueConverters";
 import { filterHelper } from "../filter/filter-interfaces";
 import { assign } from "../../assign";
+import { remult as defaultRemult } from "../remult-proxy";
+import { getId } from "./getId";
 //import { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import("class-validator".toString())
@@ -165,8 +167,10 @@ export class RepositoryImplementation {
                 instance[field.key] = entity[field.key];
             }
             let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
-            if (id)
+            if (id) {
                 row.id = id;
+                row.originalId = id;
+            }
             else
                 row.id = row.getId();
             ref = row;
@@ -197,17 +201,9 @@ export class RepositoryImplementation {
     }
     async find(options) {
         Remult.onFind(this._info, options);
-        let opt = {};
         if (!options)
             options = {};
-        opt = {};
-        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
-            options.orderBy = this._info.entityInfo.defaultOrderBy;
-        }
-        opt.where = await this.translateWhereToFilter(options.where);
-        opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
-        opt.limit = options.limit;
-        opt.page = options.page;
+        let opt = await this.buildEntityDataProviderFindOptions(options);
         let rawRows = await this.edp.find(opt);
         let loadFields = undefined;
         if (options.load)
@@ -242,6 +238,18 @@ export class RepositoryImplementation {
             }
         }
     }
+    async buildEntityDataProviderFindOptions(options) {
+        let opt = {};
+        opt = {};
+        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
+            options.orderBy = this._info.entityInfo.defaultOrderBy;
+        }
+        opt.where = await this.translateWhereToFilter(options.where);
+        opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
+        opt.limit = options.limit;
+        opt.page = options.page;
+        return opt;
+    }
     async mapRawDataToResult(r, loadFields) {
         if (!r)
             return undefined;
@@ -622,6 +630,9 @@ class rowHelperBase {
     }
     saveOriginalData() {
         this.originalValues = this.copyDataToObject();
+        this.saveMoreOriginalData();
+    }
+    saveMoreOriginalData() {
     }
     async validate() {
         this.__clearErrorsAndReportChanged();
@@ -711,10 +722,10 @@ export class rowHelperImplementation extends rowHelperBase {
     get apiDeleteAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiDelete); }
     get apiInsertAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiInsert); }
     getId() {
-        if (this.info.idMetadata.field instanceof CompoundIdField)
-            return this.info.idMetadata.field.getId(this.instance);
-        else
-            return this.instance[this.info.idMetadata.field.key];
+        return getId(this.info, this.instance);
+    }
+    saveMoreOriginalData() {
+        this.originalId = this.getId();
     }
     wasDeleted() {
         this._subscribers?.reportObserved();
@@ -805,6 +816,7 @@ export class rowHelperImplementation extends rowHelperBase {
                     }
                 }
                 await this.loadDataFrom(updatedRow);
+                this.repository.remult._changeListener.saved(this);
                 if (this.info.entityInfo.saved)
                     await this.info.entityInfo.saved(this.instance);
                 this.saveOriginalData();
@@ -831,6 +843,7 @@ export class rowHelperImplementation extends rowHelperBase {
         this.__assertValidity();
         try {
             await this.edp.delete(this.id);
+            this.repository.remult._changeListener.deleted(this);
             if (this.info.entityInfo.deleted)
                 await this.info.entityInfo.deleted(this.instance);
             if (this.repository.listeners)
@@ -861,14 +874,10 @@ export class rowHelperImplementation extends rowHelperBase {
                 this.instance[col.key] = data[col.key];
         }
         await this.calcServerExpression();
-        if (this.repository.metadata.idMetadata.field instanceof CompoundIdField) {
-            this.id = this.repository.metadata.idMetadata.field.getId(this.instance);
-        }
-        else
-            this.id = data[this.repository.metadata.idMetadata.field.key];
+        this.id = getId(this.info, this.instance);
     }
     getOriginalId() {
-        return this.id;
+        return this.originalId;
     }
     async calcServerExpression() {
         if (isBackend())
@@ -913,7 +922,7 @@ export function getFields(container, remult) {
     return getControllerRef(container, remult).fields;
 }
 export function getControllerRef(container, remultArg) {
-    const remultVar = remultArg || RepositoryImplementation.defaultRemult;
+    const remultVar = remultArg || defaultRemult;
     let result = container[controllerColumns];
     if (!result)
         result = container[entityMember];
@@ -1658,7 +1667,7 @@ export class EntityBase {
 }
 export class ControllerBase {
     constructor(remult) {
-        this.remult = remult || RepositoryImplementation.defaultRemult;
+        this.remult = remult || defaultRemult;
     }
     assign(values) {
         assign(this, values);
@@ -1678,6 +1687,14 @@ class QueryResultImpl {
             this.options.pageSize = queryConfig.defaultPageSize;
         }
     }
+    subscribe(onResult) {
+        return this.repo.remult.liveQueryProvider.subscribe(this.repo, {
+            limit: this.options.pageSize,
+            load: this.options.load,
+            orderBy: this.options.orderBy,
+            where: this.options.where
+        }, onResult);
+    }
     async getPage(page) {
         if (page < 1)
             page = 1;

package/esm/src/remult3/getId.d.ts

@@ -0,0 +1,2 @@
+import type { EntityMetadata } from "./remult3";
+export declare function getId<entityType>(meta: EntityMetadata<entityType>, instance: entityType): any;

package/esm/src/remult3/getId.js

@@ -0,0 +1,7 @@
+import { CompoundIdField } from '../column';
+export function getId(meta, instance) {
+    if (meta.idMetadata.field instanceof CompoundIdField)
+        return meta.idMetadata.field.getId(instance);
+    else
+        return instance[meta.idMetadata.field.key];
+}

package/esm/src/remult3/remult3.d.ts

@@ -15,7 +15,8 @@ export interface EntityRef<entityType> extends Subscribable {
     wasDeleted(): boolean;
     fields: FieldsRef<entityType>;
     error: string;
-    getId(): any;
+    getId(): idType<entityType>;
+    getOriginalId(): idType<entityType>;
     repository: Repository<entityType>;
     metadata: EntityMetadata<entityType>;
     toApiJson(): any;
@@ -108,6 +109,11 @@ export interface EntityMetadata<entityType = any> {
     getDbName(): Promise<string>;
 }
 export declare type OmitEB<T> = Omit<T, keyof import('./RepositoryImplementation').EntityBase>;
+export declare type idType<entityType> = entityType extends {
+    id?: number;
+} ? number : entityType extends {
+    id?: string;
+} ? string : (string | number);
 /**used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
@@ -120,11 +126,7 @@ export interface Repository<entityType> {
      *      */
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>): Promise<entityType>;
     /** returns the items that matches the idm the result is cached unless specified differently in the `options` parameter */
-    findId(id: entityType extends {
-        id?: number;
-    } ? number : entityType extends {
-        id?: string;
-    } ? string : (string | number), options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
+    findId(id: idType<entityType>, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
     /**  An alternative form of fetching data from the API server, which is intended for operating on large numbers of entity objects.
      *
      * It also has it's own paging mechanism that can be used n paging scenarios.
@@ -298,6 +300,8 @@ export interface QueryResult<entityType> {
     getPage(pageNumber?: number): Promise<entityType[]>;
     /** Performs an operation on all the items matching the query criteria */
     forEach(what: (item: entityType) => Promise<any>): Promise<number>;
+    /**@Experimental */
+    subscribe(onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): VoidFunction;
 }
 /** An interface used to paginating using the `query` method in the `Repository` object */
 export interface Paginator<entityType> {

package/esm/src/server-action.js

@@ -1,7 +1,8 @@
 import 'reflect-metadata';
 import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, buildRestDataProvider } from './context';
 import { SqlDatabase } from './data-providers/sql-database';
-import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef, RepositoryImplementation } from './remult3';
+import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef } from './remult3';
+import { remult } from './remult-proxy';
 export class Action {
     constructor(actionUrl, queue, allowed) {
         this.actionUrl = actionUrl;
@@ -10,9 +11,9 @@ export class Action {
     }
     async run(pIn, baseUrl, http) {
         if (baseUrl === undefined)
-            baseUrl = RepositoryImplementation.defaultRemult.apiClient.url;
+            baseUrl = remult.apiClient.url;
         if (!http)
-            http = buildRestDataProvider(RepositoryImplementation.defaultRemult.apiClient.httpClient);
+            http = buildRestDataProvider(remult.apiClient.httpClient);
         let r = await http.post(baseUrl + '/' + this.actionUrl, pIn);
         let p = r;
         if (p && p.queuedJobId) {

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -6,7 +6,7 @@ import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
 export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature): void;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare type dbTestWhatSignature = (db: {
     db: DataProvider;

package/esm/src/shared-tests/db-tests-setup.js

@@ -22,7 +22,6 @@ export function addDatabaseToTest(tester) {
         test(tester);
     }
     databasesTesters.push(tester);
-    return tester;
 }
 export function testInMemory(key, what, focus = false) {
     itWithFocus(key + " - in memory", async () => {

package/esm/src/sort.d.ts

@@ -5,6 +5,7 @@ export declare class Sort {
     constructor(...segments: SortSegment[]);
     Segments: SortSegment[];
     reverse(): Sort;
+    compare(a: any, b: any): number;
     static translateOrderByToSort<T>(entityDefs: EntityMetadata<T>, orderBy: EntityOrderBy<T>): Sort;
     static createUniqueSort<T>(entityMetadata: EntityMetadata<T>, orderBy: Sort): Sort;
     static createUniqueEntityOrderBy<T>(entityMetadata: EntityMetadata<T>, orderBy: EntityOrderBy<T>): EntityOrderBy<T>;

package/esm/src/sort.js

@@ -21,6 +21,24 @@ export class Sort {
         }
         return r;
     }
+    compare(a, b) {
+        let r = 0;
+        for (let i = 0; i < this.Segments.length; i++) {
+            let seg = this.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;
+    }
     static translateOrderByToSort(entityDefs, orderBy) {
         if (!orderBy)
             return undefined;

package/esm/src/tests/testHelper.spec.d.ts

@@ -1,5 +1,6 @@
 import './frontend-database-tests-setup.spec';
 import { Remult } from "../context";
+import { DataApi } from "../data-api";
 import { DataProvider, EntityDataProvider } from "../data-interfaces";
 import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { EntityMetadata } from "../remult3";
@@ -32,3 +33,4 @@ export declare class MockRestDataProvider implements DataProvider {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;
 }
+export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("c:/Repos/radweb/projects/core/src/data-interfaces").RestDataProviderHttpProvider;