remult 0.17.0 → 0.18.1-exp.1

package/README.md

@@ -3,7 +3,6 @@
     <img src="https://github.com/remult/remult/raw/master/docs/.vuepress/public/logo.png" width="140" height="140">
   </a>
   <h1>Remult</h1>
-  <p>A CRUD framework for full-stack TypeScript</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
 		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
 	</a>
@@ -25,29 +24,14 @@
   <a href="https://twitter.com/intent/tweet?text=Remult%20-%20open-source%20CRUD%20framework%20for%20full-stack%20TypeScript%0A%0A%40remultjs%0A&url=https%3A%2F%2Fgithub.com%2Fremult%2Fremult">
     <img alt="Twitter URL" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Ftext%3DRemult%2520-%2520open-source%2520CRUD%2520framework%2520for%2520full-stack%2520TypeScript%250A%250A%2540remultjs%250A%26url%3Dhttps%253A%252F%252Fgithub.com%252Fremult%252Fremult">
   </a>
+	<a href="https://twitter.com/remultjs" rel="nofollow">
+	  <img alt="Twitter Follow" src="https://img.shields.io/twitter/url.svg?label=Follow%20%40remultjs&style=social&url=https%3A%2F%2Ftwitter.com%2FRemultJs">
+	</a>
 </div>
-
-
-<br/>
-
-<div align="center">
-  <a href="#getting-started">Getting Started</a> |
-  <a href="#documentation">Documentation</a> |
-  <a href="#example-apps">Example Apps</a>
-</div>
-
 <hr/>
-<br/>
 
-<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
-  <p align="center">
-    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
-  </p>
-</a>
-
-<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
-  <p align="center">Watch code demo on YouTube here (14 mins)</p>
-</a>
+[Getting Started](#getting-started) | [Documentation](#documentation) |
+[Example Apps](#example-apps)
 
 ## What is Remult?
 
@@ -55,13 +39,6 @@
 as a single source of truth for your API, frontend type-safe API client and
 backend ORM**.
 
-* :zap: Zero-boilerplate CRUD API routes with paging, sorting, and filtering for Express / Fastify / Next.js / NestJS / Koa / others...
-* :ok_hand: Fullstack type-safety for API queries, mutations and RPC, without code generation
-* :sparkles: Input validation, defined once, runs both on the backend and on the frontend for best UX
-* :lock: Fine-grained code-based API authorization
-* :relieved: Incrementally adoptable
-* :rocket: Production ready
-
 ### Status
 
 Remult is **production-ready** and, in fact, used in production apps since 2018.

package/esm/index.d.ts

@@ -1,4 +1,5 @@
-export { Field, Fields, StringFieldOptions, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider } from './src/data-interfaces';
@@ -13,7 +14,8 @@ export { SqlDatabase, } from './src/data-providers/sql-database';
 export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
-export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
+export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';

package/esm/live-query/ably.d.ts

@@ -0,0 +1,13 @@
+import type * as Ably from 'ably';
+import type { ServerEventDispatcher } from '../src/live-query/LiveQueryPublisher';
+import type { LiveQueryProvider, PubSubClient } from '../src/live-query/LiveQuerySubscriber';
+export declare class AblyLiveQueryProvider implements LiveQueryProvider {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
+}
+export declare class AblyServerEventDispatcher implements ServerEventDispatcher {
+    private ably;
+    constructor(ably: Ably.Types.RealtimePromise);
+    sendChannelMessage<T>(channel: string, message: T): void;
+}

package/esm/live-query/ably.js

@@ -0,0 +1,25 @@
+export class AblyLiveQueryProvider {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openStreamAndReturnCloseFunction(onReconnect) {
+        return {
+            disconnect: () => {
+                this.ably.connection.close();
+            },
+            subscribe: (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => { myHandler = () => { }; };
+            }
+        };
+    }
+}
+export class AblyServerEventDispatcher {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    sendChannelMessage(channel, message) {
+        this.ably.channels.get(channel).publish({ data: message });
+    }
+}

package/esm/live-query/index.d.ts

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, ServerEventDispatcher, LiveQueryStorage, LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, AMessageChannel } from '../src/live-query/LiveQuerySubscriber';
+export { LiveQueryClient } from '../src/live-query/LiveQueryClient';

package/esm/live-query/index.js

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
+export { AMessageChannel } from '../src/live-query/LiveQuerySubscriber';
+export { LiveQueryClient } from '../src/live-query/LiveQueryClient';

package/esm/postgres/schema-builder.js

@@ -43,7 +43,7 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.log("start verify structure"); //keep me
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
             let e = await getDbNameProvider(entity);
@@ -56,7 +56,7 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + e.entityName + " ", err);
+                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
             }
         }
     }
