remult 0.21.1 → 0.22.0

package/esm/src/context.js

@@ -1,12 +1,44 @@
 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 { SseSubscriptionClient } from "./live-query/SseSubscriptionClient";
-import { RemultProxy } from "./remult-proxy";
-import { buildRestDataProvider, isExternalHttpProvider } from "./buildRestDataProvider";
+import { RepositoryImplementation } from './remult3/RepositoryImplementation';
+import { LiveQueryClient } from './live-query/LiveQueryClient';
+import { SseSubscriptionClient } from './live-query/SseSubscriptionClient';
+import { RemultProxy, remult } from './remult-proxy';
+import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider';
+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);
+        else
+            callback();
+    }
+    getRemult() {
+        if (!this.remultObjectStorage) {
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
+        }
+        return this.remultObjectStorage.getStore();
+    }
+}
+RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
 export function isBackend() {
-    return actionInfo.runningOnServer;
+    return actionInfo.runningOnServer || !remult.dataProvider.isProxy;
 }
 export class Remult {
     constructor(provider) {
@@ -16,7 +48,7 @@ export class Remult {
         this.repCache = new Map();
         /* @internal*/
         this.liveQueryPublisher = {
-            itemChanged: async () => { }
+            itemChanged: async () => { },
         };
         /* @internal*/
         this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient, () => this.user?.id);
@@ -25,7 +57,7 @@ export class Remult {
         /** The api client that will be used by `remult` to perform calls to the `api` */
         this.apiClient = {
             url: '/api',
-            subscriptionClient: new SseSubscriptionClient()
+            subscriptionClient: new SseSubscriptionClient(),
         };
         if (provider && provider.getEntityDataProvider) {
             this.dataProvider = provider;
@@ -34,7 +66,7 @@ export class Remult {
         if (isExternalHttpProvider(provider)) {
             this.apiClient.httpClient = provider;
         }
-        else if (typeof (provider) === "function")
+        else if (typeof provider === 'function')
             this.apiClient.httpClient = provider;
         else if (provider) {
             const apiClient = provider;
@@ -60,10 +92,10 @@ export class Remult {
             dataProvider = this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
-            this.repCache.set(dataProvider, dpCache = new Map());
+            this.repCache.set(dataProvider, (dpCache = new Map()));
         let r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, r = new RepositoryImplementation(entity, this, dataProvider));
+            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider)));
         }
         return r;
     }
@@ -111,7 +143,7 @@ export class Remult {
                 }
             }
         }
-        else if (typeof (allowed) === "function") {
+        else if (typeof allowed === 'function') {
             return allowed(instance, this);
         }
         else
@@ -124,22 +156,31 @@ export class Remult {
      * @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]);
+        const z = backendMethod[serverActionField];
         if (!z.doWork)
-            throw Error("The method received is not a valid backend method");
+            throw Error('The method received is not a valid backend method');
         //@ts-ignore
         return z.doWork(args, classInstance, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
     }
     clearAllCache() {
         this.repCache.clear();
     }
