remult 0.20.0-exp.9 → 0.20.0

package/esm/graphql.d.ts

@@ -1,5 +1,5 @@
-import { RemultServer } from "./server/expressBridge";
-export declare function remultGraphql(api: RemultServer<any>): {
+import { RemultExpressServer } from "./remult-express";
+export declare function remultGraphql(api: RemultExpressServer): {
     rootValue: {};
     schema: string;
 };

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/postgres/postgres-data-provider.d.ts

@@ -28,4 +28,9 @@ export declare function createPostgresConnection(options?: {
     sslInDev?: boolean;
     configuration?: "heroku" | PoolConfig;
 }): Promise<SqlDatabase>;
+export declare function createPostgresDataProvider(options?: {
+    connectionString?: string;
+    sslInDev?: boolean;
+    configuration?: "heroku" | PoolConfig;
+}): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/esm/postgres/postgres-data-provider.js

@@ -37,6 +37,7 @@ export class PostgresDataProvider {
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
                 getLimitSqlSyntax: this.getLimitSqlSyntax,
+                supportsJsonColumnType: this.supportsJsonColumnType,
                 //@ts-ignore
                 pool: client
             });
@@ -74,6 +75,9 @@ class PostgresBridgeToSQLQueryResult {
     }
 }
 export async function createPostgresConnection(options) {
+    return createPostgresDataProvider(options);
+}
+export async function createPostgresDataProvider(options) {
     if (!options)
         options = {};
     let config = {};

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

@@ -13,13 +13,13 @@ export function remultExpress(options) {
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
     const server = createRemultServer(options, {
-        buildGenericRequest: req => req
+        buildGenericRequestInfo: req => req,
+        getRequestBody: async (req) => req.body
     });
     server.registerRouter(app);
     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

@@ -30,7 +30,8 @@ export function remultFastify(options) {
         return response;
     }
     const api = createRemultServer(options, {
-        buildGenericRequest: req => req
+        buildGenericRequestInfo: req => req,
+        getRequestBody: async (req) => req.body
     });
     const pluginFunction = async (instance, op) => {
         //@ts-ignore
@@ -60,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-fresh.js

@@ -1,23 +1,13 @@
 import { createRemultServerCore } from "./server/expressBridge";
 export function remultFresh(options, response) {
     const server = createRemultServerCore(options, {
-        buildGenericRequest: r => r
+        buildGenericRequestInfo: r => r,
+        getRequestBody: req => req.json()
     });
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),
         handle: async (req, ctx) => {
-            const theReq = {
-                method: req.method,
-                url: req.url,
-                body: undefined
-            };
-            switch (req.method.toLocaleLowerCase()) {
-                case "put":
-                case "post":
-                    theReq.body = await req.json();
-                    break;
-            }
             let init = {};
             const res = await server.handle(req);
             if (res) {

package/esm/remult-next.d.ts

@@ -1,11 +1,25 @@
 /// <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;
     } = {
         [key: string]: any;
     }, Q extends ParsedUrlQuery = ParsedUrlQuery, D extends PreviewData = PreviewData>(getServerPropsFunction: GetServerSideProps<P, Q, D>): GetServerSideProps<P, Q, D>;
+    /** Creates a `next.js` handler with remult defined in the correct context
+     * @see
+     * https://remult.dev/tutorials/react-next/appendix-1-get-server-side-props.html#using-remult-in-a-next-js-api-handler
+     */
+    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

@@ -1,14 +1,12 @@
 import { createRemultServer } from "./server";
 export function remultNext(options) {
     let result = createRemultServer(options, {
-        buildGenericRequest: req => req
+        buildGenericRequestInfo: req => req,
+        getRequestBody: async (req) => req.body
     });
-    return Object.assign((req, res) => result.handle(req, res), 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),
+    return Object.assign((req, res) => result.handle(req, res).then(() => { }), result, {
+        getRemult: (req) => result.getRemult(req),
+        openApiDoc: (arg) => result.openApiDoc(arg),
     }, {
         getServerSideProps: (getServerPropsFunction) => {
             return (context) => {
@@ -24,6 +22,93 @@ export function remultNext(options) {
                     });
                 });
             };
+        },
+        handle: (handler) => {
+            return async (req, res) => {
+                await new Promise(async (resolve) => {
+                    result.withRemult(req, res, async () => {
+                        await handler(req, res);
+                        resolve();
+                    });
+                });
+            };
         }
     });
 }
+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

@@ -1,28 +1,19 @@
 import { createRemultServer } from './server';
 export function remultSveltekit(options) {
     let result = createRemultServer(options, {
-        buildGenericRequest: event => ({
+        buildGenericRequestInfo: event => ({
             url: event.request.url,
             method: event.request.method,
-            body: event.locals["_tempJson"],
             on: (e, do1) => {
                 if (e === 'close') {
                     event.locals["_tempOnClose"] = do1;
                 }
             }
-        })
+        }),
+        getRequestBody: event => event.request.json()
     });
     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 = {
@@ -57,7 +48,6 @@ export function remultSveltekit(options) {
                     }
                 }
             };
-            event.locals["_tempJson"] = json;
             const responseFromRemultHandler = await result.handle(event, response);
             if (sseResponse !== undefined) {
                 return sseResponse;
@@ -77,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/core.d.ts

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

package/esm/server/expressBridge.d.ts

@@ -44,7 +44,7 @@ export interface RemultServerOptions<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>;
+        deserialize(json: any, options: InitRequestOptions): Promise<void>;
     };
     /** Storage to use for backend methods that use queue */
     queueStorage?: QueueStorage;
@@ -54,20 +54,22 @@ export interface InitRequestOptions {
     readonly remult: Remult;
 }
 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 declare type GenericRequestHandler = (req: GenericRequestInfo, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
     statusCode: number;
 }
-export interface RemultServer<RequestType> {
+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>;
-    withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;
@@ -78,10 +80,9 @@ export declare type SpecificRoute = {
     post(handler: GenericRequestHandler): SpecificRoute;
     delete(handler: GenericRequestHandler): SpecificRoute;
 };
-export interface GenericRequest {
+export interface GenericRequestInfo {
     url?: string;
     method?: any;
-    body?: any;
     query?: any;
     params?: any;
 }
@@ -129,5 +130,6 @@ export declare class JobsInQueueEntity extends IdEntity {
     progress: number;
 }
 export interface ServerCoreOptions<RequestType> {
-    buildGenericRequest(req: RequestType): GenericRequest;
+    buildGenericRequestInfo(req: RequestType): GenericRequestInfo;
+    getRequestBody(req: RequestType): Promise<any>;
 }

package/esm/server/expressBridge.js

@@ -125,7 +125,15 @@ export class RemultServerImplementation {
                     await this.runWithRemult(async (remult) => {
                         remult.user = jsonContextData.user;
                         if (this.options.contextSerializer) {
-                            await this.options.contextSerializer.deserialize(jsonContextData, remult);
+                            await this.options.contextSerializer.deserialize(jsonContextData.context, {
+                                remult,
+                                get liveQueryStorage() {
+                                    return remult.liveQueryStorage;
+                                },
+                                set liveQueryStorage(value) {
+                                    remult.liveQueryStorage = value;
+                                }
+                            });
                         }
                         await what(remult.repo(e));
                     });
@@ -134,6 +142,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 +155,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);
@@ -196,15 +204,15 @@ export class RemultServerImplementation {
                 r.route(streamPath).get(this.process(async (remult, req, res, origReq, origRes) => {
                     remult.subscriptionServer.openHttpServerStream(origReq, origRes);
                 }));
-                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
-                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult);
+                r.route(streamPath + '/subscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
+                    const body = remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult);
                 }));
