remult 0.20.0-exp.14 → 0.20.0-exp.16

package/esm/graphql.js

@@ -79,6 +79,7 @@ export function remultGraphql(api) {
             query += q;
             root[key] = async ({ options, filter }, req, a) => {
                 return new Promise(async (res, error) => {
+                    //TODO - consider this with remult usage
                     api.withRemult(req, undefined, async () => {
                         let remult = await api.getRemult(req);
                         let repo = remult.repo(e);

package/esm/remult-express.d.ts

@@ -1,6 +1,9 @@
 import * as express from 'express';
-import { RemultServer, RemultServerOptions } from './server/expressBridge';
+import { RemultServerCore, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): express.RequestHandler & RemultServer<express.Request>;
+}): RemultExpressServer;
+export declare type RemultExpressServer = express.RequestHandler & RemultServerCore<express.Request> & {
+    withRemult: (req: express.Request, res: express.Response, next: VoidFunction) => void;
+};

package/esm/remult-express.js

@@ -20,7 +20,6 @@ export function remultExpress(options) {
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
-        registerRouter: x => server.registerRouter(x),
         withRemult: (...args) => server.withRemult(...args)
     });
 }

package/esm/remult-fastify.d.ts

@@ -1,3 +1,6 @@
 import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
-import { RemultServer, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer<FastifyRequest>;
+import { RemultServerOptions, RemultServerCore } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
+export declare type RemultFastifyServer = FastifyPluginCallback & RemultServerCore<FastifyRequest> & {
+    withRemult<T>(req: FastifyRequest, what: () => Promise<T>): Promise<T>;
+};

package/esm/remult-fastify.js

@@ -61,7 +61,10 @@ export function remultFastify(options) {
     return Object.assign(pluginFunction, {
         getRemult: x => api.getRemult(x),
         openApiDoc: x => api.openApiDoc(x),
-        handle: (req, res) => api.handle(req, res),
-        withRemult: (req, res, next) => api.withRemult(req, res, next)
+        withRemult: (req, what) => new Promise((resolve) => {
+            return api.withRemult(req, undefined, () => {
+                what().then(resolve);
+            });
+        })
     });
 }

package/esm/remult-fresh.d.ts

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

package/esm/remult-next.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 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<NextApiRequest> & NextApiHandler & {
+import { RemultServerCore, RemultServerOptions } from "./server";
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultNextServer;
+export declare type RemultNextServer = RemultServerCore<NextApiRequest> & NextApiHandler & {
     getServerSideProps<P extends {
         [key: string]: any;
     } = {
@@ -14,3 +15,11 @@ export declare function remultNext(options?: RemultServerOptions<NextApiRequest>
      */
     handle<T>(handler: NextApiHandler<T>): NextApiHandler<T>;
 };
+export declare function remultNextApp(options?: RemultServerOptions<Request>): RemultNextAppServer;
+export declare type RemultNextAppServer = RemultServerCore<Request> & {
+    GET: (req: Request) => Promise<Response>;
+    PUT: (req: Request) => Promise<Response>;
+    POST: (req: Request) => Promise<Response>;
+    DELETE: (req: Request) => Promise<Response>;
+    withRemult<T>(what: () => Promise<T>): Promise<T>;
+};

package/esm/remult-next.js

@@ -5,11 +5,8 @@ export function remultNext(options) {
         getRequestBody: async (req) => req.body
     });
     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),
-        registerRouter: (...args) => result.registerRouter(...args),
-        withRemult: (...args) => result.withRemult(...args),
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (arg) => result.openApiDoc(arg),
     }, {
         getServerSideProps: (getServerPropsFunction) => {
             return (context) => {
@@ -38,3 +35,80 @@ export function remultNext(options) {
         }
     });
 }
+const encoder = new TextEncoder();
+export function remultNextApp(options) {
+    let result = createRemultServer(options, {
+        getRequestBody: req => req.json(),
+        buildGenericRequestInfo: (req) => ({
+            url: req.url,
+            method: req.method,
+            on: (e, do1) => {
+                if (e === "close") {
+                    req["_tempOnClose"] = do1;
+                }
+            },
+        }),
+    });
+    const handler = async (req) => {
+        {
+            let sseResponse = undefined;
+            req["_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(encoder.encode(message));
+                                    }
+                                    response.write = (data) => {
+                                        controller.enqueue(encoder.encode(data));
+                                    };
+                                },
+                                cancel: () => {
+                                    response.write = () => { };
+                                    req["_tempOnClose"]();
+                                },
+                            });
+                            sseResponse = new Response(stream, { headers });
+                        }
+                    }
+                },
+            };
+            const responseFromRemultHandler = await result.handle(req, response);
+            if (sseResponse !== undefined) {
+                return sseResponse;
+            }
+            if (responseFromRemultHandler) {
+                return new Response(JSON.stringify(responseFromRemultHandler.data), {
+                    status: responseFromRemultHandler.statusCode,
+                });
+            }
+        }
+    };
+    return {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (options) => result.openApiDoc(options),
+        GET: handler,
+        POST: handler,
+        PUT: handler,
+        DELETE: handler,
+        withRemult: (what) => {
+            return new Promise((resolve) => {
+                return result.withRemult({}, undefined, () => {
+                    what().then(resolve);
+                });
+            });
+        }
+    };
+}

