remult 3.0.0-next.1 → 3.0.0-next.3

package/esm/src/buildRestDataProvider.js

@@ -1,5 +1,5 @@
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider.js';
-import { flags } from './remult3/remult3.js';
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider-using-fetch.js';
+import { retry } from './data-providers/retry.js';
 export function buildRestDataProvider(provider) {
     if (!provider)
         return new RestDataProviderHttpProviderUsingFetch();
@@ -40,30 +40,6 @@ export class HttpProviderBridgeToRestDataProviderHttpProvider {
         return await retry(() => toPromise(this.http.get(url)));
     }
 }
-export async function retry(what) {
-    let i = 0;
-    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') ||
-                err.status == 500) &&
-                i++ < flags.error500RetryCount) {
-                await new Promise((res, req) => {
-                    setTimeout(() => {
-                        res({});
-                    }, 500);
-                });
-                continue;
-            }
-            throw err;
-        }
-    }
-}
 export function toPromise(p) {
     let r;
     if (p['toPromise'] !== undefined) {

package/esm/src/context.js

@@ -1,3 +1,4 @@
+import { DataProviderPromiseWrapper, } from './data-interfaces.js';
 import { buildFullUrl, RestDataProvider, } from './data-providers/rest-data-provider.js';
 import { LiveQueryClient } from './live-query/LiveQueryClient.js';
 import { SseSubscriptionClient } from './live-query/SseSubscriptionClient.js';
@@ -65,9 +66,20 @@ export class Remult {
      */
     repo = (entity, dataProvider) => {
         const info = createOldEntity(entity, this);
-        if (dataProvider === undefined)
-            dataProvider =
-                info?.options?.dataProvider?.(this.dataProvider) ?? this.dataProvider;
+        if (dataProvider === undefined) {
+            if (info?.options?.dataProvider) {
+                const d = info.options.dataProvider(this.dataProvider);
+                if (d instanceof Promise) {
+                    dataProvider = new DataProviderPromiseWrapper(d);
+                }
+                else {
+                    dataProvider = d ?? undefined;
+                }
+            }
+        }
+        if (!dataProvider) {
+            dataProvider = this.dataProvider;
+        }
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, (dpCache = new Map()));

package/esm/src/data-interfaces.js

@@ -19,3 +19,43 @@ export class EntityError extends Error {
     exception;
     httpStatusCode;
 }
+export class DataProviderPromiseWrapper {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    getEntityDataProvider(entity) {
+        return new EntityDataProviderPromiseWrapper(this.dataProvider.then((dp) => dp.getEntityDataProvider(entity)));
+    }
+    transaction(action) {
+        return this.dataProvider.then((dp) => dp.transaction(action));
+    }
+    ensureSchema(entities) {
+        return this.dataProvider.then((dp) => dp.ensureSchema?.(entities));
+    }
+    isProxy;
+}
+class EntityDataProviderPromiseWrapper {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    delete(id) {
+        return this.dataProvider.then((dp) => dp.delete(id));
+    }
+    insert(data) {
+        return this.dataProvider.then((dp) => dp.insert(data));
+    }
+    count(where) {
+        return this.dataProvider.then((dp) => dp.count(where));
+    }
+    find(options) {
+        return this.dataProvider.then((dp) => dp.find(options));
+    }
+    groupBy(options) {
+        return this.dataProvider.then((dp) => dp.groupBy(options));
+    }
+    update(id, data) {
+        return this.dataProvider.then((dp) => dp.update(id, data));
+    }
+}

package/esm/src/data-providers/rest-data-provider-using-fetch.js

@@ -0,0 +1,78 @@
+import { retry } from './retry.js';
+export class RestDataProviderHttpProviderUsingFetch {
+    fetch;
+    constructor(fetch) {
+        this.fetch = fetch;
+    }
+    async get(url) {
+        return await retry(async () => this.myFetch(url).then((r) => {
+            return r;
+        }));
+    }
+    put(url, data) {
+        return this.myFetch(url, {
+            method: 'put',
+            body: JSON.stringify(data),
+        });
+    }
+    delete(url) {
+        return this.myFetch(url, { method: 'delete' });
+    }
+    async post(url, data) {
+        return await retry(() => this.myFetch(url, {
+            method: 'post',
+            body: JSON.stringify(data),
+        }));
+    }
+    myFetch(url, options) {
+        const headers = {};
+        if (options?.body)
+            headers['Content-type'] = 'application/json';
+        if (typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined' &&
+            typeof (window.document.cookie !== 'undefined'))
+            for (const cookie of window.document.cookie.split(';')) {
+                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
+                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
+                }
+            }
+        return (this.fetch || fetch)(url, {
+            credentials: 'include',
+            method: options?.method,
+            body: options?.body,
+            headers,
+        })
+            .then((response) => {
+            return onSuccess(response);
+        })
+            .catch(async (error) => {
+            let r = await error;
+            throw r;
+        });
+    }
+}
+function onSuccess(response) {
+    if (response.status == 204)
+        return;
+    if (response.status >= 200 && response.status < 300)
+        return response.json();
+    else {
+        throw response
+            .json()
+            .then((x) => {
+            return {
+                ...x,
+                message: x.message || response.statusText,
+                url: response.url,
+                status: response.status,
+            };
+        })
+            .catch(() => {
+            throw {
+                message: response.statusText,
+                url: response.url,
+                status: response.status,
+            };
+        });
+    }
+}

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

@@ -1,5 +1,5 @@
 import { UrlBuilder } from '../../urlBuilder.js';
-import { buildRestDataProvider, retry } from '../buildRestDataProvider.js';
+import { buildRestDataProvider } from '../buildRestDataProvider.js';
 import { customUrlToken, Filter } from '../filter/filter-interfaces.js';
 import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
 import { remultStatic } from '../remult-static.js';
@@ -284,83 +284,6 @@ export class RestEntityDataProvider {
             .then((y) => y.map((y) => this.translateFromJson(y)));
     }
 }
-export class RestDataProviderHttpProviderUsingFetch {
-    fetch;
-    constructor(fetch) {
-        this.fetch = fetch;
-    }
-    async get(url) {
-        return await retry(async () => this.myFetch(url).then((r) => {
-            return r;
-        }));
-    }
-    put(url, data) {
-        return this.myFetch(url, {
-            method: 'put',
-            body: JSON.stringify(data),
-        });
-    }
-    delete(url) {
-        return this.myFetch(url, { method: 'delete' });
-    }
-    async post(url, data) {
-        return await retry(() => this.myFetch(url, {
-            method: 'post',
-            body: JSON.stringify(data),
-        }));
-    }
-    myFetch(url, options) {
-        const headers = {};
-        if (options?.body)
-            headers['Content-type'] = 'application/json';
-        if (typeof window !== 'undefined' &&
-            typeof window.document !== 'undefined' &&
-            typeof (window.document.cookie !== 'undefined'))
-            for (const cookie of window.document.cookie.split(';')) {
-                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
-                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
-                }
-            }
-        return (this.fetch || fetch)(url, {
-            credentials: 'include',
-            method: options?.method,
-            body: options?.body,
-            headers,
-        })
-            .then((response) => {
-            return onSuccess(response);
-        })
-            .catch(async (error) => {
-            let r = await error;
-            throw r;
-        });
-    }
-}
-function onSuccess(response) {
-    if (response.status == 204)
-        return;
-    if (response.status >= 200 && response.status < 300)
-        return response.json();
-    else {
-        throw response
-            .json()
-            .then((x) => {
-            return {
-                ...x,
-                message: x.message || response.statusText,
-                url: response.url,
-                status: response.status,
-            };
-        })
-            .catch(() => {
-            throw {
-                message: response.statusText,
-                url: response.url,
-                status: response.status,
-            };
-        });
-    }
-}
 export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     for (const key in filter) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {

package/esm/src/data-providers/retry.js

@@ -0,0 +1,25 @@
+import { flags } from '../remult3/remult3.js';
+export async function retry(what) {
+    let i = 0;
+    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') ||
+                err.status == 500) &&
+                i++ < flags.error500RetryCount) {
+                await new Promise((res, req) => {
+                    setTimeout(() => {
+                        res({});
+                    }, 500);
+                });
+                continue;
+            }
+            throw err;
+        }
+    }
+}