-                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, origReq, origRes) => {
-                    remult.subscriptionServer.subscribeToChannel(origReq.body, res, remult, true);
+                r.route(streamPath + '/unsubscribe').post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
+                    remult.subscriptionServer.subscribeToChannel(await this.coreOptions.getRequestBody(origReq), res, remult, true);
                 }));
             }
-            r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, origReq, origRes) => {
-                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(origReq.body));
+            r.route(this.options.rootPath + '/' + liveQueryKeepAliveRoute).post(this.process(async (remult, req, res, reqInfo, origRes, origReq) => {
+                res.success(await remult.liveQueryStorage.keepAliveAndReturnUnknownQueryIds(await this.coreOptions.getRequestBody(origReq)));
             }));
         }
         this.options.entities.forEach(e => {
@@ -230,14 +238,14 @@ export class RemultServerImplementation {
         if (this.options.logApiEndPoints)
             console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c)))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
+            .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c)))).put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).put(res, '', await this.coreOptions.getRequestBody(orig))))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
-            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body, () => this.serializeContext(c))));
+            .post(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).httpPost(res, req, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));
         r.route(myRoute + '/:id')
             //@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)));
     }
@@ -255,7 +263,7 @@ export class RemultServerImplementation {
     }
     process(what) {
         return async (req, origRes) => {
-            const genReq = this.coreOptions.buildGenericRequest(req);
+            const genReq = this.coreOptions.buildGenericRequestInfo(req);
             if (!genReq.query) {
                 genReq.query = req["_tempQuery"];
             }
@@ -264,10 +272,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)
@@ -291,7 +295,7 @@ export class RemultServerImplementation {
                         });
                     }
                 }