@@ -102,7 +102,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
     async verifyAllColumns(entity) {
@@ -122,7 +122,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/remult-express.d.ts

@@ -1,6 +1,32 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
+import { Remult } from './src/context';
+import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
+import { ServerEventDispatcher } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
+    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
 }): express.RequestHandler & RemultServer;
+export declare class ServerEventsController implements ServerEventDispatcher {
+    private canUserConnectToChannel?;
+    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
+    connections: clientConnection[];
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
+    sendChannelMessage<T>(channel: string, message: any): void;
+    debugMessageFileSaver: (id: any, channel: any, message: any) => void;
+    openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
+    debug(): void;
+    debugFileSaver: (x: any) => void;
+}
+declare class clientConnection {
+    response: import('express').Response;
+    channels: Record<string, boolean>;
+    close(): void;
+    closed: boolean;
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: import('express').Response);
+    sendLiveMessage(): void;
+}
+export {};

package/esm/remult-express.js

@@ -1,5 +1,10 @@
 import * as express from 'express';
-import { createRemultServer } from './server/index';
+import { createRemultServer } from './server/expressBridge';
+import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/LiveQuerySubscriber';
+import { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from './src/live-query/LiveQueryPublisher';
+import { v4 as uuid } from 'uuid';
+import { remult } from './src/remult-proxy';
+import { getEntityKey } from './src/remult3';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -14,6 +19,29 @@ export function remultExpress(options) {
     }
     const server = createRemultServer(options);
     server.registerRouter(app);
+    if (!options.serverEventDispatcher) {
+        options.serverEventDispatcher = (router, server) => {
+            return buildHttpServerEventDispatcher(router, options.rootPath, server);
+        };
+    }
+    app.post(options.rootPath + liveQueryKeepAliveRoute, (r, res, n) => server.withRemult(r, res, n), async (req, res) => {
+        res.send(await remult.liveQueryPublisher.storage.keepAliveAndReturnUnknownIds(req.body));
+    });
+    server.liveQueryManager = new LiveQueryPublisher(options.serverEventDispatcher(app, server), new LiveQueryStorageInMemoryImplementation(), async (req, entityKey, what) => {
+        for (const e of options.entities) {
+            let key = getEntityKey(e);
+            if (key === entityKey) {
+                await new Promise((result) => {
+                    server.withRemult(options.requestSerializer.fromJson(req), undefined, async () => {
+                        await what(remult.repo(e));
+                        result({});
+                    });
+                });
+                return;
+            }
+        }
+        throw new Error("Couldn't find entity " + entityKey);
+    });
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -21,3 +49,111 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
+export class ServerEventsController {
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
+        this.connections = [];
+        this.debugMessageFileSaver = (id, channel, message) => { };
+        this.debugFileSaver = () => { };
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    if (remove)
+                        delete c.channels[channel];
+                    else
+                        c.channels[channel] = true;
+                    res.json("ok");
+                    this.debug();
+                    return;
+                }
+                else {
+                    res.sendStatus(403);
+                    this.debug();
+                    return;
+                }
+            }
+        }
+        res.sendStatus(404);
+    }
+    sendChannelMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
+        for (const sc of this.connections) {
+            if (sc.channels[channel]) {
+                this.debugMessageFileSaver(sc.connectionId, channel, message);
+                sc.write(data);
+            }
+        }
+    }
+    openHttpServerStream(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+        const cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
+        this.connections.push(cc);
+        this.debug();
+        req.on("close", () => {
+            cc.close();
+            this.connections = this.connections.filter(s => s !== cc);
+            this.debug();
+        });
+        return cc;
+    }
+    debug() {
+        this.debugFileSaver(this.connections.map(x => ({
+            id: x.connectionId,
+            channels: x.channels
+        })));
+    }
+}
+class clientConnection {
+    constructor(response) {
+        this.response = response;
+        this.channels = {};
+        this.closed = false;
+        this.connectionId = uuid();
+        this.write(this.connectionId, "connectionId");
+        this.sendLiveMessage();
+    }
+    close() {
+        this.closed = true;
+    }
+    write(eventData, eventType = "message") {
+        let event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
+        let r = this.response;
+        if (r.flush)
+            r.flush();
+    }
+    sendLiveMessage() {
+        if (this.closed)
+            return;
+        this.write("", "keep-alive");
+        setTimeout(() => {
+            this.sendLiveMessage();
+        }, 45000);
+    }
+}
+function buildHttpServerEventDispatcher(router, apiPath, server) {
+    const streamPath = apiPath + '/' + streamUrl;
+    let httpServerEvents = new ServerEventsController();
+    router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.openHttpServerStream(req, res);
+    });
+    router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult);
+    });
+    router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult, true);
+    });
+    return httpServerEvents;
+}