package/esm/remult-sveltekit.d.ts

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

package/esm/remult-sveltekit.js

@@ -67,7 +67,5 @@ export function remultSveltekit(options) {
     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.d.ts

@@ -59,15 +59,17 @@ export interface ServerHandleResponse {
     data?: any;
     statusCode: number;
 }
-export interface RemultServer<RequestType> {
-    getRemult(req: RequestType): Promise<Remult>;
+export interface RemultServer<RequestType> extends RemultServerCore<RequestType> {
     withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
+    registerRouter(r: GenericRouter): void;
+    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+}
+export interface RemultServerCore<RequestType> {
+    getRemult(req: RequestType): Promise<Remult>;
     openApiDoc(options: {
         title: string;
         version?: string;
     }): any;
-    registerRouter(r: GenericRouter): void;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/esm/server/expressBridge.js

@@ -134,6 +134,9 @@ export class RemultServerImplementation {
             }
             throw new Error("Couldn't find entity " + entityKey);
         };
+        this.withRemult = (req, res, next) => {
+            this.process(async () => { next(); })(req, res);
+        };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -144,9 +147,6 @@ export class RemultServerImplementation {
             this.subscriptionServer = options.subscriptionServer;
     }
     ;
-    withRemult(req, res, next) {
-        this.process(async () => { next(); })(req, res);
-    }
     getRouteImpl() {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation(this.coreOptions);
@@ -237,7 +237,7 @@ export class RemultServerImplementation {
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
             //@ts-ignore
-            .put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, orig.params.id, orig.body)))
+            .put(this.process(async (c, req, res, reqInfo, _, orig) => dataApiFactory(c).put(res, reqInfo.params.id, await this.coreOptions.getRequestBody(orig))))
             //@ts-ignore
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
     }
@@ -264,10 +264,6 @@ export class RemultServerImplementation {
             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);