+    static run(callback, options) {
+        const remult = new Remult();
+        if (options.dataProvider)
+            remult.dataProvider = options.dataProvider;
+        let r;
+        RemultAsyncLocalStorage.instance.run(remult, () => {
+            r = callback();
+        });
+        return r;
+    }
 }
 /** 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();
 export class ClassHelper {
@@ -152,7 +193,7 @@ export function setControllerSettings(target, options) {
     while (true) {
         let helper = classHelpers.get(r);
         if (!helper)
-            classHelpers.set(r, helper = new ClassHelper());
+            classHelpers.set(r, (helper = new ClassHelper()));
         helper.classes.set(target, options);
         let p = Object.getPrototypeOf(r.prototype);
         if (p == null)
@@ -171,10 +212,10 @@ Allow.authenticated = (...args) => {
         if (args[0].authenticated)
             return args[0].authenticated();
     }
-    return RemultProxy.defaultRemult.authenticated();
+    return remult.authenticated();
 };
 export const queryConfig = {
-    defaultPageSize: 200
+    defaultPageSize: 200,
 };
 export class EventSource {
     constructor() {
@@ -184,9 +225,9 @@ export class EventSource {
                 this.listeners.push(what);
                 await what();
                 return () => {
-                    this.listeners = this.listeners.filter(x => x != what);
+                    this.listeners = this.listeners.filter((x) => x != what);
                 };
-            }
+            },
         };
     }
     async fire() {
@@ -199,7 +240,7 @@ export async function doTransaction(remult, what) {
     const trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
     let ok = true;
     const result = await remult.dataProvider.transaction(async (ds) => {
-        remult.dataProvider = (ds);
+        remult.dataProvider = ds;
         remult.liveQueryPublisher = trans;
         await what();
         ok = true;
@@ -215,11 +256,11 @@ class transactionLiveQueryPublisher {
     async itemChanged(entityKey, changes) {
         let items = this.transactionItems.get(entityKey);
         if (!items) {
-            this.transactionItems.set(entityKey, items = []);
+            this.transactionItems.set(entityKey, (items = []));
         }
         for (const c of changes) {
             if (c.oldId !== undefined) {
-                const item = items.find(y => y.id === c.oldId);
+                const item = items.find((y) => y.id === c.oldId);
                 if (item !== undefined) {
                     if (c.deleted)
                         item.deleted = true;

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

@@ -36,4 +36,3 @@ export interface DataApiRequest {
 }
 export declare function determineSort(sortUrlParm: string, dirUrlParam: string): any;
 export declare function serializeError(data: ErrorInfo): ErrorInfo<any>;
-export declare function getLiveQueryChannel(queryId: string, userId: string): string;

package/esm/src/data-api.js

@@ -1,36 +1,36 @@
-import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
+import { customUrlToken, buildFilterFromRequestParameters, } from './filter/filter-interfaces';
 import { doTransaction } from './context';
 import { Filter } from './filter/filter-interfaces';
 import { ForbiddenError } from './server-action';
-import { findOptionsToJson, liveQueryAction } from './data-providers/rest-data-provider';
+import { findOptionsToJson, liveQueryAction, } from './data-providers/rest-data-provider';
 export class DataApi {
     constructor(repository, remult) {
         this.repository = repository;
         this.remult = remult;
     }
     httpGet(res, req, serializeContext) {
-        const action = req?.get("__action");
+        const action = req?.get('__action');
         if (action?.startsWith(liveQueryAction))
-            return this.liveQuery(res, req, undefined, serializeContext, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+            return this.liveQuery(res, req, undefined, serializeContext, action.substring(liveQueryAction.length));
         switch (action) {
-            case "get":
-            case "count":
+            case 'get':
+            case 'count':
                 return this.count(res, req, undefined);
         }
         return this.getArray(res, req, undefined);
     }
     async httpPost(res, req, body, serializeContext) {
-        const action = req?.get("__action");
+        const action = req?.get('__action');
         if (action?.startsWith(liveQueryAction))
-            return this.liveQuery(res, req, undefined, serializeContext, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+            return this.liveQuery(res, req, undefined, serializeContext, action.substring(liveQueryAction.length));
         switch (action) {
-            case "get":
+            case 'get':
                 return this.getArray(res, req, body);
-            case "count":
+            case 'count':
                 return this.count(res, req, body);
-            case "endLiveQuery":
-                await this.remult.liveQueryStorage.remove(getLiveQueryChannel(body.id, this.remult.user?.id));
-                res.success("ok");
+            case 'endLiveQuery':
+                await this.remult.liveQueryStorage.remove(body.id);
+                res.success('ok');
                 return;
             default:
                 return this.post(res, body);
@@ -49,7 +49,9 @@ export class DataApi {
             return;
         }
         try {
-            response.success({ count: +await this.repository.count(await this.buildWhere(request, filterBody)) });
+            response.success({
+                count: +(await this.repository.count(await this.buildWhere(request, filterBody))),
+            });
         }
         catch (err) {
             response.error(err);
@@ -59,16 +61,16 @@ export class DataApi {
         let findOptions = { load: () => [] };
         findOptions.where = await this.buildWhere(request, filterBody);
         if (request) {
-            let sort = request.get("_sort");
+            let sort = request.get('_sort');
             if (sort != undefined) {
                 let dir = request.get('_order');
                 findOptions.orderBy = determineSort(sort, dir);
             }
-            let limit = +request.get("_limit");
+            let limit = +request.get('_limit');
             if (!limit && DataApi.defaultGetLimit)
                 limit = DataApi.defaultGetLimit;
             findOptions.limit = limit;
-            findOptions.page = +request.get("_page");
+            findOptions.page = +request.get('_page');
         }
         if (this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) {
             let hasId = false;
@@ -90,7 +92,7 @@ export class DataApi {
                     isLessThan: () => { },
                     isNotNull: () => { },
                     isNull: () => { },
-                    or: () => { }
+                    or: () => { },
                 });
             }
             if (!hasId) {
@@ -98,8 +100,7 @@ export class DataApi {
                 throw new ForbiddenError();
             }
         }
-        const r = await this.repository.find(findOptions)
-            .then(async (r) => {
+        const r = await this.repository.find(findOptions).then(async (r) => {
             return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
         });
         return { r, findOptions };
@@ -130,12 +131,12 @@ export class DataApi {
             const data = {
                 requestJson: await serializeContext(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
-                lastIds: r.r.map(y => this.repository.metadata.idMetadata.getId(y))
+                lastIds: r.r.map((y) => this.repository.metadata.idMetadata.getId(y)),
             };
             await this.remult.liveQueryStorage.add({
                 entityKey: this.repository.metadata.key,
                 id: queryChannel,
-                data
+                data,
             });
             response.success(r.r);
         }
@@ -149,19 +150,19 @@ export class DataApi {
     async buildWhere(request, filterBody) {
         var where = [];
         if (this.repository.metadata.options.apiPrefilter) {
-            if (typeof this.repository.metadata.options.apiPrefilter === "function")
+            if (typeof this.repository.metadata.options.apiPrefilter === 'function')
                 where.push(await this.repository.metadata.options.apiPrefilter());
             else
                 where.push(this.repository.metadata.options.apiPrefilter);
         }
         if (request) {
             where.push(buildFilterFromRequestParameters(this.repository.metadata, {
-                get: key => {
+                get: (key) => {
                     let result = request.get(key);
-                    if (key.startsWith(customUrlToken) && result)
+                    if (key.startsWith(customUrlToken) && result && typeof result === "string")
                         return JSON.parse(result);
                     return result;
-                }
+                },
             }));
         }
         if (filterBody)
@@ -170,21 +171,24 @@ export class DataApi {
     }
     async doOnId(response, id, what) {
         try {
-            var where = [this.repository.metadata.idMetadata.getIdFilter(id)];
+            var where = [
+                this.repository.metadata.idMetadata.getIdFilter(id),
+            ];
             if (this.repository.metadata.options.apiPrefilter) {
-                if (typeof this.repository.metadata.options.apiPrefilter === "function")
+                if (typeof this.repository.metadata.options.apiPrefilter === 'function')
                     where.push(await this.repository.metadata.options.apiPrefilter());
                 else
                     where.push(this.repository.metadata.options.apiPrefilter);
             }
-            await this.repository.find({
-                where: { $and: where }
+            await this.repository
+                .find({
+                where: { $and: where },
             })
                 .then(async (r) => {
                 if (r.length == 0)
                     response.notFound();
                 else if (r.length > 1)
-                    response.error({ message: "id is not unique" });
+                    response.error({ message: 'id is not unique' });
                 else
                     await what(r[0]);
             });
@@ -254,10 +258,10 @@ export function determineSort(sortUrlParm, dirUrlParam) {
     let result = {};
     sortUrlParm.split(',').map((name, i) => {
         let key = name.trim();
-        if (i < dirItems.length && dirItems[i].toLowerCase().trim().startsWith("d"))
-            return result[key] = "desc";
+        if (i < dirItems.length && dirItems[i].toLowerCase().trim().startsWith('d'))
+            return (result[key] = 'desc');
         else
-            return result[key] = "asc";
+            return (result[key] = 'asc');
     });
     return result;
 }
@@ -272,6 +276,3 @@ export function serializeError(data) {
         data = { message: x };
     return data;
 }
-export function getLiveQueryChannel(queryId, userId) {
-    return `users:${userId}:queries:${queryId}`;
-}

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

@@ -4,8 +4,8 @@ import { EntityMetadata, OmitEB } from './remult3';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsRawFilter?: boolean;
     ensureSchema?(entities: EntityMetadata[]): Promise<void>;
+    isProxy?: boolean;
 }
 export interface Storage {
     ensureSchema(): Promise<void>;

package/esm/src/data-interfaces.js

@@ -4,7 +4,7 @@ export function extractSort(sort) {
         return sort;
     if (sort instanceof Array) {
         let r = new Sort();
-        sort.forEach(i => {
+        sort.forEach((i) => {
             r.Segments.push(i);
         });
         return r;

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

@@ -1,4 +1,4 @@
-import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
+import { customDatabaseFilterToken, Filter, } from '../filter/filter-interfaces';
 import { CompoundIdField } from '../column';
 export class ArrayEntityDataProvider {
     constructor(entity, rows) {
@@ -15,8 +15,8 @@ export class ArrayEntityDataProvider {
     static rawFilter(filter) {
         return {
             [customDatabaseFilterToken]: {
-                arrayFilter: filter
-            }
+                arrayFilter: filter,
+            },
         };
     }
     verifyThatRowHasAllNotNullColumns(r) {
@@ -58,7 +58,7 @@ export class ArrayEntityDataProvider {
         let rows = this.rows;
         if (options) {
             if (options.where) {
-                rows = rows.filter(i => {
+                rows = rows.filter((i) => {
                     let x = new FilterConsumerBridgeToObject(i);
                     options.where.__applyToConsumer(x);
                     return x.ok;
@@ -72,7 +72,7 @@ export class ArrayEntityDataProvider {
             rows = pageArray(rows, options);
         }
         if (rows)
-            return rows.map(i => {
+            return rows.map((i) => {
                 return this.translateFromJson(i);
             });
     }
@@ -91,7 +91,7 @@ export class ArrayEntityDataProvider {
         return result;
     }
     idMatches(id) {
-        return item => {
+        return (item) => {
             let x = new FilterConsumerBridgeToObject(item);
             Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
             return x.ok;
@@ -139,9 +139,9 @@ export class ArrayEntityDataProvider {
                 }
             }
             if (data[idf.key])
-                this.rows.forEach(i => {
+                this.rows.forEach((i) => {
                     if (data[idf.key] == i[idf.key])
-                        throw Error("id already exists");
+                        throw Error('id already exists');
                 });
         }
         let j = this.translateToJson(data);
@@ -161,7 +161,7 @@ function pageArray(rows, options) {
     if (page < 1)
         page = 1;
     let x = 0;
-    return rows.filter(i => {
+    return rows.filter((i) => {
         x++;
         let max = page * options.limit;
         let min = max - options.limit;

package/esm/src/data-providers/in-memory-database.d.ts

@@ -1,5 +1,5 @@
 import { DataProvider, EntityDataProvider } from '../data-interfaces';
-import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
+import { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
 import { EntityMetadata } from '../remult3';
 export declare class InMemoryDataProvider implements DataProvider, __RowsOfDataForTesting {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;

package/esm/src/data-providers/in-memory-database.js

@@ -12,5 +12,7 @@ export class InMemoryDataProvider {
             this.rows[name] = [];
         return new ArrayEntityDataProvider(entity, this.rows[name]);
     }
-    toString() { return "InMemoryDataProvider"; }
+    toString() {
+        return 'InMemoryDataProvider';
+    }
 }

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

@@ -26,27 +26,27 @@ class JsonEntityDataProvider {
         return what(dp, () => this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
     }
     find(options) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.find(options)));
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.find(options))));
     }
     count(where) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where)));
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where))));
     }
     update(id, data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then(x => {
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then((x) => {
             save();
             return x;
-        })));
+        }))));
     }
     delete(id) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(x => {
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then((x) => {
             save();
             return x;
-        })));
+        }))));
     }
     async insert(data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then(x => {
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then((x) => {
             save();
             return x;
-        })));
+        }))));
     }
 }

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

@@ -8,7 +8,7 @@ export declare class RestDataProvider implements DataProvider {
     constructor(apiProvider: () => ApiClient);
     getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsRawFilter: boolean;
+    isProxy: boolean;
 }
 export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;