remult 0.14.28 → 0.14.31

package/esm/remult-express.d.ts

@@ -1,5 +1,5 @@
-import { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultMiddlewareOptions & {
+import { RemultServerOptions } from './server/expressBridge';
+export declare function remultExpress(options?: RemultServerOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
 }): import("express-serve-static-core").Router & {

package/esm/remult-fastify.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback } from 'fastify';
-import { RemultServer, RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultMiddlewareOptions): FastifyPluginCallback & RemultServer;
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions): FastifyPluginCallback & RemultServer;

package/esm/remult-fastify.js

@@ -19,7 +19,7 @@ export function remultFastify(options) {
         return response;
     }
     let api;
-    const pluginFunction = async (instance, options) => {
+    const pluginFunction = async (instance, op) => {
         //@ts-ignore
         let fastifyRouter = {
             route(path) {

package/esm/remult-fresh.d.ts

@@ -0,0 +1,22 @@
+import { RemultServerOptions, RemultServer } from "./server/expressBridge";
+import { Remult } from "./src/context";
+export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServer {
+    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+}
+export interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+export interface FreshContext {
+    next: () => Promise<any>;
+    state: FreshRemultState;
+}
+export interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}
+export interface FreshRemultState {
+    remult: Remult;
+}

package/esm/remult-fresh.js

@@ -0,0 +1,43 @@
+import { remultMiddleware } from "./remult-middleware";
+export function remultFresh(options, response) {
+    const mw = remultMiddleware(options);
+    const orig = mw.handle;
+    return {
+        ...mw,
+        ...{
+            handle: async (req, ctx) => {
+                const theReq = {
+                    method: req.method,
+                    url: req.url,
+                    body: undefined
+                };
+                switch (req.method.toLocaleLowerCase()) {
+                    case "put":
+                    case "post":
+                        console.log(req);
+                        theReq.body = await req.json();
+                        break;
+                }
+                let init = {};
+                const res = await orig(theReq);
+                if (res) {
+                    if (res.statusCode)
+                        init.status = res.statusCode;
+                    if (res.data) {
+                        console.log({ init, res });
+                        return response.json(res.data, init);
+                    }
+                    else
+                        return new response(undefined, init);
+                }
+                else {
+                    const remult = await mw.getRemult(req);
+                    ctx.state.remult = remult;
+                    return ctx.next();
+                }
+                ;
+            }
+        }
+    };
+}
+;

package/esm/remult-middleware.d.ts

@@ -1,9 +1,10 @@
-import { GenericRequest, GenericRequestHandler, GenericResponse, RemultMiddlewareOptions, RemultServer } from './server/expressBridge';
-export declare function remultMiddleware(options?: RemultMiddlewareOptions): RemultMiddleware;
-export interface RemultMiddleware extends GenericRequestHandler, RemultServer {
+import { GenericRequest, GenericMiddleware, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultServerOptions): RemultMiddleware;
+export interface RemultMiddleware extends GenericMiddleware, RemultServer {
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<MiddlewareResponse>;
 }
 export interface MiddlewareResponse {
     data?: any;
     statusCode?: number;
 }
+export { GenericRequest, GenericMiddleware as GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions as RemultMiddlewareOptions, SpecificRoute, RemultServer };

package/esm/remult-middleware.js

@@ -6,7 +6,7 @@ export function remultMiddleware(options) {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
         addArea: x => server.addArea(x),
-        handle: req => m.handle(req)
+        handle: (req, res) => m.handle(req, res)
     });
 }
 class middleware {
@@ -114,3 +114,4 @@ class middleware {
         next();
     }
 }
+export { buildRemultServer };

package/esm/server/expressBridge.d.ts

@@ -5,7 +5,7 @@ import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-export declare type RemultMiddlewareOptions = {
+export declare type RemultServerOptions = {
     /** Sets a database connection for Remult.
      *
      * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
@@ -14,17 +14,17 @@ export declare type RemultMiddlewareOptions = {
     disableAutoApi?: boolean;
     queueStorage?: QueueStorage;
     initRequest?: (remult: Remult, origReq: GenericRequest) => Promise<void>;
+    getUser?: (request: GenericRequest) => Promise<UserInfo>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
     entities?: ClassType<any>[];
     controllers?: ClassType<any>[];
-    bodyParser?: boolean;
     rootPath?: string;
 };
-export declare function buildRemultServer(app: GenericRouter, options: RemultMiddlewareOptions): RemultServer;
-export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
-export interface RemultExpressBridge extends GenericRequestHandler, RemultServer {
+export declare function buildRemultServer(app: GenericRouter, options: RemultServerOptions): RemultServer;
+export declare type GenericMiddleware = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
+export interface RemultExpressBridge extends GenericMiddleware, RemultServer {
 }
 export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
@@ -37,10 +37,10 @@ export declare type GenericRouter = {
     route(path: string): SpecificRoute;
 };
 export declare type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
+    get(handler: GenericMiddleware): SpecificRoute;
+    put(handler: GenericMiddleware): SpecificRoute;
+    post(handler: GenericMiddleware): SpecificRoute;
+    delete(handler: GenericMiddleware): SpecificRoute;
 };
 export interface GenericRequest {
     url?: string;
@@ -48,8 +48,6 @@ export interface GenericRequest {
     body?: any;
     query?: any;
     params?: any;
-    user?: UserInfo;
-    auth?: UserInfo;
 }
 export interface GenericResponse {
     json(data: any): any;
@@ -60,7 +58,7 @@ export interface GenericResponse {
 declare class ExpressBridge {
     private app;
     queue: inProcessQueueHandler;
-    initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>;
+    options: RemultServerOptions;
     dataProvider: DataProvider | Promise<DataProvider>;
     openApiDoc(options: {
         title: string;
@@ -71,7 +69,7 @@ declare class ExpressBridge {
         allowed: AllowedForInstance<any>;
         tag: string;
     }[];
-    constructor(app: GenericRouter, queue: inProcessQueueHandler, initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>, dataProvider: DataProvider | Promise<DataProvider>);
+    constructor(app: GenericRouter, queue: inProcessQueueHandler, options: RemultServerOptions, dataProvider: DataProvider | Promise<DataProvider>);
     logApiEndPoints: boolean;
     private firstArea;
     addArea(rootUrl: string): SiteArea;

package/esm/server/expressBridge.js

@@ -37,7 +37,7 @@ export function buildRemultServer(app, options) {
             return dp;
         });
     }
-    let bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options.initRequest, dataProvider);
+    let bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     if (options.logApiEndPoints !== undefined)
         bridge.logApiEndPoints = options.logApiEndPoints;
     if (options.rootPath === undefined)
@@ -56,10 +56,10 @@ export function buildRemultServer(app, options) {
 }
 ;
 class ExpressBridge {
-    constructor(app, queue, initRequest, dataProvider) {
+    constructor(app, queue, options, dataProvider) {
         this.app = app;
         this.queue = queue;
-        this.initRequest = initRequest;
+        this.options = options;
         this.dataProvider = dataProvider;
         /* internal */
         this.backendMethodsOpenApi = [];
@@ -393,14 +393,19 @@ export class SiteArea {
             let remult = new Remult();
             remult.setDataProvider(await this.bridge.dataProvider);
             if (req) {
-                let user = req['user'];
-                if (!user)
-                    user = req['auth'];
+                let user;
+                if (this.bridge.options.getUser)
+                    user = await this.bridge.options.getUser(req);
+                else {
+                    user = req['user'];
+                    if (!user)
+                        user = req['auth'];
+                }
                 if (user)
                     remult.setUser(user);
             }
-            if (this.bridge.initRequest) {
-                await this.bridge.initRequest(remult, req);
+            if (this.bridge.options.initRequest) {
+                await this.bridge.options.initRequest(remult, req);
             }
             what(remult, myReq, myRes, req);
         };

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -6,14 +6,14 @@ import { Action, BackendMethod } from '../server-action';
 Remult.apiBaseUrl = 'http://localhost:3003/api';
 let path = Remult.apiBaseUrl + '/tasks';
 const environments = [
-    ["next", 3000],
-    ["nest", 3001],
-    ["koa", 3002],
-    ["fastify", 3003],
-    ["express", 3004],
-    ["middleware", 3005],
-    ["optine", 3006],
-    ["fresh", 8000],
+// ["next", 3000],
+// ["nest", 3001],
+// ["koa", 3002],
+// ["fastify", 3003],
+// ["express", 3004],
+// ["middleware", 3005],
+// ["optine", 3006],
+// ["fresh", 8000],
 ];
 function test(name, test) {
     for (const [env, port] of environments) {

package/esm/src/context.d.ts

@@ -40,12 +40,7 @@ export declare class Remult {
     /** Returns the current user's info */
     get user(): UserInfo;
     /** Set's the current user info */
-    setUser(info: UserInfo | {
-        sub?: string;
-        name?: string;
-        permissions?: string[];
-        username?: string;
-    }): Promise<void>;
+    setUser(info: UserInfo): Promise<void>;
     private _user;
     private _userChangeEvent;
     /** Checks if a user was authenticated */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.28",
+    "version": "0.14.31",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -36,6 +36,10 @@
             "require": "./remult-fastify.js",
             "import": "./esm/remult-fastify.js"
         },
+        "./remult-fresh": {
+            "require": "./remult-fresh.js",
+            "import": "./esm/remult-fresh.js"
+        },
         "./postgres": {
             "require": "./postgres/index.js",
             "import": "./esm/postgres/index.js"

package/readme.md

@@ -35,13 +35,13 @@
 
 ### Status
 
-Remult is **production-ready** and, in fact, used in production apps since 2017. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
+Remult is **production-ready** and, in fact, used in production apps since 2018. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
 
 ## Motivation
 
 Full-stack web development is (still) too complicated. **Simple CRUD, a common requirement of any business application, should be simple to build, maintain, and extend** when the need arises.
 
-Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult let you write TypeScript code you can follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
+Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult helps building fullstack apps using only TypeScript code you can easily follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
 
 Other frameworks tend to fall into either too much abstraction (no-code, low-code, BaaS) or partial abstraction (MVC frameworks, GraphQL, ORMs, API generators, code generators), and tend to be opinionated regarding the development tool-chain, deployment environment, configuration/conventions or DSL. Remult attempts to strike a better balance.
 

package/remult-express.d.ts

@@ -1,5 +1,5 @@
-import { RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultMiddlewareOptions & {
+import { RemultServerOptions } from './server/expressBridge';
+export declare function remultExpress(options?: RemultServerOptions & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
 }): import("express-serve-static-core").Router & {

package/remult-fastify.d.ts

@@ -1,3 +1,3 @@
 import type { FastifyPluginCallback } from 'fastify';
-import { RemultServer, RemultMiddlewareOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultMiddlewareOptions): FastifyPluginCallback & RemultServer;
+import { RemultServer, RemultServerOptions } from './server/expressBridge';
+export declare function remultFastify(options: RemultServerOptions): FastifyPluginCallback & RemultServer;

package/remult-fastify.js

@@ -24,7 +24,7 @@ function remultFastify(options) {
         return response;
     }
     var api;
-    var pluginFunction = function (instance, options) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+    var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {
             fastifyRouter = {

package/remult-fresh.d.ts

@@ -0,0 +1,22 @@
+import { RemultServerOptions, RemultServer } from "./server/expressBridge";
+import { Remult } from "./src/context";
+export declare function remultFresh(options: RemultServerOptions, response: FreshResponse): RemultFresh;
+export interface RemultFresh extends RemultServer {
+    handle(req: FreshRequest, ctx: FreshContext): Promise<FreshResponse>;
+}
+export interface FreshRequest {
+    url: string;
+    method: string;
+    json: () => Promise<any>;
+}
+export interface FreshContext {
+    next: () => Promise<any>;
+    state: FreshRemultState;
+}
+export interface FreshResponse {
+    new (body?: any | undefined, init?: ResponseInit): any;
+    json(data: unknown, init?: ResponseInit): any;
+}
+export interface FreshRemultState {
+    remult: Remult;
+}

package/remult-fresh.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultFresh = void 0;
+var tslib_1 = require("tslib");
+var remult_middleware_1 = require("./remult-middleware");
+function remultFresh(options, response) {
+    var _this = this;
+    var mw = remult_middleware_1.remultMiddleware(options);
+    var orig = mw.handle;
+    return tslib_1.__assign(tslib_1.__assign({}, mw), {
+        handle: function (req, ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var theReq, _a, _b, init, res, remult;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        theReq = {
+                            method: req.method,
+                            url: req.url,
+                            body: undefined
+                        };
+                        _a = req.method.toLocaleLowerCase();
+                        switch (_a) {
+                            case "put": return [3 /*break*/, 1];
+                            case "post": return [3 /*break*/, 1];
+                        }
+                        return [3 /*break*/, 3];
+                    case 1:
+                        console.log(req);
+                        _b = theReq;
+                        return [4 /*yield*/, req.json()];
+                    case 2:
+                        _b.body = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 3:
+                        init = {};
+                        return [4 /*yield*/, orig(theReq)];
+                    case 4:
+                        res = _c.sent();
+                        if (!res) return [3 /*break*/, 5];
+                        if (res.statusCode)
+                            init.status = res.statusCode;
+                        if (res.data) {
+                            console.log({ init: init, res: res });
+                            return [2 /*return*/, response.json(res.data, init)];
+                        }
+                        else
+                            return [2 /*return*/, new response(undefined, init)];
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, mw.getRemult(req)];
+                    case 6:
+                        remult = _c.sent();
+                        ctx.state.remult = remult;
+                        return [2 /*return*/, ctx.next()];
+                    case 7:
+                        ;
+                        return [2 /*return*/];
+                }
+            });
+        }); }
+    });
+}
+exports.remultFresh = remultFresh;
+;

package/remult-middleware.d.ts

@@ -1,9 +1,10 @@
-import { GenericRequest, GenericRequestHandler, GenericResponse, RemultMiddlewareOptions, RemultServer } from './server/expressBridge';
-export declare function remultMiddleware(options?: RemultMiddlewareOptions): RemultMiddleware;
-export interface RemultMiddleware extends GenericRequestHandler, RemultServer {
+import { GenericRequest, GenericMiddleware, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultServerOptions): RemultMiddleware;
+export interface RemultMiddleware extends GenericMiddleware, RemultServer {
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<MiddlewareResponse>;
 }
 export interface MiddlewareResponse {
     data?: any;
     statusCode?: number;
 }
+export { GenericRequest, GenericMiddleware as GenericRequestHandler, GenericResponse, GenericRouter, buildRemultServer, RemultServerOptions as RemultMiddlewareOptions, SpecificRoute, RemultServer };

package/remult-middleware.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remultMiddleware = void 0;
+exports.buildRemultServer = exports.remultMiddleware = void 0;
 var tslib_1 = require("tslib");
 var expressBridge_1 = require("./server/expressBridge");
+Object.defineProperty(exports, "buildRemultServer", { enumerable: true, get: function () { return expressBridge_1.buildRemultServer; } });
 function remultMiddleware(options) {
     var m = new middleware();
     var server = expressBridge_1.buildRemultServer(m, options);
@@ -10,7 +11,7 @@ function remultMiddleware(options) {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
         addArea: function (x) { return server.addArea(x); },
-        handle: function (req) { return m.handle(req); }
+        handle: function (req, res) { return m.handle(req, res); }
     });
 }
 exports.remultMiddleware = remultMiddleware;

package/server/expressBridge.d.ts

@@ -5,7 +5,7 @@ import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-export declare type RemultMiddlewareOptions = {
+export declare type RemultServerOptions = {
     /** Sets a database connection for Remult.
      *
      * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
@@ -14,17 +14,17 @@ export declare type RemultMiddlewareOptions = {
     disableAutoApi?: boolean;
     queueStorage?: QueueStorage;
     initRequest?: (remult: Remult, origReq: GenericRequest) => Promise<void>;
+    getUser?: (request: GenericRequest) => Promise<UserInfo>;
     initApi?: (remult: Remult) => void | Promise<void>;
     logApiEndPoints?: boolean;
     defaultGetLimit?: number;
     entities?: ClassType<any>[];
     controllers?: ClassType<any>[];
-    bodyParser?: boolean;
     rootPath?: string;
 };
-export declare function buildRemultServer(app: GenericRouter, options: RemultMiddlewareOptions): RemultServer;
-export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
-export interface RemultExpressBridge extends GenericRequestHandler, RemultServer {
+export declare function buildRemultServer(app: GenericRouter, options: RemultServerOptions): RemultServer;
+export declare type GenericMiddleware = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
+export interface RemultExpressBridge extends GenericMiddleware, RemultServer {
 }
 export interface RemultServer {
     getRemult(req: GenericRequest): Promise<Remult>;
@@ -37,10 +37,10 @@ export declare type GenericRouter = {
     route(path: string): SpecificRoute;
 };
 export declare type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
+    get(handler: GenericMiddleware): SpecificRoute;
+    put(handler: GenericMiddleware): SpecificRoute;
+    post(handler: GenericMiddleware): SpecificRoute;
+    delete(handler: GenericMiddleware): SpecificRoute;
 };
 export interface GenericRequest {
     url?: string;
@@ -48,8 +48,6 @@ export interface GenericRequest {
     body?: any;
     query?: any;
     params?: any;
-    user?: UserInfo;
-    auth?: UserInfo;
 }
 export interface GenericResponse {
     json(data: any): any;
@@ -60,7 +58,7 @@ export interface GenericResponse {
 declare class ExpressBridge {
     private app;
     queue: inProcessQueueHandler;
-    initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>;
+    options: RemultServerOptions;
     dataProvider: DataProvider | Promise<DataProvider>;
     openApiDoc(options: {
         title: string;
@@ -71,7 +69,7 @@ declare class ExpressBridge {
         allowed: AllowedForInstance<any>;
         tag: string;
     }[];
-    constructor(app: GenericRouter, queue: inProcessQueueHandler, initRequest: (remult: Remult, origReq: GenericRequest) => Promise<void>, dataProvider: DataProvider | Promise<DataProvider>);
+    constructor(app: GenericRouter, queue: inProcessQueueHandler, options: RemultServerOptions, dataProvider: DataProvider | Promise<DataProvider>);
     logApiEndPoints: boolean;
     private firstArea;
     addArea(rootUrl: string): SiteArea;

package/server/expressBridge.js

@@ -49,7 +49,7 @@ function buildRemultServer(app, options) {
             });
         }); });
     }
-    var bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options.initRequest, dataProvider);
+    var bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     if (options.logApiEndPoints !== undefined)
         bridge.logApiEndPoints = options.logApiEndPoints;
     if (options.rootPath === undefined)
@@ -69,10 +69,10 @@ function buildRemultServer(app, options) {
 exports.buildRemultServer = buildRemultServer;
 ;
 var ExpressBridge = /** @class */ (function () {
-    function ExpressBridge(app, queue, initRequest, dataProvider) {
+    function ExpressBridge(app, queue, options, dataProvider) {
         this.app = app;
         this.queue = queue;
-        this.initRequest = initRequest;
+        this.options = options;
         this.dataProvider = dataProvider;
         /* internal */
         this.backendMethodsOpenApi = [];
@@ -449,19 +449,29 @@ var SiteArea = /** @class */ (function () {
                         return [4 /*yield*/, this.bridge.dataProvider];
                     case 1:
                         _b.apply(_a, [_c.sent()]);
-                        if (req) {
-                            user = req['user'];
-                            if (!user)
-                                user = req['auth'];
-                            if (user)
-                                remult.setUser(user);
-                        }
-                        if (!this.bridge.initRequest) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.bridge.initRequest(remult, req)];
+                        if (!req) return [3 /*break*/, 5];
+                        user = void 0;
+                        if (!this.bridge.options.getUser) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.bridge.options.getUser(req)];
                     case 2:
-                        _c.sent();
-                        _c.label = 3;
+                        user = _c.sent();
+                        return [3 /*break*/, 4];
                     case 3:
+                        user = req['user'];
+                        if (!user)
+                            user = req['auth'];
+                        _c.label = 4;
+                    case 4:
+                        if (user)
+                            remult.setUser(user);
+                        _c.label = 5;
+                    case 5:
+                        if (!this.bridge.options.initRequest) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.bridge.options.initRequest(remult, req)];
+                    case 6:
+                        _c.sent();
+                        _c.label = 7;
+                    case 7:
                         what(remult, myReq, myRes, req);
                         return [2 /*return*/];
                 }

package/src/backend-tests/test-http-server.backend-spec.js

@@ -9,14 +9,14 @@ var server_action_1 = require("../server-action");
 context_1.Remult.apiBaseUrl = 'http://localhost:3003/api';
 var path = context_1.Remult.apiBaseUrl + '/tasks';
 var environments = [
-    ["next", 3000],
-    ["nest", 3001],
-    ["koa", 3002],
-    ["fastify", 3003],
-    ["express", 3004],
-    ["middleware", 3005],
-    ["optine", 3006],
-    ["fresh", 8000],
+// ["next", 3000],
+// ["nest", 3001],
+// ["koa", 3002],
+// ["fastify", 3003],
+// ["express", 3004],
+// ["middleware", 3005],
+// ["optine", 3006],
+// ["fresh", 8000],
 ];
 function test(name, test) {
     var e_1, _a;

package/src/context.d.ts

@@ -40,12 +40,7 @@ export declare class Remult {
     /** Returns the current user's info */
     get user(): UserInfo;
     /** Set's the current user info */
-    setUser(info: UserInfo | {
-        sub?: string;
-        name?: string;
-        permissions?: string[];
-        username?: string;
-    }): Promise<void>;
+    setUser(info: UserInfo): Promise<void>;
     private _user;
     private _userChangeEvent;
     /** Checks if a user was authenticated */