-                remult.dataProvider = (await this.dataProvider);
-                remult.subscriptionServer = this.subscriptionServer;
-                remult.liveQueryStorage = this.liveQueryStorage;
                 if (req) {
                     let user;
                     if (this.options.getUser)

package/esm/server/index.d.ts

@@ -1,5 +1,5 @@
 import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';

package/graphql.js

@@ -150,6 +150,7 @@ function remultGraphql(api) {
                         return [2 /*return*/, new Promise(function (res, error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                 var _this = this;
                                 return tslib_1.__generator(this, function (_a) {
+                                    //TODO - consider this with remult usage
                                     api.withRemult(req, undefined, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                         var remult, repo, dApi, result, err;
                                         return tslib_1.__generator(this, function (_a) {

package/package.json

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

package/remult-express.d.ts

@@ -1,6 +1,9 @@
 import * as express from 'express';
-import { RemultServer, RemultServerOptions } from './server/expressBridge';
+import { RemultServerCore, RemultServerOptions } from './server/expressBridge';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-}): express.RequestHandler & RemultServer<express.Request>;
+}): RemultExpressServer;
+export declare type RemultExpressServer = express.RequestHandler & RemultServerCore<express.Request> & {
+    withRemult: (req: express.Request, res: express.Response, next: VoidFunction) => void;
+};

package/remult-express.js

@@ -27,7 +27,6 @@ function remultExpress(options) {
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
-        registerRouter: function (x) { return server.registerRouter(x); },
         withRemult: function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {

package/remult-fastify.d.ts

@@ -1,3 +1,6 @@
 import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
-import { RemultServer, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): FastifyPluginCallback & RemultServer<FastifyRequest>;
+import { RemultServerOptions, RemultServerCore } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
+export declare type RemultFastifyServer = FastifyPluginCallback & RemultServerCore<FastifyRequest> & {
+    withRemult<T>(req: FastifyRequest, what: () => Promise<T>): Promise<T>;
+};

package/remult-fastify.js

@@ -71,8 +71,11 @@ function remultFastify(options) {
     return Object.assign(pluginFunction, {
         getRemult: function (x) { return api.getRemult(x); },
         openApiDoc: function (x) { return api.openApiDoc(x); },
-        handle: function (req, res) { return api.handle(req, res); },
-        withRemult: function (req, res, next) { return api.withRemult(req, res, next); }
+        withRemult: function (req, what) { return new Promise(function (resolve) {
+            return api.withRemult(req, undefined, function () {
+                what().then(resolve);
+            });
+        }); }
     });
 }
 exports.remultFastify = remultFastify;

package/remult-fresh.d.ts

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

package/remult-next.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 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<NextApiRequest> & NextApiHandler & {
+import { RemultServerCore, RemultServerOptions } from "./server";
+export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultNextServer;
+export declare type RemultNextServer = RemultServerCore<NextApiRequest> & NextApiHandler & {
     getServerSideProps<P extends {
         [key: string]: any;
     } = {
@@ -14,3 +15,11 @@ export declare function remultNext(options?: RemultServerOptions<NextApiRequest>
      */
     handle<T>(handler: NextApiHandler<T>): NextApiHandler<T>;
 };
+export declare function remultNextApp(options?: RemultServerOptions<Request>): RemultNextAppServer;
+export declare type RemultNextAppServer = RemultServerCore<Request> & {
+    GET: (req: Request) => Promise<Response>;
+    PUT: (req: Request) => Promise<Response>;
+    POST: (req: Request) => Promise<Response>;
+    DELETE: (req: Request) => Promise<Response>;
+    withRemult<T>(what: () => Promise<T>): Promise<T>;
+};

package/remult-next.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultNext = void 0;
+exports.remultNextApp = exports.remultNext = void 0;
 var tslib_1 = require("tslib");
 var server_1 = require("./server");
 function remultNext(options) {
@@ -12,41 +12,8 @@ function remultNext(options) {
         }); }); }
     });
     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++) {
-                args[_i] = arguments[_i];
-            }
-            return result.getRemult.apply(result, tslib_1.__spread(args));
-        },
-        handle: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return result.handle.apply(result, tslib_1.__spread(args));
-        },
-        openApiDoc: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return result.openApiDoc.apply(result, tslib_1.__spread(args));
-        },
-        registerRouter: function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return result.registerRouter.apply(result, tslib_1.__spread(args));
-        },
-        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));
-        },
+        getRemult: function (req) { return result.getRemult(req); },
+        openApiDoc: function (arg) { return result.openApiDoc(arg); },
     }, {
         getServerSideProps: function (getServerPropsFunction) {
             return function (context) {
@@ -105,3 +72,100 @@ function remultNext(options) {
     });
 }
 exports.remultNext = remultNext;
+var encoder = new TextEncoder();
+function remultNextApp(options) {
+    var _this = this;
+    var result = server_1.createRemultServer(options, {
+        getRequestBody: function (req) { return req.json(); },
+        buildGenericRequestInfo: function (req) { return ({
+            url: req.url,
+            method: req.method,
+            on: function (e, do1) {
+                if (e === "close") {
+                    req["_tempOnClose"] = do1;
+                }
+            },
+        }); },
+    });
+    var handler = function (req) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var sseResponse_1, response_1, responseFromRemultHandler;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sseResponse_1 = undefined;
+                    req["_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_2, _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(encoder.encode(message));
+                                                }
+                                            }
+                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                            finally {
+                                                try {
+                                                    if (messages_2_1 && !messages_2_1.done && (_a = messages_2.return)) _a.call(messages_2);
+                                                }
+                                                finally { if (e_2) throw e_2.error; }
+                                            }
+                                            response_1.write = function (data) {
+                                                controller.enqueue(encoder.encode(data));
+                                            };
+                                        },
+                                        cancel: function () {
+                                            response_1.write = function () { };
+                                            req["_tempOnClose"]();
+                                        },
+                                    });
+                                    sseResponse_1 = new Response(stream, { headers: headers });
+                                }
+                            }
+                        },
+                    };
+                    return [4 /*yield*/, result.handle(req, response_1)];
+                case 1:
+                    responseFromRemultHandler = _a.sent();
+                    if (sseResponse_1 !== undefined) {
+                        return [2 /*return*/, sseResponse_1];
+                    }
+                    if (responseFromRemultHandler) {
+                        return [2 /*return*/, new Response(JSON.stringify(responseFromRemultHandler.data), {
+                                status: responseFromRemultHandler.statusCode,
+                            })];
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    return {
+        getRemult: function (req) { return result.getRemult(req); },
+        openApiDoc: function (options) { return result.openApiDoc(options); },
+        GET: handler,
+        POST: handler,
+        PUT: handler,
+        DELETE: handler,
+        withRemult: function (what) {
+            return new Promise(function (resolve) {
+                return result.withRemult({}, undefined, function () {
+                    what().then(resolve);
+                });
+            });
+        }
+    };
+}
+exports.remultNextApp = remultNextApp;

