remult 0.26.12-next.0 → 0.26.12-next.2

package/esm/remult-next.js

@@ -118,6 +118,6 @@ export function remultNextApp(options) {
         POST: handler,
         PUT: handler,
         DELETE: handler,
-        withRemult: (what) => result.withRemultAsync({}, what),
+        withRemult: (what, disableInitUserAndRequest) => result.withRemultAsync(disableInitUserAndRequest ? undefined : {}, what),
     };
 }

package/esm/remult-solid-start.js

@@ -86,8 +86,8 @@ export function remultSolidStart(options) {
     return Object.assign(handler, {
         getRemult: (req) => result.getRemult(req),
         openApiDoc: (options) => result.openApiDoc(options),
-        async withRemult(what) {
-            return result.withRemultAsync(await getRequestEvent(), what);
+        async withRemult(what, disableInitUserAndRequest) {
+            return result.withRemultAsync(disableInitUserAndRequest ? undefined : await getRequestEvent(), what);
         },
         GET: serverHandler,
         PUT: serverHandler,

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

@@ -105,15 +105,20 @@ export class RemultServerImplementation {
     withRemultAsync(request, what) {
         if (!request)
             return this.runWithRemult(what);
-        return new Promise((resolve, error) => {
-            return this.withRemult(request, undefined, () => {
-                try {
-                    what().then(resolve).catch(error);
-                }
-                catch (err) {
-                    error(err);
-                }
-            });
+        return new Promise(async (resolve, error) => {
+            try {
+                return await this.withRemult(request, undefined, async () => {
+                    try {
+                        what().then(resolve).catch(error);
+                    }
+                    catch (err) {
+                        error(err);
+                    }
+                });
+            }
+            catch (err) {
+                error(err);
+            }
         });
     }
     getEntities() {
@@ -146,9 +151,9 @@ export class RemultServerImplementation {
         throw new Error("Couldn't find entity " + entityKey);
     };
     subscriptionServer;
-    withRemult = (req, res, next) => {
-        this.process(async () => {
-            next();
+    withRemult = async (req, res, next) => {
+        await this.process(async () => {
+            await next();
         })(req, res);
     };
     routeImpl;
@@ -294,12 +299,12 @@ export class RemultServerImplementation {
                 if (!genReq.params)
                     genReq.params = req['_tempParams'];
             }
-            let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
-            if (remultStatic.asyncContext.isInInitRequest())
-                return await what(remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req);
-            else
-                try {
+            let myReq = new RequestBridgeToDataApiRequest(genReq);
+            let myRes = new ResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+            try {
+                if (remultStatic.asyncContext.isInInitRequest())
+                    return await what(remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req);
+                else
                     await this.runWithRemult(async (remult) => {
                         if (req) {
                             remultStatic.asyncContext.setInInitRequest(true);
@@ -332,10 +337,13 @@ export class RemultServerImplementation {
                         }
                         await what(remult, myReq, myRes, genReq, origRes, req);
                     });
-                }
-                catch (err) {
+            }
+            catch (err) {
+                if (origRes)
                     myRes.error(err, undefined);
-                }
+                else
+                    throw err;
+            }
         };
     }
     async getRemult(req) {
@@ -747,7 +755,7 @@ export class RemultServerImplementation {
     /* internal */
     backendMethodsOpenApi = [];
 }
-class ExpressRequestBridgeToDataApiRequest {
+class RequestBridgeToDataApiRequest {
     r;
     get(key) {
         return this.r?.query[key];
@@ -756,7 +764,7 @@ class ExpressRequestBridgeToDataApiRequest {
         this.r = r;
     }
 }
-class ExpressResponseBridgeToDataApiResponse {
+class ResponseBridgeToDataApiResponse {
     r;
     req;
     handleError;

package/esm/src/remult-static.js

@@ -25,6 +25,7 @@ if ((typeof process !== 'undefined' &&
     process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
     typeof globalThis[remultStaticKey] === 'undefined') {
     globalThis[remultStaticKey] = x;
+    x.remultFactory = () => defaultFactory();
 }
 else {
     x = globalThis[remultStaticKey];
@@ -39,4 +40,3 @@ export function defaultFactory() {
 export function resetFactory() {
     remultStatic.remultFactory = () => defaultFactory();
 }
-resetFactory();

package/esm/src/remult3/remult3.js

@@ -1,11 +1,10 @@
 export const flags = {
     error500RetryCount: 4,
 };
+//y1 TODO - discuss next auth withRemult paradox - the gift that keeps on giving - it's doing something crazy there!!
+//p1 - review starter and examples and separate remult * auth from the routes
+//p1 - https://github.com/remult/remult/discussions/438
 //y1 - live query with count #436
-//y1 - https://github.com/remult/remult/discussions/438
-//p1 - discuss next auth withRemult paradox
-//p1 - maybe the default withRemult should by default use the data provider set by the remultExpress
-//p1 - withRemult to support the full  range of data provider.
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
 //y1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
 //y1 TODO -  readonly key: keyof MembersOnly<entityType> & string
@@ -24,7 +23,6 @@ const result = await repo.batch(x=>({
   count:x.count()
 }))
 */
-//p1 - consider in json storage, to store the json without spaces
 //p1 - consider upsert (where,set)
 //y1 - wait a second to close stream -see pr
 //p1 - Consider enforcing serial operations on JSON database to prevent data loss

package/package.json

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

package/remult-next.d.ts

@@ -22,5 +22,5 @@ export type RemultNextAppServer = RemultServerCore<Request> & {
     PUT: (req: Request) => Promise<Response>;
     POST: (req: Request) => Promise<Response>;
     DELETE: (req: Request) => Promise<Response>;
-    withRemult<T>(what: () => Promise<T>): Promise<T>;
+    withRemult<T>(what: () => Promise<T>, disableInitUserAndRequest?: boolean): Promise<T>;
 };

package/remult-next.js

@@ -174,7 +174,9 @@ function remultNextApp(options) {
         POST: handler,
         PUT: handler,
         DELETE: handler,
-        withRemult: function (what) { return result.withRemultAsync({}, what); },
+        withRemult: function (what, disableInitUserAndRequest) {
+            return result.withRemultAsync(disableInitUserAndRequest ? undefined : {}, what);
+        },
     };
 }
 exports.remultNextApp = remultNextApp;

package/remult-solid-start.d.ts

@@ -3,7 +3,7 @@ import type { RemultServerCore, RemultServerOptions } from './server/index.js';
 export declare function remultSolidStart(options: RemultServerOptions<RequestEvent>): RemultSolidStartServer;
 type RequestHandler = (event: RequestEvent) => Promise<Response>;
 export type RemultSolidStartServer = RemultServerCore<RequestEvent> & {
-    withRemult<T>(what: () => Promise<T>): Promise<T>;
+    withRemult<T>(what: () => Promise<T>, disableInitUserAndRequest?: boolean): Promise<T>;
     GET: RequestHandler;
     PUT: RequestHandler;
     POST: RequestHandler;

package/remult-solid-start.js

@@ -112,15 +112,21 @@ function remultSolidStart(options) {
     return Object.assign(handler, {
         getRemult: function (req) { return result.getRemult(req); },
         openApiDoc: function (options) { return result.openApiDoc(options); },
-        withRemult: function (what) {
+        withRemult: function (what, disableInitUserAndRequest) {
             return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var _a, _b;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
+                var _a, _b, _c;
+                return tslib_1.__generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             _b = (_a = result).withRemultAsync;
-                            return [4 /*yield*/, (0, web_1.getRequestEvent)()];
-                        case 1: return [2 /*return*/, _b.apply(_a, [_c.sent(), what])];
+                            if (!disableInitUserAndRequest) return [3 /*break*/, 1];
+                            _c = undefined;
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, (0, web_1.getRequestEvent)()];
+                        case 2:
+                            _c = _d.sent();
+                            _d.label = 3;
+                        case 3: return [2 /*return*/, _b.apply(_a, [_c, what])];
                     }
                 });
             });

package/server/remult-api-server.js

@@ -143,14 +143,26 @@ var RemultServerImplementation = /** @class */ (function () {
                 }
             });
         }); };
-        this.withRemult = function (req, res, next) {
-            _this.process(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                return tslib_1.__generator(this, function (_a) {
-                    next();
-                    return [2 /*return*/];
-                });
-            }); })(req, res);
-        };
+        this.withRemult = function (req, res, next) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.process(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*/, next()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })(req, res)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -241,16 +253,33 @@ var RemultServerImplementation = /** @class */ (function () {
         var _this = this;
         if (!request)
             return this.runWithRemult(what);
-        return new Promise(function (resolve, error) {
-            return _this.withRemult(request, undefined, function () {
-                try {
-                    what().then(resolve).catch(error);
-                }
-                catch (err) {
-                    error(err);
+        return new Promise(function (resolve, error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var err_1;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.withRemult(request, undefined, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    try {
+                                        what().then(resolve).catch(error);
+                                    }
+                                    catch (err) {
+                                        error(err);
+                                    }
+                                    return [2 /*return*/];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        err_1 = _a.sent();
+                        error(err_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
                 }
             });
-        });
+        }); });
     };
     RemultServerImplementation.prototype.getEntities = function () {
         //TODO V2 - consider using entitiesMetaData - but it may require making it all awaitable
@@ -536,7 +565,7 @@ var RemultServerImplementation = /** @class */ (function () {
     RemultServerImplementation.prototype.process = function (what) {
         var _this = this;
         return function (req, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var genReq, myReq, myRes, err_1;
+            var genReq, myReq, myRes, err_2;
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
@@ -551,69 +580,74 @@ var RemultServerImplementation = /** @class */ (function () {
                             if (!genReq.params)
                                 genReq.params = req['_tempParams'];
                         }
-                        myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-                        myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
-                        if (!remult_static_js_1.remultStatic.asyncContext.isInInitRequest()) return [3 /*break*/, 2];
+                        myReq = new RequestBridgeToDataApiRequest(genReq);
+                        myRes = new ResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        if (!remult_static_js_1.remultStatic.asyncContext.isInInitRequest()) return [3 /*break*/, 3];
                         return [4 /*yield*/, what(remult_static_js_1.remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.runWithRemult(function (remult) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var user;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!req) return [3 /*break*/, 8];
-                                            remult_static_js_1.remultStatic.asyncContext.setInInitRequest(true);
-                                            _a.label = 1;
-                                        case 1:
-                                            _a.trys.push([1, , 7, 8]);
-                                            user = void 0;
-                                            if (!this.options.getUser) return [3 /*break*/, 3];
-                                            return [4 /*yield*/, this.options.getUser(req)];
-                                        case 2:
-                                            user = _a.sent();
-                                            return [3 /*break*/, 4];
-                                        case 3:
-                                            user = req['user'];
-                                            if (!user)
-                                                user = req['auth'];
-                                            _a.label = 4;
-                                        case 4:
-                                            if (user)
-                                                remult.user = user;
-                                            if (!this.options.initRequest) return [3 /*break*/, 6];
-                                            return [4 /*yield*/, this.options.initRequest(req, {
-                                                    remult: remult,
-                                                    get liveQueryStorage() {
-                                                        return remult.liveQueryStorage;
-                                                    },
-                                                    set liveQueryStorage(value) {
-                                                        remult.liveQueryStorage = value;
-                                                    },
-                                                })];
-                                        case 5:
-                                            _a.sent();
-                                            _a.label = 6;
-                                        case 6: return [3 /*break*/, 8];
-                                        case 7:
-                                            remult_static_js_1.remultStatic.asyncContext.setInInitRequest(false);
-                                            return [7 /*endfinally*/];
-                                        case 8: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
-                                        case 9:
-                                            _a.sent();
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 3:
-                        _a.sent();
-                        return [3 /*break*/, 5];
+                    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 () {
+                            var user;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!req) return [3 /*break*/, 8];
+                                        remult_static_js_1.remultStatic.asyncContext.setInInitRequest(true);
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, , 7, 8]);
+                                        user = void 0;
+                                        if (!this.options.getUser) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.options.getUser(req)];
+                                    case 2:
+                                        user = _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        user = req['user'];
+                                        if (!user)
+                                            user = req['auth'];
+                                        _a.label = 4;
+                                    case 4:
+                                        if (user)
+                                            remult.user = user;
+                                        if (!this.options.initRequest) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, this.options.initRequest(req, {
+                                                remult: remult,
+                                                get liveQueryStorage() {
+                                                    return remult.liveQueryStorage;
+                                                },
+                                                set liveQueryStorage(value) {
+                                                    remult.liveQueryStorage = value;
+                                                },
+                                            })];
+                                    case 5:
+                                        _a.sent();
+                                        _a.label = 6;
+                                    case 6: return [3 /*break*/, 8];
+                                    case 7:
+                                        remult_static_js_1.remultStatic.asyncContext.setInInitRequest(false);
+                                        return [7 /*endfinally*/];
+                                    case 8: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
+                                    case 9:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
                     case 4:
-                        err_1 = _a.sent();
-                        myRes.error(err_1, undefined);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _a.sent();
+                        if (origRes)
+                            myRes.error(err_2, undefined);
+                        else
+                            throw err_2;
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
                 }
             });
         }); };
@@ -1071,42 +1105,42 @@ var RemultServerImplementation = /** @class */ (function () {
     return RemultServerImplementation;
 }());
 exports.RemultServerImplementation = RemultServerImplementation;
-var ExpressRequestBridgeToDataApiRequest = /** @class */ (function () {
-    function ExpressRequestBridgeToDataApiRequest(r) {
+var RequestBridgeToDataApiRequest = /** @class */ (function () {
+    function RequestBridgeToDataApiRequest(r) {
         this.r = r;
     }
-    ExpressRequestBridgeToDataApiRequest.prototype.get = function (key) {
+    RequestBridgeToDataApiRequest.prototype.get = function (key) {
         var _a;
         return (_a = this.r) === null || _a === void 0 ? void 0 : _a.query[key];
     };
-    return ExpressRequestBridgeToDataApiRequest;
+    return RequestBridgeToDataApiRequest;
 }());
-var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
-    function ExpressResponseBridgeToDataApiResponse(r, req, handleError) {
+var ResponseBridgeToDataApiResponse = /** @class */ (function () {
+    function ResponseBridgeToDataApiResponse(r, req, handleError) {
         this.r = r;
         this.req = req;
         this.handleError = handleError;
     }
-    ExpressResponseBridgeToDataApiResponse.prototype.forbidden = function () {
+    ResponseBridgeToDataApiResponse.prototype.forbidden = function () {
         this.error({ message: 'Forbidden' }, undefined, 403);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.setStatus = function (status) {
+    ResponseBridgeToDataApiResponse.prototype.setStatus = function (status) {
         return this.r.status(status);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.progress = function (progress) { };
-    ExpressResponseBridgeToDataApiResponse.prototype.success = function (data) {
+    ResponseBridgeToDataApiResponse.prototype.progress = function (progress) { };
+    ResponseBridgeToDataApiResponse.prototype.success = function (data) {
         this.r.json(data);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.created = function (data) {
+    ResponseBridgeToDataApiResponse.prototype.created = function (data) {
         this.setStatus(201).json(data);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.deleted = function () {
+    ResponseBridgeToDataApiResponse.prototype.deleted = function () {
         this.setStatus(204).end();
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.notFound = function () {
+    ResponseBridgeToDataApiResponse.prototype.notFound = function () {
         this.error({ message: 'NotFound' }, undefined, 404);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
+    ResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var data, responseSent, sendError;
@@ -1164,7 +1198,7 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
             });
         });
     };
-    return ExpressResponseBridgeToDataApiResponse;
+    return ResponseBridgeToDataApiResponse;
 }());
 var inProcessQueueHandler = /** @class */ (function () {
     function inProcessQueueHandler(storage) {

package/src/remult-static.js

@@ -28,6 +28,7 @@ if ((typeof process !== 'undefined' &&
     process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
     typeof globalThis[remultStaticKey] === 'undefined') {
     globalThis[remultStaticKey] = x;
+    x.remultFactory = function () { return defaultFactory(); };
 }
 else {
     x = globalThis[remultStaticKey];
@@ -44,4 +45,3 @@ function resetFactory() {
     exports.remultStatic.remultFactory = function () { return defaultFactory(); };
 }
 exports.resetFactory = resetFactory;
-resetFactory();

package/src/remult3/remult3.js

@@ -4,11 +4,10 @@ exports.flags = void 0;
 exports.flags = {
     error500RetryCount: 4,
 };
+//y1 TODO - discuss next auth withRemult paradox - the gift that keeps on giving - it's doing something crazy there!!
+//p1 - review starter and examples and separate remult * auth from the routes
+//p1 - https://github.com/remult/remult/discussions/438
 //y1 - live query with count #436
-//y1 - https://github.com/remult/remult/discussions/438
-//p1 - discuss next auth withRemult paradox
-//p1 - maybe the default withRemult should by default use the data provider set by the remultExpress
-//p1 - withRemult to support the full  range of data provider.
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
 //y1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
 //y1 TODO -  readonly key: keyof MembersOnly<entityType> & string
@@ -27,7 +26,6 @@ const result = await repo.batch(x=>({
   count:x.count()
 }))
 */
-//p1 - consider in json storage, to store the json without spaces
 //p1 - consider upsert (where,set)
 //y1 - wait a second to close stream -see pr
 //p1 - Consider enforcing serial operations on JSON database to prevent data loss