remult 0.17.2 → 0.18.0

package/esm/remult-mongo.js

@@ -1,10 +1,18 @@
 import { CompoundIdField, Filter } from '.';
-import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
+import { getRepository } from './src/remult3';
+import { remult as remultContext } from './src/remult-proxy';
 export class MongoDataProvider {
     constructor(db, client) {
         this.db = db;
         this.client = client;
     }
+    static getDb(remult) {
+        const r = (remult || remultContext).dataProvider;
+        if (!r.db)
+            throw "the data provider is not a MongoDataProvider";
+        return r.db;
+    }
     getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity);
     }
@@ -20,6 +28,14 @@ export class MongoDataProvider {
             throw err;
         }
     }
+    static async filterToRaw(entity, condition) {
+        const repo = getRepository(entity);
+        var b = new FilterConsumerBridgeToMongo(await dbNamesOf(repo.metadata));
+        b._addWhere = false;
+        await (await (repo.translateWhereToFilter(condition))).__applyToConsumer(b);
+        let r = await b.resolveWhere();
+        return r;
+    }
 }
 const NULL = { $null: "$null" };
 function isNull(x) {
@@ -33,7 +49,7 @@ class MongoEntityDataProvider {
     translateFromJson(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            let val = row[nameProvider.nameOf(col)];
+            let val = row[nameProvider.$dbNameOf(col)];
             if (isNull(val))
                 val = null;
             result[col.key] = col.valueConverter.fromDb(val);
@@ -46,7 +62,7 @@ class MongoEntityDataProvider {
             let val = col.valueConverter.toDb(row[col.key]);
             if (val === null)
                 val = NULL;
-            result[nameProvider.nameOf(col)] = val;
+            result[nameProvider.$dbNameOf(col)] = val;
         }
         return result;
     }
@@ -73,7 +89,7 @@ class MongoEntityDataProvider {
         if (options.orderBy) {
             op.sort = {};
             for (const s of options.orderBy.Segments) {
-                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+                op.sort[e.$dbNameOf(s.field)] = s.isDescending ? -1 : 1;
             }
         }
         return await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
@@ -116,8 +132,8 @@ class MongoEntityDataProvider {
         return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }), e);
     }
     async collection() {
-        const e = await getDbNameProvider(this.entity);
-        const collection = this.db.collection(e.entityName);
+        const e = await dbNamesOf(this.entity);
+        const collection = this.db.collection(e.$entityName);
         return { e, collection };
     }
 }
@@ -171,7 +187,7 @@ class FilterConsumerBridgeToMongo {
     }
     isIn(col, val) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: {
+            [this.nameProvider.$dbNameOf(col)]: {
                 $in: val.map(x => col.valueConverter.toDb(x))
             }
         }));
