remult 0.20.0-exp.1 → 0.20.0-exp.10

package/esm/remult-next.js

@@ -3,7 +3,7 @@ export function remultNext(options) {
     let result = createRemultServer(options, {
         buildGenericRequest: req => req
     });
-    return Object.assign((req, res) => result.handle(req, res), result, {
+    return Object.assign((req, res) => result.handle(req, res).then(() => { }), result, {
         getRemult: (...args) => result.getRemult(...args),
         handle: (...args) => result.handle(...args),
         openApiDoc: (...args) => result.openApiDoc(...args),

package/esm/remult-sveltekit.d.ts

@@ -0,0 +1,3 @@
+import type { RequestEvent, Handle } from '@sveltejs/kit';
+import { RemultServer, RemultServerOptions } from './server';
+export declare function remultSveltekit(options?: RemultServerOptions<RequestEvent>): RemultServer<RequestEvent> & Handle;

package/esm/remult-sveltekit.js

@@ -0,0 +1,83 @@
+import { createRemultServer } from './server';
+export function remultSveltekit(options) {
+    let result = createRemultServer(options, {
+        buildGenericRequest: event => ({
+            url: event.request.url,
+            method: event.request.method,
+            body: event.locals["_tempJson"],
+            on: (e, do1) => {
+                if (e === 'close') {
+                    event.locals["_tempOnClose"] = do1;
+                }
+            }
+        })
+    });
+    const handler = async ({ event, resolve }) => {
+        if (event.url.pathname.startsWith(options.rootPath)) {
+            let json = {};
+            try {
+                if (event.request.method == 'POST' || event.request.method == 'PUT') {
+                    json = await event.request.json();
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            let sseResponse = undefined;
+            event.locals["_tempOnClose"] = () => { };
+            const response = {
+                end: () => { },
+                json: () => { },
+                status: () => {
+                    return response;
+                },
+                write: () => { },
+                writeHead: (status, headers) => {
+                    if (status === 200 && headers) {
+                        const contentType = headers['Content-Type'];
+                        if (contentType === 'text/event-stream') {
+                            const messages = [];
+                            response.write = (x) => messages.push(x);
+                            const stream = new ReadableStream({
+                                start: (controller) => {
+                                    for (const message of messages) {
+                                        controller.enqueue(message);
+                                    }
+                                    response.write = (data) => {
+                                        controller.enqueue(data);
+                                    };
+                                },
+                                cancel: () => {
+                                    response.write = () => { };
+                                    event.locals["_tempOnClose"]();
+                                }
+                            });
+                            sseResponse = new Response(stream, { headers });
+                        }
+                    }
+                }
+            };
+            event.locals["_tempJson"] = json;
+            const responseFromRemultHandler = await result.handle(event, response);
+            if (sseResponse !== undefined) {
+                return sseResponse;
+            }
+            if (responseFromRemultHandler) {
+                return new Response(JSON.stringify(responseFromRemultHandler.data), {
+                    status: responseFromRemultHandler.statusCode
+                });
+            }
+        }
+        return new Promise((res) => {
+            result.withRemult(event, undefined, async () => {
+                res(await resolve(event));
+            });
+        });
+    };
+    return Object.assign(handler, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        registerRouter: x => result.registerRouter(x),
+        withRemult: (...args) => result.withRemult(...args)
+    });
+}

package/esm/server/expressBridge.js

@@ -255,7 +255,13 @@ export class RemultServerImplementation {
     }
     process(what) {
         return async (req, origRes) => {
-            let myReq = new ExpressRequestBridgeToDataApiRequest(req);
+            const genReq = this.coreOptions.buildGenericRequest(req);
+            if (!genReq.query) {
+                genReq.query = req["_tempQuery"];
+            }
+            if (!genReq.params)
+                genReq.params = req["_tempParams"];
+            let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
             let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
             await this.runWithRemult(async (remult) => {
                 remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
@@ -285,7 +291,7 @@ export class RemultServerImplementation {
                         });
                     }
                 }
-                await what(remult, myReq, myRes, req, origRes);
+                await what(remult, myReq, myRes, genReq, origRes);
             });
         };
     }
@@ -871,6 +877,7 @@ class RouteImplementation {
                 }
                 query[key] = [current, val];
             });
+            origReq["_tempQuery"] = query;
             req.query = query;
         }
         let lowerPath = path.toLowerCase();