package/remult-sveltekit.d.ts

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

package/remult-sveltekit.js

@@ -106,14 +106,6 @@ function remultSveltekit(options) {
     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

@@ -59,15 +59,17 @@ export interface ServerHandleResponse {
     data?: any;
     statusCode: number;
 }
-export interface RemultServer<RequestType> {
-    getRemult(req: RequestType): Promise<Remult>;
+export interface RemultServer<RequestType> extends RemultServerCore<RequestType> {
     withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
+    registerRouter(r: GenericRouter): void;
+    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+}
+export interface RemultServerCore<RequestType> {
+    getRemult(req: RequestType): Promise<Remult>;
     openApiDoc(options: {
         title: string;
         version?: string;
     }): any;
-    registerRouter(r: GenericRouter): void;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/server/expressBridge.js

@@ -243,6 +243,12 @@ 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.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -253,13 +259,6 @@ var RemultServerImplementation = /** @class */ (function () {
             this.subscriptionServer = options.subscriptionServer;
     }
     ;
-    RemultServerImplementation.prototype.withRemult = function (req, res, next) {
-        var _this = this;
-        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);
-    };
     RemultServerImplementation.prototype.getRouteImpl = function () {
         if (!this.routeImpl) {
             this.routeImpl = new RouteImplementation(this.coreOptions);
@@ -453,8 +452,14 @@ var RemultServerImplementation = /** @class */ (function () {
             return [2 /*return*/, dataApiFactory(c).get(res, orig.params.id)];
         }); }); }))
             //@ts-ignore
-            .put(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, dataApiFactory(c).put(res, orig.params.id, orig.body)];
+            .put(this.process(function (c, req, res, reqInfo, _, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { var _a, _b, _c; return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _b = (_a = dataApiFactory(c)).put;
+                    _c = [res, reqInfo.params.id];
+                    return [4 /*yield*/, this.coreOptions.getRequestBody(orig)];
+                case 1: return [2 /*return*/, _b.apply(_a, _c.concat([_d.sent()]))];
+            }
         }); }); }))
             //@ts-ignore
             .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
@@ -515,33 +520,26 @@ var RemultServerImplementation = /** @class */ (function () {
                         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;
-                                return tslib_1.__generator(this, function (_b) {
-                                    switch (_b.label) {
+                                var user;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
                                         case 0:
-                                            remult.liveQueryPublisher = new SubscriptionServer_1.LiveQueryPublisher(function () { return remult.subscriptionServer; }, function () { return remult.liveQueryStorage; }, this.runWithSerializedJsonContextData);
-                                            _a = remult;
-                                            return [4 /*yield*/, this.dataProvider];
-                                        case 1:
-                                            _a.dataProvider = (_b.sent());
-                                            remult.subscriptionServer = this.subscriptionServer;
-                                            remult.liveQueryStorage = this.liveQueryStorage;
-                                            if (!req) return [3 /*break*/, 6];
+                                            if (!req) return [3 /*break*/, 5];
                                             user = void 0;
-                                            if (!this.options.getUser) return [3 /*break*/, 3];
+                                            if (!this.options.getUser) return [3 /*break*/, 2];
                                             return [4 /*yield*/, this.options.getUser(req)];
+                                        case 1:
+                                            user = _a.sent();
+                                            return [3 /*break*/, 3];
                                         case 2:
-                                            user = _b.sent();
-                                            return [3 /*break*/, 4];
-                                        case 3:
                                             user = req['user'];
                                             if (!user)
                                                 user = req['auth'];
-                                            _b.label = 4;
-                                        case 4:
+                                            _a.label = 3;
+                                        case 3:
                                             if (user)
                                                 remult.user = (user);
-                                            if (!this.options.initRequest) return [3 /*break*/, 6];
+                                            if (!this.options.initRequest) return [3 /*break*/, 5];
                                             return [4 /*yield*/, this.options.initRequest(req, {
                                                     remult: remult,
                                                     get liveQueryStorage() {
@@ -551,12 +549,12 @@ var RemultServerImplementation = /** @class */ (function () {
                                                         remult.liveQueryStorage = value;
                                                     }
                                                 })];
-                                        case 5:
-                                            _b.sent();
-                                            _b.label = 6;
-                                        case 6: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
-                                        case 7:
-                                            _b.sent();
+                                        case 4:
+                                            _a.sent();
+                                            _a.label = 5;
+                                        case 5: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
+                                        case 6:
+                                            _a.sent();
                                             return [2 /*return*/];
                                     }
                                 });

package/server/index.d.ts

@@ -1,5 +1,5 @@
 import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';