@@ -203,7 +219,7 @@ class FilterConsumerBridgeToMongo {
     }
     add(col, val, operator) {
         this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+            [this.nameProvider.$dbNameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
         }));
     }
     databaseCustom(databaseCustom) {

package/esm/remult-next.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { GetServerSideProps, NextApiRequest, PreviewData, NextApiHandler } from "next";
+import type { ParsedUrlQuery } from "querystring";
+import { RemultServer, RemultServerOptions } from "./server";
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultServer & NextApiHandler & {
+    getServerSideProps<P extends {
+        [key: string]: any;
+    } = {
+        [key: string]: any;
+    }, Q extends ParsedUrlQuery = ParsedUrlQuery, D extends PreviewData = PreviewData>(getServerPropsFunction: GetServerSideProps<P, Q, D>): GetServerSideProps<P, Q, D>;
+};

package/esm/remult-next.js

@@ -0,0 +1,27 @@
+import { createRemultServer } from "./server";
+export function remultNext(options) {
+    let result = createRemultServer(options);
+    return Object.assign((req, res) => result.handle(req, res), result, {
+        getRemult: (...args) => result.getRemult(...args),
+        handle: (...args) => result.handle(...args),
+        openApiDoc: (...args) => result.openApiDoc(...args),
+        registerRouter: (...args) => result.registerRouter(...args),
+        withRemult: (...args) => result.withRemult(...args),
+    }, {
+        getServerSideProps: (getServerPropsFunction) => {
+            return (context) => {
+                return new Promise((res, err) => {
+                    result.withRemult(context, undefined, async () => {
+                        try {
+                            let r = await getServerPropsFunction(context);
+                            res(JSON.parse(JSON.stringify(r)));
+                        }
+                        catch (e) {
+                            err(e);
+                        }
+                    });
+                });
+            };
+        }
+    });
+}

package/esm/server/core.d.ts

@@ -1,2 +1,4 @@
 export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/server/core.js

@@ -1,2 +1,4 @@
 export { createRemultServerCore } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/server/expressBridge.d.ts

@@ -4,6 +4,7 @@ import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
+import { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -11,8 +12,20 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
     queueStorage?: QueueStorage;
-    initRequest?: (remult: Remult, origReq: RequestType) => Promise<void>;
-    getUser?: (request: RequestType) => Promise<UserInfo>;
+    liveQueryStorage?: LiveQueryStorage;
+    subscriptionServer?: SubscriptionServer;
+    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
+    requestSerializer?: {
+        toJson: (request: RequestType) => any;
+        fromJson: (request: any) => RequestType;
+    };
+    /** Will create tables and columns in supporting databases. default: true
+     *
+     * @description
+     * when set to true, it'll create entities that do not exist, and add columns that are missing.
+    */
+    ensureSchema?: boolean;
+    getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
@@ -20,6 +33,10 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
+export interface InitRequestOptions {
+    liveQueryStorage: LiveQueryStorage;
+    readonly remult: Remult;
+}
 export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
@@ -73,11 +90,6 @@ export interface queuedJobInfo {
     setResult(result: any): void;
     setProgress(progress: number): void;
 }
-export interface ApiActionResponse {
-    error(error: any): void;
-    success(result: any): void;
-    progress(progress: number): void;
-}
 export interface QueueStorage {
     createJob(url: string, userId: string): Promise<string>;
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;

package/esm/server/expressBridge.js

@@ -5,11 +5,18 @@ 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, streamUrl } from '../src/live-query/SubscriptionChannel';
+import { initDataProvider } from './initDataProvider';
+import { SseSubscriptionServer } from "../SseSubscriptionServer";
 ;
 export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer();
+    }
     if (options.logApiEndPoints === undefined)
         options.logApiEndPoints = true;
     actionInfo.runningOnServer = true;
@@ -19,29 +26,59 @@ export function createRemultServerCore(options) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider;
-    if (typeof options.dataProvider === "function") {
-        dataProvider = options.dataProvider();
-    }
-    else
-        dataProvider = Promise.resolve(options.dataProvider);
-    dataProvider = dataProvider.then(async (dp) => {
-        if (dp)
-            return dp;
-        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
-    });
+    let dataProvider = initDataProvider(options.dataProvider);
+    if (options.ensureSchema === undefined)
+        options.ensureSchema = true;
     RemultAsyncLocalStorage.enable();
-    if (options.initApi) {
-        dataProvider = dataProvider.then(async (dp) => {
-            var remult = new Remult(dp);
-            await new Promise((res) => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+    dataProvider = dataProvider.then(async (dp) => {
+        var remult = new Remult(dp);
+        await new Promise((res) => {
+            RemultAsyncLocalStorage.instance.run(remult, async () => {
+                if (options.ensureSchema) {
+                    let started = false;
+                    const startConsoleLog = () => {
+                        if (started)
+                            return;
+                        started = true;
+                        console.time("Ensure Schema");
+                    };
+                    if (dp.ensureSchema) {
+                        startConsoleLog();
+                        const entitiesMetadata = options.entities.map(e => remult.repo(e).metadata);
+                        await dp.ensureSchema(entitiesMetadata);
+                    }
+                    for (const item of [options.liveQueryStorage, options.queueStorage]) {
+                        if (item?.ensureSchema) {
+                            startConsoleLog();
+                            await item.ensureSchema();
+                        }
+                    }
+                    if (started)
+                        console.timeEnd("Ensure Schema");
+                }
+                if (options.initApi)
                     await options.initApi(remult);
-                    res({});
-                });
+                res({});
             });
-            return dp;
         });
+        return dp;
+    });
+    if (!options.requestSerializer) {
+        options.requestSerializer = {
+            toJson: x => {
+                const r = {
+                    url: x.url
+                };
+                for (const key of ['session', 'auth', 'user']) {
+                    if (x[key])
+                        r[key] = x[key];
+                }
+                return r;
+            },
+            fromJson: x => {
+                return x;
+            }
+        };
     }
     {
         let allControllers = [];
@@ -90,25 +127,50 @@ export class RemultAsyncLocalStorage {
     }
 }
 RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
-class RemultServerImplementation {
+/* @internal*/
+export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.liveQueryStorage = new InMemoryLiveQueryStorage();
+        this.runWithRequest = async (req, entityKey, what) => {
+            for (const e of this.options.entities) {
+                let key = getEntityKey(e);
+                if (key === entityKey) {
+                    await new Promise((result) => {
+                        this.withRemult(this.options.requestSerializer.fromJson(req), undefined, async () => {
+                            await what(remult.repo(e));
+                            result({});
+                        });
+                    });
+                    return;
+                }
+            }
+            throw new Error("Couldn't find entity " + entityKey);
+        };
         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);
     }
-    handle(req, gRes) {
+    getRouteImpl() {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation();
             this.registerRouter(this.routeImpl);
         }
-        return this.routeImpl.handle(req, gRes);
+        return this.routeImpl;
+    }
+    handle(req, gRes) {
+        return this.getRouteImpl().handle(req, gRes);
     }
     registerRouter(r) {
         if (this.registeredRouter)
@@ -144,6 +206,21 @@ class RemultServerImplementation {
                     },
                     doWork: undefined
                 }, r);
+            if (this.options.subscriptionServer instanceof SseSubscriptionServer) {
+                const streamPath = this.options.rootPath + '/' + streamUrl;
+                r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.openHttpServerStream(origReq, origRes);
+                }));
+                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult);
+                }));
+                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
+                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult, true);
+                }));
+            }
+            r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, origReq, origRes) => {
+                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(origReq.body));
+            }));
         }
         this.options.entities.forEach(e => {
             let key = getEntityKey(e);
@@ -156,11 +233,11 @@ class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
+            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.options.requestSerializer.toJson(orig)))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
-            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body)));
+            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body, () => this.options.requestSerializer.toJson(orig))));
         r.route(myRoute + '/:id')
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
@@ -170,11 +247,14 @@ class RemultServerImplementation {
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
     }
     process(what) {
-        return async (req, res) => {
+        return async (req, origRes) => {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
             let remult = new Remult();
+            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 => {
                 RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
@@ -190,9 +270,17 @@ 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);
+                    await what(remult, myReq, myRes, req, origRes);
                     res({});
                 });
             });
