remult 0.19.2 → 0.20.0-exp.1

package/remult-fastify.js

@@ -34,7 +34,9 @@ function remultFastify(options) {
         };
         return response;
     }
-    var api = index_1.createRemultServer(options);
+    var api = index_1.createRemultServer(options, {
+        buildGenericRequest: function (req) { return req; }
+    });
     var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {

package/remult-fresh.d.ts

@@ -1,8 +1,8 @@
-import { RemultServerOptions, GenericRequest } from "./server/expressBridge";
+import { RemultServerOptions } from "./server/expressBridge";
 import { Remult } from "./src/context";
-export declare function remultFresh<RequestType extends GenericRequest>(options: RemultServerOptions<RequestType>, response: FreshResponse): RemultFresh;
+export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
 export interface RemultFresh {
-    getRemult(req: GenericRequest): Promise<Remult>;
+    getRemult(req: FreshRequest): Promise<Remult>;
     openApiDoc(options: {
         title: string;
     }): any;

package/remult-fresh.js

@@ -5,7 +5,9 @@ var tslib_1 = require("tslib");
 var expressBridge_1 = require("./server/expressBridge");
 function remultFresh(options, response) {
     var _this = this;
-    var server = expressBridge_1.createRemultServerCore(options);
+    var server = expressBridge_1.createRemultServerCore(options, {
+        buildGenericRequest: function (r) { return r; }
+    });
     return {
         getRemult: function (r) { return server.getRemult(r); },
         openApiDoc: function (x) { return server.openApiDoc(x); },
@@ -33,7 +35,7 @@ function remultFresh(options, response) {
                         return [3 /*break*/, 3];
                     case 3:
                         init = {};
-                        return [4 /*yield*/, server.handle(theReq)];
+                        return [4 /*yield*/, server.handle(req)];
                     case 4:
                         res = _c.sent();
                         if (res) {

package/remult-next.d.ts

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

package/remult-next.js

@@ -5,7 +5,9 @@ var tslib_1 = require("tslib");
 var server_1 = require("./server");
 function remultNext(options) {
     var _this = this;
-    var result = server_1.createRemultServer(options);
+    var result = server_1.createRemultServer(options, {
+        buildGenericRequest: function (req) { return req; }
+    });
     return Object.assign(function (req, res) { return result.handle(req, res); }, result, {
         getRemult: function () {
             var args = [];

package/remult-svletekit.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-svletekit.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.d.ts

@@ -5,7 +5,7 @@ import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
-export interface RemultServerOptions<RequestType extends GenericRequest> {
+export interface RemultServerOptions<RequestType> {
     /**Entities to use for the api */
     entities?: ClassType<any>[];
     /**Controller to use for the api */
@@ -41,10 +41,10 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     subscriptionServer?: SubscriptionServer;
     /** A storage to use to store live queries, relevant mostly for serverless scenarios or larger scales */
     liveQueryStorage?: LiveQueryStorage;
-    /** Used to store the relevent request info for re running a live query */
-    requestSerializer?: {
-        toJson: (request: RequestType) => any;
-        fromJson: (request: any) => RequestType;
+    /** Used to store the context relevant info for re running a live query */
+    contextSerializer?: {
+        serialize(remult: Remult): Promise<any>;
+        deserialize(json: any, remult: Remult): Promise<void>;
     };
     /** Storage to use for backend methods that use queue */
     queueStorage?: QueueStorage;
@@ -53,21 +53,21 @@ export interface InitRequestOptions {
     liveQueryStorage: LiveQueryStorage;
     readonly remult: Remult;
 }
-export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServerCore<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions: ServerCoreOptions<RequestType>): RemultServer<RequestType>;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
     statusCode: number;
 }
-export interface RemultServer {
-    getRemult(req: GenericRequest): Promise<Remult>;
+export interface RemultServer<RequestType> {
+    getRemult(req: RequestType): Promise<Remult>;
     openApiDoc(options: {
         title: string;
         version?: string;
     }): any;
     registerRouter(r: GenericRouter): void;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemult(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
+    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;
@@ -128,3 +128,6 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
+export interface ServerCoreOptions<RequestType> {
+    buildGenericRequest(req: RequestType): GenericRequest;
+}