package/esm/src/filter/entityDbName.js

@@ -0,0 +1,18 @@
+export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
+    if (metadata.options.sqlExpression) {
+        if (typeof metadata.options.sqlExpression === 'string')
+            return metadata.options.sqlExpression;
+        else if (typeof metadata.options.sqlExpression === 'function') {
+            const prev = metadata.options.sqlExpression;
+            try {
+                metadata.options.sqlExpression =
+                    "recursive sqlExpression call for entity '" + metadata.key + "'. ";
+                return await prev(metadata);
+            }
+            finally {
+                metadata.options.sqlExpression = prev;
+            }
+        }
+    }
+    return wrapIdentifier(metadata.dbName);
+}

package/esm/src/filter/fieldDbName.js

@@ -0,0 +1,40 @@
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+const sqlExpressionInProgressKey = Symbol.for(`sqlExpressionInProgressKey`);
+export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlExpression = false) {
+    try {
+        if (f.options.sqlExpression) {
+            let result;
+            if (typeof f.options.sqlExpression === 'function') {
+                if (f[sqlExpressionInProgressKey] && !forceSqlExpression) {
+                    return "recursive sqlExpression call for field '" + f.key + "'. \0";
+                }
+                try {
+                    ;
+                    f[sqlExpressionInProgressKey] = true;
+                    result = await f.options.sqlExpression(meta);
+                    if (!result.includes('\0'))
+                        f.options.sqlExpression = () => result;
+                }
+                finally {
+                    delete f[sqlExpressionInProgressKey];
+                }
+            }
+            else
+                result = f.options.sqlExpression;
+            if (!result)
+                return f.dbName;
+            return result;
+        }
+        const rel = getRelationFieldInfo(f);
+        let field = rel?.type === 'toOne' &&
+            f.options.field;
+        if (field) {
+            let fInfo = meta.fields.find(field);
+            if (fInfo)
+                return fieldDbName(fInfo, meta, wrapIdentifier, forceSqlExpression);
+        }
+        return wrapIdentifier(f.dbName);
+    }
+    finally {
+    }
+}

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,7 +1,8 @@
 import { SqlDatabase } from '../data-providers/sql-database.js';
 import { remult } from '../remult-proxy.js';
 import { getEntityMetadata } from '../remult3/RepositoryImplementation.js';