@@ -878,7 +885,7 @@ class RouteImplementation {
         if (m) {
             let h = m.get(req.method.toLowerCase());
             if (h) {
-                h(req, res, next);
+                h(origReq, res, next);
                 return;
             }
         }
@@ -889,10 +896,12 @@ class RouteImplementation {
             if (m) {
                 let h = m.get(req.method.toLowerCase());
                 if (h) {
-                    if (!req.params)
+                    if (!req.params) {
                         req.params = {};
+                        origReq["_tempParams"] = req.params;
+                    }
                     req.params.id = path.substring(idPosition + 1);
-                    h(req, res, next);
+                    h(origReq, res, next);
                     return;
                 }
             }

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

@@ -15,7 +15,7 @@ export declare class DataApi<T = any> {
         findOptions: FindOptions<T>;
     }>;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any, queryChannel: string): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;

package/esm/src/data-api.js

@@ -128,7 +128,7 @@ export class DataApi {
         try {
             const r = await this.getArrayImpl(response, request, filterBody);
             const data = {
-                requestJson: serializeRequest(),
+                requestJson: await serializeRequest(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
                 lastIds: r.r.map(y => this.repository.metadata.idMetadata.getId(y))
             };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.20.0-exp.1",
+    "version": "0.20.0-exp.10",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

package/remult-next.js

@@ -8,7 +8,7 @@ function remultNext(options) {
     var result = server_1.createRemultServer(options, {
         buildGenericRequest: function (req) { return req; }
     });
-    return Object.assign(function (req, res) { return result.handle(req, res); }, result, {
+    return Object.assign(function (req, res) { return result.handle(req, res).then(function () { }); }, result, {
         getRemult: function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {

package/remult-sveltekit.d.ts

@@ -0,0 +1,3 @@
+import type { RequestEvent, Handle } from '@sveltejs/kit';
+import { RemultServer, RemultServerOptions } from './server';
+export declare function remultSveltekit(options?: RemultServerOptions<RequestEvent>): RemultServer<RequestEvent> & Handle;

package/remult-sveltekit.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultSveltekit = void 0;
+var tslib_1 = require("tslib");
+var server_1 = require("./server");
+function remultSveltekit(options) {
+    var _this = this;
+    var result = server_1.createRemultServer(options, {
+        buildGenericRequest: function (event) {
+            return ({
+                url: event.request.url,
+                method: event.request.method,
+                body: event.locals["_tempJson"],
+                on: function (e, do1) {
+                    if (e === 'close') {
+                        event.locals["_tempOnClose"] = do1;
+                    }
+                }
+            });
+        }
+    });
+    var handler = function (_a) {
+        var event = _a.event, resolve = _a.resolve;
+        return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var json, error_1, sseResponse_1, response_1, responseFromRemultHandler;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!event.url.pathname.startsWith(options.rootPath)) return [3 /*break*/, 7];
+                        json = {};
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        if (!(event.request.method == 'POST' || event.request.method == 'PUT')) return [3 /*break*/, 3];
+                        return [4 /*yield*/, event.request.json()];
+                    case 2:
+                        json = _b.sent();
+                        _b.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _b.sent();
+                        console.log(error_1);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        sseResponse_1 = undefined;
+                        event.locals["_tempOnClose"] = function () { };
+                        response_1 = {
+                            end: function () { },
+                            json: function () { },
+                            status: function () {
+                                return response_1;
+                            },
+                            write: function () { },
+                            writeHead: function (status, headers) {
+                                if (status === 200 && headers) {
+                                    var contentType = headers['Content-Type'];
+                                    if (contentType === 'text/event-stream') {
+                                        var messages_1 = [];
+                                        response_1.write = function (x) { return messages_1.push(x); };
+                                        var stream = new ReadableStream({
+                                            start: function (controller) {
+                                                var e_1, _a;
+                                                try {
+                                                    for (var messages_2 = tslib_1.__values(messages_1), messages_2_1 = messages_2.next(); !messages_2_1.done; messages_2_1 = messages_2.next()) {
+                                                        var message = messages_2_1.value;
+                                                        controller.enqueue(message);
+                                                    }
+                                                }
+                                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (messages_2_1 && !messages_2_1.done && (_a = messages_2.return)) _a.call(messages_2);
+                                                    }
+                                                    finally { if (e_1) throw e_1.error; }
+                                                }
+                                                response_1.write = function (data) {
+                                                    controller.enqueue(data);
+                                                };
+                                            },
+                                            cancel: function () {
+                                                response_1.write = function () { };
+                                                event.locals["_tempOnClose"]();
+                                            }
+                                        });
+                                        sseResponse_1 = new Response(stream, { headers: headers });
+                                    }
+                                }
+                            }
+                        };
+                        event.locals["_tempJson"] = json;
+                        return [4 /*yield*/, result.handle(event, response_1)];
+                    case 6:
+                        responseFromRemultHandler = _b.sent();
+                        if (sseResponse_1 !== undefined) {
+                            return [2 /*return*/, sseResponse_1];
+                        }
+                        if (responseFromRemultHandler) {
+                            return [2 /*return*/, new Response(JSON.stringify(responseFromRemultHandler.data), {
+                                    status: responseFromRemultHandler.statusCode
+                                })];
+                        }
+                        _b.label = 7;
+                    case 7: 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 Object.assign(handler, {
+        getRemult: function (req) { return result.getRemult(req); },
+        openApiDoc: function (options) { return result.openApiDoc(options); },
+        registerRouter: function (x) { return result.registerRouter(x); },
+        withRemult: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return result.withRemult.apply(result, tslib_1.__spread(args));
+        }
+    });
+}
+exports.remultSveltekit = remultSveltekit;

package/server/expressBridge.js

@@ -472,12 +472,18 @@ 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 myReq, myRes;
+            var genReq, myReq, myRes;
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        myReq = new ExpressRequestBridgeToDataApiRequest(req);
+                        genReq = this.coreOptions.buildGenericRequest(req);
+                        if (!genReq.query) {
+                            genReq.query = req["_tempQuery"];
+                        }
+                        if (!genReq.params)
+                            genReq.params = req["_tempParams"];
+                        myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
                         myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
                         return [4 /*yield*/, this.runWithRemult(function (remult) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _a, user;
@@ -519,7 +525,7 @@ var RemultServerImplementation = /** @class */ (function () {
                                         case 5:
                                             _b.sent();
                                             _b.label = 6;
-                                        case 6: return [4 /*yield*/, what(remult, myReq, myRes, req, origRes)];
+                                        case 6: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes)];
                                         case 7:
                                             _b.sent();
                                             return [2 /*return*/];
@@ -1245,6 +1251,7 @@ var RouteImplementation = /** @class */ (function () {
                 }
                 query_1[key] = [current, val];
             });
+            origReq["_tempQuery"] = query_1;
             req.query = query_1;
         }
         var lowerPath = path.toLowerCase();
@@ -1252,7 +1259,7 @@ var RouteImplementation = /** @class */ (function () {
         if (m) {
             var h = m.get(req.method.toLowerCase());
             if (h) {
-                h(req, res, next);
+                h(origReq, res, next);
                 return;
             }
         }
@@ -1263,10 +1270,12 @@ var RouteImplementation = /** @class */ (function () {
             if (m) {
                 var h = m.get(req.method.toLowerCase());
                 if (h) {
-                    if (!req.params)
+                    if (!req.params) {
                         req.params = {};
+                        origReq["_tempParams"] = req.params;
+                    }
                     req.params.id = path.substring(idPosition + 1);
-                    h(req, res, next);
+                    h(origReq, res, next);
                     return;
                 }
             }

package/src/data-api.d.ts

@@ -15,7 +15,7 @@ export declare class DataApi<T = any> {
         findOptions: FindOptions<T>;
     }>;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any, queryChannel: string): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;

package/src/data-api.js

@@ -210,42 +210,45 @@ var DataApi = /** @class */ (function () {
     DataApi.prototype.liveQuery = function (response, request, filterBody, serializeRequest, queryChannel) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var r, data, err_3;
+            var _a;
             var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         if (!this.repository.metadata.apiReadAllowed) {
                             response.forbidden();
                             return [2 /*return*/];
                         }
-                        _a.label = 1;
+                        _b.label = 1;
                     case 1:
-                        _a.trys.push([1, 4, , 5]);
+                        _b.trys.push([1, 5, , 6]);
                         return [4 /*yield*/, this.getArrayImpl(response, request, filterBody)];
                     case 2:
-                        r = _a.sent();
-                        data = {
-                            requestJson: serializeRequest(),
-                            findOptionsJson: rest_data_provider_1.findOptionsToJson(r.findOptions, this.repository.metadata),
-                            lastIds: r.r.map(function (y) { return _this.repository.metadata.idMetadata.getId(y); })
-                        };
+                        r = _b.sent();
+                        _a = {};
+                        return [4 /*yield*/, serializeRequest()];
+                    case 3:
+                        data = (_a.requestJson = _b.sent(),
+                            _a.findOptionsJson = rest_data_provider_1.findOptionsToJson(r.findOptions, this.repository.metadata),
+                            _a.lastIds = r.r.map(function (y) { return _this.repository.metadata.idMetadata.getId(y); }),
+                            _a);
                         return [4 /*yield*/, this.remult.liveQueryStorage.add({
                                 entityKey: this.repository.metadata.key,
                                 id: queryChannel,
                                 data: data
                             })];
-                    case 3:
-                        _a.sent();
-                        response.success(r.r);
-                        return [3 /*break*/, 5];
                     case 4:
-                        err_3 = _a.sent();
+                        _b.sent();
+                        response.success(r.r);
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_3 = _b.sent();
                         if (err_3.isForbiddenError)
                             response.forbidden();
                         else
                             response.error(err_3);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
                 }
             });
         });