package/esm/remult-fastify.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server/index';
+import { createRemultServer } from './server/expressBridge';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {

package/esm/remult-fresh.js

@@ -1,6 +1,6 @@
-import { createRemultServerCore } from "./server/expressBridge";
+import { createRemultServer } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = createRemultServerCore(options);
+    const server = createRemultServer(options);
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),

package/esm/remult-knex/index.js

@@ -153,15 +153,8 @@ class KnexEntityDataProvider {
         }
         let insert = this.knex(e.entityName).insert(insertObject);
         if (isAutoIncrement(this.entity.idMetadata.field)) {
-            let newId;
-            if (this.knex.client.config.client === 'mysql2') {
-                let result = await insert;
-                newId = result[0];
-            }
-            else {
-                let result = await insert.returning(this.entity.idMetadata.field.key);
-                newId = result[0].id;
-            }
+            let result = await insert.returning(this.entity.idMetadata.field.key);
+            let newId = result[0].id;
             resultFilter = new Filter(x => x.isEqualTo(this.entity.idMetadata.field, newId));
         }
         else
@@ -263,7 +256,7 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.info("start verify structure");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -326,7 +319,7 @@ export class KnexSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/server/expressBridge.d.ts

@@ -1,9 +1,11 @@
-import { queuedJobInfoResponse } from '../src/server-action';
+import { ActionInterface, queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { Remult, UserInfo } from '../src/context';
+import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
+import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
+import { LiveQueryPublisher } from '../src/live-query/LiveQueryPublisher';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -12,6 +14,10 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
     queueStorage?: QueueStorage;
     initRequest?: (remult: Remult, origReq: RequestType) => Promise<void>;
+    requestSerializer?: {
+        toJson: (request: RequestType) => any;
+        fromJson: (request: any) => RequestType;
+    };
     getUser?: (request: RequestType) => Promise<UserInfo>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
@@ -20,7 +26,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
@@ -57,14 +63,39 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare class RemultAsyncLocalStorage {
-    private readonly remultObjectStorage;
-    static enable(): void;
-    static disable(): void;
-    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: VoidFunction): void;
-    getRemult(): Remult;
-    static instance: RemultAsyncLocalStorage;
+export declare class RemultServerImplementation implements RemultServer {
+    queue: inProcessQueueHandler;
+    options: RemultServerOptions<GenericRequest>;
+    dataProvider: DataProvider | Promise<DataProvider>;
+    constructor(queue: inProcessQueueHandler, options: RemultServerOptions<GenericRequest>, dataProvider: DataProvider | Promise<DataProvider>);
+    liveQueryManager: LiveQueryPublisher;
+    withRemult<T>(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
+    routeImpl: RouteImplementation;
+    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse>;
+    registeredRouter: boolean;
+    registerRouter(r: GenericRouter): void;
+    add(key: string, dataApiFactory: ((req: Remult) => DataApi), r: GenericRouter): void;
+    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, origReq: GenericRequest) => Promise<void>): (req: GenericRequest, res: GenericResponse) => Promise<void>;
+    getRemult(req: GenericRequest): Promise<Remult>;
+    hasQueue: boolean;
+    addAction(action: ActionInterface, r: GenericRouter): void;
+    openApiDoc(options: {
+        title: string;
+        version?: string;
+    }): any;
+    backendMethodsOpenApi: {
+        path: string;
+        allowed: AllowedForInstance<any>;
+        tag: string;
+    }[];
+}
+declare class inProcessQueueHandler {
+    private storage;
+    constructor(storage: QueueStorage);
+    submitJob(url: string, req: Remult, body: any): Promise<string>;
+    mapQueuedAction(url: string, what: (data: any, r: Remult, res: ApiActionResponse) => void): void;
+    actions: Map<string, (data: any, r: Remult, res: ApiActionResponse) => void>;
+    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
 }
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
@@ -90,6 +121,12 @@ export declare class EntityQueueStorage implements QueueStorage {
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
     createJob(url: string, userId: string): Promise<string>;
 }