-import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+import { entityDbName } from './entityDbName.js';
+import { fieldDbName } from './fieldDbName.js';
 export class FilterConsumerBridgeToSqlRequest {
     r;
     nameProvider;
@@ -260,60 +261,3 @@ async function internalDbNamesOf(repo, wrapIdentifierOrOptions, forceSqlExpressi
     }
     return result;
 }
-export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
-    if (metadata.options.sqlExpression) {
-        if (typeof metadata.options.sqlExpression === 'string')
-            return metadata.options.sqlExpression;
-        else if (typeof metadata.options.sqlExpression === 'function') {
-            const prev = metadata.options.sqlExpression;
-            try {
-                metadata.options.sqlExpression =
-                    "recursive sqlExpression call for entity '" + metadata.key + "'. ";
-                return await prev(metadata);
-            }
-            finally {
-                metadata.options.sqlExpression = prev;
-            }
-        }
-    }
-    return wrapIdentifier(metadata.dbName);
-}
-const sqlExpressionInProgressKey = Symbol.for(`sqlExpressionInProgressKey`);
-export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlExpression = false) {
-    try {
-        if (f.options.sqlExpression) {
-            let result;
-            if (typeof f.options.sqlExpression === 'function') {
-                if (f[sqlExpressionInProgressKey] && !forceSqlExpression) {
-                    return "recursive sqlExpression call for field '" + f.key + "'. \0";
-                }
-                try {
-                    ;
-                    f[sqlExpressionInProgressKey] = true;
-                    result = await f.options.sqlExpression(meta);
-                    if (!result.includes('\0'))
-                        f.options.sqlExpression = () => result;
-                }
-                finally {
-                    delete f[sqlExpressionInProgressKey];
-                }
-            }
-            else
-                result = f.options.sqlExpression;
-            if (!result)
-                return f.dbName;
-            return result;
-        }
-        const rel = getRelationFieldInfo(f);
-        let field = rel?.type === 'toOne' &&
-            f.options.field;
-        if (field) {
-            let fInfo = meta.fields.find(field);
-            if (fInfo)
-                return fieldDbName(fInfo, meta, wrapIdentifier, forceSqlExpression);
-        }
-        return wrapIdentifier(f.dbName);
-    }
-    finally {
-    }
-}

