remult 0.27.21 → 0.27.22-next.1

package/esm/remult-sveltekit.js

@@ -71,16 +71,7 @@ export function remultSveltekit(options) {
         });
     };
     const handler = async ({ event, resolve }) => {
-        if (event.url.pathname.startsWith(options.rootPath)) {
-            const result = await serverHandler(event);
-            if (result != null && result?.status != 404)
-                return result;
-        }
-        return new Promise((res) => {
-            result.withRemult(event, undefined, async () => {
-                res(await resolve(event));
-            });
-        });
+        return result.withRemultAsync(event, async () => await resolve(event));
     };
     return Object.assign(handler, {
         getRemult: (req) => result.getRemult(req),
@@ -88,6 +79,7 @@ export function remultSveltekit(options) {
         withRemult(request, what) {
             return result.withRemultAsync(request, what);
         },
+        hookHandler: handler,
         GET: serverHandler,
         PUT: serverHandler,
         POST: serverHandler,

package/esm/server/initAsyncHooks.js

@@ -37,55 +37,6 @@ export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
         return this.asyncLocalStorage.getStore();
     }
 }
-const ignoreInStack = [
-    'AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run',
-    'RemultAsyncLocalStorage.run',
-    'Module.withRemult',
-    'RemultServerImplementation.runWithRemult',
-];
-export class SequentialRemultAsyncLocalStorageCore {
-    wasImplemented = 'yes';
-    async run(store, callback) {
-        let log = (msg) => { };
-        if (false) {
-            let stack = new Error().stack;
-            let y = stack.split('\n');
-            while (y.length > 0 &&
-                (y[0].trim().startsWith('Error') ||
-                    ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
-                y.splice(0, 1);
-            }
-            stack = y.join('\n');
-            log = (msg) => {
-                console.log(msg, stack);
-            };
-        }
-        log('waiting on ');
-        const nextPromise = this.lastPromise.then(async () => {
-            log('executing  ');
-            const previousValue = this.currentValue;
-            this.currentValue = store;
-            const result = await callback();
-            this.currentValue = previousValue;
-            return result;
-        });
-        this.lastPromise = nextPromise.catch(() => {
-            log('Error on ');
-            return undefined;
-        });
-        try {
-            return await nextPromise;
-        }
-        finally {
-            log('completed  ');
-        }
-    }
-    getStore() {
-        return this.currentValue;
-    }
-    lastPromise = Promise.resolve(undefined);
-    currentValue;
-}
 export class StubRemultAsyncLocalStorageCore {
     isStub = true;
     wasImplemented = 'yes';

package/esm/server/remult-api-server.js

@@ -154,7 +154,7 @@ export class RemultServerImplementation {
     withRemult = async (req, res, next) => {
         await this.process(async () => {
             await next();
-        })(req, res);
+        }, true)(req, res);
     };
     routeImpl;
     getRouteImpl() {
@@ -293,7 +293,7 @@ export class RemultServerImplementation {
             dataProvider: dataProvider,
         });
     }
-    process(what) {
+    process(what, doNotReuseInitRequest) {
         return async (req, origRes) => {
             const genReq = req ? this.coreOptions.buildGenericRequestInfo(req) : {};
             if (req) {
@@ -306,7 +306,8 @@ export class RemultServerImplementation {
             let myReq = new RequestBridgeToDataApiRequest(genReq);
             let myRes = new ResponseBridgeToDataApiResponse(origRes, req, genReq, this.options.error);
             try {
-                if (remultStatic.asyncContext.isInInitRequest())
+                if (remultStatic.asyncContext.isInInitRequest() &&
+                    !doNotReuseInitRequest)
                     return await what(remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req);
                 else
                     await this.runWithRemult(async (remult) => {

package/esm/src/context.js

@@ -140,6 +140,11 @@ export class Remult {
             return this.isAllowed(allowed);
         return undefined;
     }
+    useFetch(fetch) {
+        this.dataProvider = new RestDataProvider(() => ({
+            httpClient: fetch,
+        }));
+    }
     /** The current data provider */
     dataProvider = new RestDataProvider(() => this.apiClient);
     /* @internal */

package/esm/src/remult-proxy.js

@@ -59,6 +59,9 @@ export class RemultProxy {
     clearAllCache() {
         return remultStatic.remultFactory().clearAllCache();
     }
+    useFetch(args) {
+        return remultStatic.remultFactory().useFetch(args);
+    }
     repoCache = new Map();
     //@ts-ignore
     repo = (...args) => {

package/package.json

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

package/remult-sveltekit.js

@@ -95,35 +95,15 @@ function remultSveltekit(options) {
         });
     }); };
     var handler = function (_a) { return tslib_1.__awaiter(_this, [_a], void 0, function (_b) {
-        var result_1;
         var _this = this;
         var event = _b.event, resolve = _b.resolve;
         return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!event.url.pathname.startsWith(options.rootPath)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, serverHandler(event)];
-                case 1:
-                    result_1 = _c.sent();
-                    if (result_1 != null && (result_1 === null || result_1 === void 0 ? void 0 : result_1.status) != 404)
-                        return [2 /*return*/, result_1];
-                    _c.label = 2;
-                case 2: return [2 /*return*/, new Promise(function (res) {
-                        result.withRemult(event, undefined, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var _a;
-                            return tslib_1.__generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        _a = res;
-                                        return [4 /*yield*/, resolve(event)];
-                                    case 1:
-                                        _a.apply(void 0, [_b.sent()]);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                    })];
-            }
+            return [2 /*return*/, result.withRemultAsync(event, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, resolve(event)];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                }); }); })];
         });
     }); };
     return Object.assign(handler, {
@@ -132,6 +112,7 @@ function remultSveltekit(options) {
         withRemult: function (request, what) {
             return result.withRemultAsync(request, what);
         },
+        hookHandler: handler,
         GET: serverHandler,
         PUT: serverHandler,
         POST: serverHandler,

package/server/initAsyncHooks.d.ts

@@ -6,13 +6,6 @@ export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T>
     run<R>(store: T, callback: () => Promise<R>): Promise<R>;
     getStore(): T | undefined;
 }
-export declare class SequentialRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
-    wasImplemented: "yes";
-    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
-    getStore(): T | undefined;
-    lastPromise: Promise<T | undefined>;
-    currentValue?: T;
-}
 export declare class StubRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
     isStub: boolean;
     wasImplemented: "yes";

package/server/initAsyncHooks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.StubRemultAsyncLocalStorageCore = exports.SequentialRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = void 0;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.StubRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = void 0;
 exports.initAsyncHooks = initAsyncHooks;
 var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
@@ -66,78 +66,6 @@ var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (fu
     return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
 }());
 exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