+declare class RouteImplementation {
+    map: Map<string, Map<string, GenericRequestHandler>>;
+    route(path: string): SpecificRoute;
+    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    middleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
+}
 export declare class JobsInQueueEntity extends IdEntity {
     userId: string;
     url: string;
@@ -100,3 +137,4 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
+export {};

package/esm/server/expressBridge.js

@@ -6,7 +6,7 @@ import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
 ;
-export function createRemultServerCore(options) {
+export function createRemultServer(options) {
     if (!options) {
         options = {};
     }
@@ -30,12 +30,30 @@ export function createRemultServerCore(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
-    RemultAsyncLocalStorage.enable();
+    if (!remultObjectStorage) {
+        dataProvider = dataProvider.then(async (dp) => {
+            try {
+                const asyncHooks = await import('async_hooks');
+                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
+            }
+            catch {
+                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
+            }
+            remult.remultFactory = () => {
+                const r = remultObjectStorage.getRemult();
+                if (r)
+                    return r;
+                else
+                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+            };
+            return dp;
+        });
+    }
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+                remultObjectStorage.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -43,6 +61,23 @@ export function createRemultServerCore(options) {
             return dp;
         });
     }
+    if (!options.requestSerializer) {
+        options.requestSerializer = {
+            toJson: x => {
+                const r = {
+                    url: x.url
+                };
+                for (const key of ['session', 'auth', 'user']) {
+                    if (x[key])
+                        r[key] = x[key];
+                }
+                return r;
+            },
+            fromJson: x => {
+                return x;
+            }
+        };
+    }
     {
         let allControllers = [];
         if (!options.entities)
@@ -60,22 +95,10 @@ export function createRemultServerCore(options) {
     return bridge;
 }
 ;
-export class RemultAsyncLocalStorage {
+class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
-    static enable() {
-        remult.remultFactory = () => {
-            const r = RemultAsyncLocalStorage.instance.getRemult();
-            if (r)
-                return r;
-            else
-                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-        };
-    }
-    static disable() {
-        remult.resetFactory();
-    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -84,13 +107,13 @@ export class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
+            throw "can't use static remult in this environment, `async_hooks` were not found";
         }
         return this.remultObjectStorage.getStore();
     }
 }
-RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
-class RemultServerImplementation {
+let remultObjectStorage;
+export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
@@ -156,11 +179,11 @@ class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
-            .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).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.options.requestSerializer.toJson(orig)))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .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)));
+            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body, () => this.options.requestSerializer.toJson(orig))));
         r.route(myRoute + '/:id')
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
@@ -174,9 +197,10 @@ class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
+            remult.liveQueryPublisher = this.liveQueryManager;
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
-                RemultAsyncLocalStorage.instance.run(remult, async () => {
+                remultObjectStorage.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)
@@ -218,7 +242,7 @@ class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);

package/esm/server/index.d.ts

@@ -1,4 +1,2 @@
-import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,7 +1,2 @@
-import { createRemultServerCore } from './expressBridge';
-import { initAsyncHooks } from './initAsyncHooks';
+export { createRemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
-export function createRemultServer(options) {
-    initAsyncHooks();
-    return createRemultServerCore(options);
-}