@@ -218,7 +306,7 @@ class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);
@@ -582,7 +670,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;
     }
@@ -720,6 +812,18 @@ class RouteImplementation {
                 constructor() {
                     this.statusCode = 200;
                 }
+                write(data) {
+                    gRes.write(data);
+                }
+                writeHead(statusCode, headers) {
+                    gRes.writeHead(statusCode, headers);
+                    this.statusCode = statusCode;
+                    res({ statusCode });
+                }
+                flush() {
+                    if (gRes.flush)
+                        gRes.flush();
+                }
                 json(data) {
                     if (gRes !== undefined)
                         gRes.json(data);

package/esm/server/index.d.ts

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

package/esm/server/index.js

@@ -1,6 +1,7 @@
-import { createRemultServerCore } from './expressBridge';
+import { createRemultServerCore, } from './expressBridge';
 import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export function createRemultServer(options) {
     initAsyncHooks();
     return createRemultServerCore(options);

package/esm/server/initDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../src/data-interfaces';
+export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/esm/server/initDataProvider.js

@@ -0,0 +1,14 @@
+export function initDataProvider(optionsDataProvider) {
+    let dataProvider;
+    if (typeof optionsDataProvider === "function") {
+        dataProvider = optionsDataProvider();
+    }
+    else
+        dataProvider = Promise.resolve(optionsDataProvider);
+    dataProvider = dataProvider.then(async (dp) => {
+        if (dp)
+            return dp;
+        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
+    });
+    return dataProvider;
+}

package/esm/src/buildRestDataProvider.d.ts

@@ -0,0 +1,31 @@
+import { RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
+export declare function isExternalHttpProvider(item: any): boolean;
+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>;
+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>;
+    };
+}

package/esm/src/buildRestDataProvider.js

@@ -0,0 +1,110 @@
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+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 isExternalHttpProvider(item) {
+    let http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+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;
+}