-                await what(remult, myReq, myRes, genReq, origRes);
+                await what(remult, myReq, myRes, genReq, origRes, req);
             });
         };
     }
@@ -320,15 +324,15 @@ export class RemultServerImplementation {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);
             }
-            r.route(myUrl).post(this.process(async (remult, req, res, orig) => {
+            r.route(myUrl).post(this.process(async (remult, req, res, _, __, orig) => {
                 if (queue) {
                     let r = {
-                        queuedJobId: await this.queue.submitJob(myUrl, remult, orig.body)
+                        queuedJobId: await this.queue.submitJob(myUrl, remult, await this.coreOptions.getRequestBody(orig))
                     };
                     res.success(r);
                 }
                 else
-                    return what(orig.body, remult, res);
+                    return what(await this.coreOptions.getRequestBody(orig), remult, res);
             }));
         });
     }
@@ -857,7 +861,7 @@ class RouteImplementation {
         });
     }
     middleware(origReq, res, next) {
-        const req = this.coreOptions.buildGenericRequest(origReq);
+        const req = this.coreOptions.buildGenericRequestInfo(origReq);
         let theUrl = req.url;
         if (theUrl.startsWith('/')) //next sends a partial url '/api/tasks' and not the full url
             theUrl = 'http://stam' + theUrl;

package/esm/server/index.d.ts

@@ -1,5 +1,5 @@
 import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequest, 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/esm/server/index.js

@@ -5,5 +5,5 @@ export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-q
 export { SseSubscriptionServer } from '../SseSubscriptionServer';
 export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
-    return createRemultServerCore(options, serverCoreOptions || { buildGenericRequest: req => req });
+    return createRemultServerCore(options, serverCoreOptions || { buildGenericRequestInfo: req => req, getRequestBody: async (req) => req.body });
 }

package/esm/src/buildRestDataProvider.js

@@ -39,15 +39,17 @@ export class HttpProviderBridgeToRestDataProviderHttpProvider {
     }
 }
 export async function retry(what) {
+    let i = 0;
     while (true) {
         try {
             return await what();
         }
         catch (err) {
-            if (err.message?.startsWith("Error occurred while trying to proxy") ||
+            if ((err.message?.startsWith("Error occurred while trying to proxy") ||
                 err.message?.startsWith("Error occured while trying to proxy") ||
                 err.message?.includes("http proxy error") ||
-                err.message?.startsWith("Gateway Timeout")) {
+                err.message?.startsWith("Gateway Timeout") ||
+                err.status == 500) && i++ < 10) {
                 await new Promise((res, req) => {
                     setTimeout(() => {
                         res({});

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

@@ -5,8 +5,8 @@ export declare class DataApi<T = any> {
     private repository;
     private remult;
     constructor(repository: Repository<T>, remult: Remult);
-    httpGet(res: DataApiResponse, req: DataApiRequest, serializeRequest: () => Promise<any>): Promise<void>;
-    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeRequest: () => Promise<any>): Promise<void>;
+    httpGet(res: DataApiResponse, req: DataApiRequest, serializeContext: () => Promise<any>): Promise<void>;
+    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeContext: () => Promise<any>): Promise<void>;
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
@@ -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: () => Promise<any>, queryChannel: string): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;