package/esm/src/remult3/RepositoryImplementation.js

@@ -14,7 +14,8 @@ import { __updateEntityBasedOnWhere } from './__updateEntityBasedOnWhere.js';
 import { getRelationFieldInfo, } from './relationInfoMember.js';
 import { RelationLoader } from './relation-loader.js';
 import { getInternalKey, } from './repository-internals.js';
-import { entityDbName, fieldDbName, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { entityDbName } from '../filter/entityDbName.js';
+import { fieldDbName } from '../filter/fieldDbName.js';
 import { remultStatic } from '../remult-static.js';
 import { Validators } from '../validators.js';
 import { addValidator } from './addValidator.js';

package/esm/src/validators.js

@@ -1,4 +1,4 @@
-import { getRelationFieldInfo } from '../internals.js';
+import { getRelationFieldInfo } from '../src/remult3/relationInfoMember.js';
 /**
  * Class containing various field validators.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.0.0-next.1",
+    "version": "3.0.0-next.3",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/buildRestDataProvider.d.ts

@@ -9,7 +9,6 @@ export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements
     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>;

package/src/buildRestDataProvider.js

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpProviderBridgeToRestDataProviderHttpProvider = void 0;
 exports.buildRestDataProvider = buildRestDataProvider;
 exports.isExternalHttpProvider = isExternalHttpProvider;
-exports.retry = retry;
 exports.toPromise = toPromise;
 exports.processHttpException = processHttpException;
 var tslib_1 = require("tslib");
-var rest_data_provider_js_1 = require("./data-providers/rest-data-provider.js");
-var remult3_js_1 = require("./remult3/remult3.js");
+var rest_data_provider_using_fetch_js_1 = require("./data-providers/rest-data-provider-using-fetch.js");
+var retry_js_1 = require("./data-providers/retry.js");
 function buildRestDataProvider(provider) {
     if (!provider)
-        return new rest_data_provider_js_1.RestDataProviderHttpProviderUsingFetch();
+        return new rest_data_provider_using_fetch_js_1.RestDataProviderHttpProviderUsingFetch();
     var httpDataProvider;
     if (!httpDataProvider) {
         if (isExternalHttpProvider(provider)) {
@@ -20,7 +19,7 @@ function buildRestDataProvider(provider) {
     }
     if (!httpDataProvider) {
         if (typeof provider === 'function') {
-            httpDataProvider = new rest_data_provider_js_1.RestDataProviderHttpProviderUsingFetch(provider);
+            httpDataProvider = new rest_data_provider_using_fetch_js_1.RestDataProviderHttpProviderUsingFetch(provider);
         }
     }
     return httpDataProvider;
@@ -40,7 +39,7 @@ var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function (
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, retry(function () { return toPromise(_this.http.post(url, data)); })];
+                    case 0: return [4 /*yield*/, (0, retry_js_1.retry)(function () { return toPromise(_this.http.post(url, data)); })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -57,7 +56,7 @@ var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function (
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, retry(function () { return toPromise(_this.http.get(url)); })];
+                    case 0: return [4 /*yield*/, (0, retry_js_1.retry)(function () { return toPromise(_this.http.get(url)); })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -66,45 +65,6 @@ var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function (
     return HttpProviderBridgeToRestDataProviderHttpProvider;
 }());
 exports.HttpProviderBridgeToRestDataProviderHttpProvider = HttpProviderBridgeToRestDataProviderHttpProvider;
-function retry(what) {
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var i, err_1;
-        var _a, _b, _c, _d;
-        return tslib_1.__generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    i = 0;
-                    _e.label = 1;
-                case 1:
-                    if (!true) return [3 /*break*/, 8];
-                    _e.label = 2;
-                case 2:
-                    _e.trys.push([2, 4, , 7]);
-                    return [4 /*yield*/, what()];
-                case 3: return [2 /*return*/, _e.sent()];
-                case 4:
-                    err_1 = _e.sent();
-                    if (!((((_a = err_1.message) === null || _a === void 0 ? void 0 : _a.startsWith('Error occurred while trying to proxy')) ||
-                        ((_b = err_1.message) === null || _b === void 0 ? void 0 : _b.startsWith('Error occured while trying to proxy')) ||
-                        ((_c = err_1.message) === null || _c === void 0 ? void 0 : _c.includes('http proxy error')) ||
-                        ((_d = err_1.message) === null || _d === void 0 ? void 0 : _d.startsWith('Gateway Timeout')) ||
-                        err_1.status == 500) &&
-                        i++ < remult3_js_1.flags.error500RetryCount)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, new Promise(function (res, req) {
-                            setTimeout(function () {
-                                res({});
-                            }, 500);
-                        })];
-                case 5:
-                    _e.sent();
-                    return [3 /*break*/, 1];
-                case 6: throw err_1;
-                case 7: return [3 /*break*/, 1];
-                case 8: return [2 /*return*/];
-            }
-        });
-    });
-}
 function toPromise(p) {
     var _this = this;
     var r;

package/src/context.d.ts

@@ -1,5 +1,5 @@
 import type { ClassType } from '../classType.js';
-import type { DataProvider } from './data-interfaces.js';
+import { type DataProvider } from './data-interfaces.js';
 import type { EntityMetadata, EntityRef, FindOptions, RefSubscriber, Repository } from './remult3/remult3.js';
 import type { ExternalHttpProvider } from './buildRestDataProvider.js';
 import type { SubscriptionClient, Unsubscribe } from './live-query/SubscriptionChannel.js';

package/src/context.js

@@ -6,6 +6,7 @@ exports.setControllerSettings = setControllerSettings;
 exports.doTransaction = doTransaction;
 exports.withRemult = withRemult;
 var tslib_1 = require("tslib");
+var data_interfaces_js_1 = require("./data-interfaces.js");
 var rest_data_provider_js_1 = require("./data-providers/rest-data-provider.js");
 var LiveQueryClient_js_1 = require("./live-query/LiveQueryClient.js");
 var SseSubscriptionClient_js_1 = require("./live-query/SseSubscriptionClient.js");
@@ -82,11 +83,22 @@ var Remult = /** @class */ (function () {
          * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
          */
         this.repo = function (entity, dataProvider) {
-            var _a, _b, _c;
+            var _a;
             var info = (0, RepositoryImplementation_js_1.createOldEntity)(entity, _this);
-            if (dataProvider === undefined)
-                dataProvider =
-                    (_c = (_b = (_a = info === null || info === void 0 ? void 0 : info.options) === null || _a === void 0 ? void 0 : _a.dataProvider) === null || _b === void 0 ? void 0 : _b.call(_a, _this.dataProvider)) !== null && _c !== void 0 ? _c : _this.dataProvider;
+            if (dataProvider === undefined) {
+                if ((_a = info === null || info === void 0 ? void 0 : info.options) === null || _a === void 0 ? void 0 : _a.dataProvider) {
+                    var d = info.options.dataProvider(_this.dataProvider);
+                    if (d instanceof Promise) {
+                        dataProvider = new data_interfaces_js_1.DataProviderPromiseWrapper(d);
+                    }
+                    else {
+                        dataProvider = d !== null && d !== void 0 ? d : undefined;
+                    }
+                }
+            }
+            if (!dataProvider) {
+                dataProvider = _this.dataProvider;
+            }
             var dpCache = _this.repCache.get(dataProvider);
             if (!dpCache)
                 _this.repCache.set(dataProvider, (dpCache = new Map()));

package/src/data-interfaces.d.ts

@@ -76,3 +76,11 @@ export declare class EntityError<entityType = unknown> extends Error implements
     exception?: any;
     httpStatusCode?: number;
 }
+export declare class DataProviderPromiseWrapper implements DataProvider {
+    private dataProvider;
+    constructor(dataProvider: Promise<DataProvider>);
+    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
+    isProxy?: boolean | undefined;
+}