remult 0.17.3 → 0.18.0

package/esm/src/context.d.ts

@@ -1,43 +1,20 @@
-import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { DataProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-export interface ExternalHttpProvider {
-    post(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    delete(url: string): Promise<void> | {
-        toPromise(): Promise<void>;
-    };
-    put(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    get(url: string): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-}
-export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
-    private http;
-    constructor(http: ExternalHttpProvider);
-    post(url: string, data: any): Promise<any>;
-    delete(url: string): Promise<void>;
-    put(url: string, data: any): Promise<any>;
-    get(url: string): Promise<any>;
-}
-export declare function retry<T>(what: () => Promise<T>): Promise<T>;
-export declare function toPromise<T>(p: Promise<T> | {
-    toPromise(): Promise<T>;
-}): Promise<any>;
-export declare function processHttpException(ex: any): Promise<any>;
+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;
@@ -53,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.
@@ -62,23 +41,42 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
+    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;
     /** 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 {
@@ -88,18 +86,17 @@ export declare const classHelpers: Map<any, ClassHelper>;
 export declare class ClassHelper {
     classes: Map<any, ControllerOptions>;
 }
-export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider | RestDataProviderHttpProviderUsingFetch;
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;
     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;
@@ -113,3 +110,9 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
+export interface itemChange {
+    id: any;
+    oldId: any;
+    deleted: boolean;
+}
+export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;

package/esm/src/context.js

@@ -1,105 +1,31 @@
 import { actionInfo, serverActionField } from './server-action';
-import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { RestDataProvider } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
-export class HttpProviderBridgeToRestDataProviderHttpProvider {
-    constructor(http) {
-        this.http = http;
-    }
-    async post(url, data) {
-        return await retry(() => toPromise(this.http.post(url, data)));
-    }
-    delete(url) {
-        return toPromise(this.http.delete(url));
-    }
-    put(url, data) {
-        return toPromise(this.http.put(url, data));
-    }
-    async get(url) {
-        return await retry(() => toPromise(this.http.get(url)));
-    }
-}
-export async function retry(what) {
-    while (true) {
-        try {
-            return await what();
-        }
-        catch (err) {
-            if (err.message?.startsWith("Error occurred while trying to proxy") ||
-                err.message?.startsWith("Error occured while trying to proxy") ||
-                err.message?.includes("http proxy error") ||
-                err.message?.startsWith("Gateway Timeout")) {
-                await new Promise((res, req) => {
-                    setTimeout(() => {
-                        res({});
-                    }, 250);
-                });
-                continue;
-            }
-            throw err;
-        }
-    }
-}
-export function toPromise(p) {
-    let r;
-    if (p["toPromise"] !== undefined) {
-        r = p["toPromise"]();
-    }
-    //@ts-ignore
-    else
-        r = p;
-    return r.then((x) => {
-        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
-            return x.data;
-        return x;
-    }).catch(async (ex) => {
-        throw await processHttpException(ex);
-    });
-}
-export async function processHttpException(ex) {
-    let z = await ex;
-    var error;
-    if (z.error)
-        error = z.error;
-    else if (z.isAxiosError) {
-        if (typeof z.response?.data === "string")
-            error = z.response.data;
-        else
-            error = z?.response?.data;
-    }
-    if (!error)
-        error = z.message;
-    if (z.status == 0 && z.error.isTrusted)
-        error = "Network Error";
-    if (typeof error === 'string') {
-        error = {
-            message: error,
-        };
-    }
-    if (z.modelState)
-        error.modelState = z.modelState;
-    let httpStatusCode = z.status;
-    if (httpStatusCode === undefined)
-        httpStatusCode = z.response?.status;
-    if (httpStatusCode !== undefined && httpStatusCode !== null) {
-        error.httpStatusCode = httpStatusCode;
-    }
-    var result = Object.assign(error, {
-    //     exception: ex disabled for now because JSON.stringify crashed with this
-    });
-    return result;
-}
+import { LiveQueryClient } from "./live-query/LiveQueryClient";
+import { SseSubscriptionClient } from "./live-query/SseSubscriptionClient";
+import { RemultProxy } from "./remult-proxy";
+import { buildRestDataProvider, isExternalHttpProvider } from "./buildRestDataProvider";
 export function isBackend() {
     return actionInfo.runningOnServer;
 }
 export class Remult {
     constructor(provider) {
-        /* @internal */
-        this.repCache = new Map();
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
+        /* @internal */
+        this.repCache = new Map();
+        /* @internal*/
+        this.liveQueryPublisher = {
+            itemChanged: async () => { }
+        };
+        /* @internal*/
+        this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient, () => this.user?.id);
+        /** 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;
@@ -116,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)
@@ -136,7 +67,6 @@ export class Remult {
         }
         return r;
     }
-    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
         return this.user?.id !== undefined;
@@ -182,11 +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)
@@ -200,6 +138,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();
@@ -208,28 +147,6 @@ export class ClassHelper {
         this.classes = new Map();
     }
 }
-function isExternalHttpProvider(item) {
-    let http = item;
-    if (http && http.get && http.put && http.post && http.delete)
-        return true;
-    return false;
-}
-export function buildRestDataProvider(provider) {
-    if (!provider)
-        return new RestDataProviderHttpProviderUsingFetch();
-    let httpDataProvider;
-    if (!httpDataProvider) {
-        if (isExternalHttpProvider(provider)) {
-            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
-        }
-    }
-    if (!httpDataProvider) {
-        if (typeof provider === "function") {
-            httpDataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
-        }
-    }
-    return httpDataProvider;
-}
 export function setControllerSettings(target, options) {
     let r = target;
     while (true) {
@@ -246,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
 };
@@ -269,3 +195,47 @@ export class EventSource {
         }
     }
 }
+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.liveQueryPublisher = trans;
+        await what();
+        ok = true;
+    });
+    if (ok)
+        await trans.flush();
+}
+class transactionLiveQueryPublisher {
+    constructor(orig) {
+        this.orig = orig;
+        this.transactionItems = new Map();
+    }
+    async itemChanged(entityKey, changes) {
+        let items = this.transactionItems.get(entityKey);
+        if (!items) {
+            this.transactionItems.set(entityKey, items = []);
+        }
+        for (const c of changes) {
+            if (c.oldId !== undefined) {
+                const item = items.find(y => y.id === c.oldId);
+                if (item !== undefined) {
+                    if (c.deleted)
+                        item.deleted = true;
+                    if (c.id != item.id)
+                        item.id = c.id;
+                }
+                else
+                    items.push(c);
+            }
+            else
+                items.push(c);
+        }
+    }
+    async flush() {
+        for (const key of this.transactionItems.keys()) {
+            await this.orig.itemChanged(key, this.transactionItems.get(key));
+        }
+    }
+}

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

@@ -1,16 +1,21 @@
 import { Remult } from './context';
-import { Repository } from './remult3';
+import { FindOptions, Repository } from './remult3';
 import { ErrorInfo } from './data-interfaces';
 export declare class DataApi<T = any> {
     private repository;
     private remult;
     constructor(repository: Repository<T>, remult: Remult);
-    httpGet(res: DataApiResponse, req: DataApiRequest): Promise<void>;
-    httpPost(res: DataApiResponse, req: DataApiRequest, body: any): Promise<void>;
+    httpGet(res: DataApiResponse, req: DataApiRequest, serializeRequest: () => any): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeRequest: () => any): Promise<void>;
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
+        r: any[];
+        findOptions: FindOptions<T>;
+    }>;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
@@ -31,3 +36,4 @@ 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;