-var ignoreInStack = [
-    'AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run',
-    'RemultAsyncLocalStorage.run',
-    'Module.withRemult',
-    'RemultServerImplementation.runWithRemult',
-];
-var SequentialRemultAsyncLocalStorageCore = /** @class */ (function () {
-    function SequentialRemultAsyncLocalStorageCore() {
-        this.wasImplemented = 'yes';
-        this.lastPromise = Promise.resolve(undefined);
-    }
-    SequentialRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var log, stack_1, y, nextPromise;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        log = function (msg) { };
-                        if (false) {
-                            stack_1 = new Error().stack;
-                            y = stack_1.split('\n');
-                            while (y.length > 0 &&
-                                (y[0].trim().startsWith('Error') ||
-                                    ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
-                                y.splice(0, 1);
-                            }
-                            stack_1 = y.join('\n');
-                            log = function (msg) {
-                                console.log(msg, stack_1);
-                            };
-                        }
-                        log('waiting on ');
-                        nextPromise = this.lastPromise.then(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var previousValue, result;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        log('executing  ');
-                                        previousValue = this.currentValue;
-                                        this.currentValue = store;
-                                        return [4 /*yield*/, callback()];
-                                    case 1:
-                                        result = _a.sent();
-                                        this.currentValue = previousValue;
-                                        return [2 /*return*/, result];
-                                }
-                            });
-                        }); });
-                        this.lastPromise = nextPromise.catch(function () {
-                            log('Error on ');
-                            return undefined;
-                        });
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, nextPromise];
-                    case 2: return [2 /*return*/, _a.sent()];
-                    case 3:
-                        log('completed  ');
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SequentialRemultAsyncLocalStorageCore.prototype.getStore = function () {
-        return this.currentValue;
-    };
-    return SequentialRemultAsyncLocalStorageCore;
-}());
-exports.SequentialRemultAsyncLocalStorageCore = SequentialRemultAsyncLocalStorageCore;
 var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
     function StubRemultAsyncLocalStorageCore() {
         this.isStub = true;

package/server/remult-api-server.js

@@ -155,7 +155,7 @@ var RemultServerImplementation = /** @class */ (function () {
                                         return [2 /*return*/];
                                 }
                             });
-                        }); })(req, res)];
+                        }); }, true)(req, res)];
                     case 1:
                         _a.sent();
                         return [2 /*return*/];
@@ -574,7 +574,7 @@ var RemultServerImplementation = /** @class */ (function () {
             });
         });
     };
-    RemultServerImplementation.prototype.process = function (what) {
+    RemultServerImplementation.prototype.process = function (what, doNotReuseInitRequest) {
         var _this = this;
         return function (req, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var genReq, myReq, myRes, err_2;
@@ -595,7 +595,8 @@ var RemultServerImplementation = /** @class */ (function () {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 6, , 7]);
-                        if (!remult_static_js_1.remultStatic.asyncContext.isInInitRequest()) return [3 /*break*/, 3];
+                        if (!(remult_static_js_1.remultStatic.asyncContext.isInInitRequest() &&
+                            !doNotReuseInitRequest)) return [3 /*break*/, 3];
                         return [4 /*yield*/, what(remult_static_js_1.remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req)];
                     case 2: return [2 /*return*/, _a.sent()];
                     case 3: return [4 /*yield*/, this.runWithRemult(function (remult) { return tslib_1.__awaiter(_this, void 0, void 0, function () {

package/src/context.d.ts

@@ -59,6 +59,7 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
+    useFetch(fetch: ApiClient['httpClient']): void;
     /** The current data provider */
     dataProvider: DataProvider;
     /** Creates a new instance of the `remult` object.

package/src/context.js

@@ -230,6 +230,11 @@ var Remult = /** @class */ (function () {
             return this.isAllowed(allowed);
         return undefined;
     };
+    Remult.prototype.useFetch = function (fetch) {
+        this.dataProvider = new rest_data_provider_js_1.RestDataProvider(function () { return ({
+            httpClient: fetch,
+        }); });
+    };
     //@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

package/src/remult-proxy.js

@@ -333,6 +333,9 @@ var RemultProxy = /** @class */ (function () {
     RemultProxy.prototype.clearAllCache = function () {
         return remult_static_js_1.remultStatic.remultFactory().clearAllCache();
     };
+    RemultProxy.prototype.useFetch = function (args) {
+        return remult_static_js_1.remultStatic.remultFactory().useFetch(args);
+    };
     Object.defineProperty(RemultProxy.prototype, "user", {
         get: function () {
             return remult_static_js_1.remultStatic.remultFactory().user;