remult 0.16.0-exp.8 → 0.16.2-exp.0

package/esm/index.d.ts

@@ -12,7 +12,7 @@ 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, isBackend, AllowedForInstance, EventDispatcher, EventSource, HttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';

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

@@ -81,14 +81,14 @@ export async function createPostgresConnection(options) {
     }
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
-    remult.setDataProvider(db);
+    remult.dataProvider = (db);
     if (options.autoCreateTables === undefined || options.autoCreateTables)
         await verifyStructureOfAllEntities(db, remult);
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
     let c = new Remult();
-    c.setDataProvider(sql);
+    c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
     await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);

package/esm/remult-express.js

@@ -18,6 +18,6 @@ export function remultExpress(options) {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
         registerRouter: x => server.registerRouter(x),
-        withRemultMiddleware: (...args) => server.withRemultMiddleware(...args)
+        withRemult: (...args) => server.withRemult(...args)
     });
 }

package/esm/remult-fastify.js

@@ -47,6 +47,7 @@ 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)
+        handle: (req, res) => api.handle(req, res),
+        withRemult: (req, res, next) => api.withRemult(req, res, next)
     });
 }

package/esm/server/expressBridge.d.ts

@@ -33,7 +33,7 @@ export interface RemultServer {
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemultMiddleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
+    withRemult(req: GenericRequest, res: GenericResponse, next: VoidFunction): any;
 }
 export declare type GenericRouter = {
     route(path: string): SpecificRoute;

package/esm/server/expressBridge.js

@@ -4,7 +4,6 @@ import { DataApi, serializeError } from '../src/data-api';
 import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { AsyncLocalStorage } from 'async_hooks';
 import { remult } from '../src/remult-proxy';
 ;
 export function createRemultServer(options) {
@@ -31,6 +30,25 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
+    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);
@@ -54,14 +72,30 @@ export function createRemultServer(options) {
         options.controllers = allControllers;
     }
     if (options.rootPath === undefined)
-        options.rootPath = Remult.apiBaseUrl;
+        options.rootPath = '/api';
     actionInfo.runningOnServer = true;
     let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     return bridge;
 }
 ;
-const remultObjectStorage = new AsyncLocalStorage();
-let remultObjectStorageWasSetup = false;
+class RemultAsyncLocalStorage {
+    constructor(remultObjectStorage) {
+        this.remultObjectStorage = remultObjectStorage;
+    }
+    run(remult, callback) {
+        if (this.remultObjectStorage)
+            this.remultObjectStorage.run(remult, callback);
+        else
+            callback();
+    }
+    getRemult() {
+        if (!this.remultObjectStorage) {
+            throw "can't use static remult in this environment, `async_hooks` were not found";
+        }
+        return this.remultObjectStorage.getStore();
+    }
+}
+let remultObjectStorage;
 class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
@@ -71,18 +105,8 @@ class RemultServerImplementation {
         this.hasQueue = false;
         /* internal */
         this.backendMethodsOpenApi = [];
-        if (!remultObjectStorageWasSetup) {
-            remultObjectStorageWasSetup = true;
-            remult.remultFactory = () => {
-                const r = remultObjectStorage.getStore();
-                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");
-            };
-        }
     }
-    withRemultMiddleware(req, res, next) {
+    withRemult(req, res, next) {
         this.process(async () => { next(); })(req, res);
     }
     handle(req, gRes) {
@@ -123,7 +147,8 @@ class RemultServerImplementation {
                             else
                                 res.success(job.info);
                         });
-                    }
+                    },
+                    doWork: undefined
                 }, r);
         }
         this.options.entities.forEach(e => {
@@ -155,7 +180,7 @@ class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.setDataProvider(await this.dataProvider);
+            remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
                 remultObjectStorage.run(remult, async () => {
                     if (req) {
@@ -168,7 +193,7 @@ class RemultServerImplementation {
                                 user = req['auth'];
                         }
                         if (user)
-                            remult.setUser(user);
+                            remult.user = (user);
                     }
                     if (this.options.initRequest) {
                         await this.options.initRequest(remult, req);

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

@@ -1,28 +1,28 @@
 import { __decorate, __metadata } from "tslib";
 import axios from 'axios';
 import { remultFresh } from '../../remult-fresh';
-import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { remult } from '../remult-proxy';
 import { Entity, Fields } from '../remult3';
 import { BackendMethod } from '../server-action';
 import { Categories } from '../tests/remult-3-entities';
-Remult.apiBaseUrl = 'http://localhost:3003/api';
-let path = Remult.apiBaseUrl + '/tasks';
+remult.apiClient.url = 'http://localhost:3003/api';
+let path = remult.apiClient.url + '/tasks';
 const environments = [
 // ["next", 3000],
 // ["nest", 3001],
-// ["koa", 3002],
-// ["fastify", 3003],
-// ["express", 3004],
-// ["generic server", 3005],
+//  ["koa", 3002],
+//  ["fastify", 3003],
+//  ["express", 3004],
+//  ["generic server", 3005],
 // ["optine", 3006],
 // ["fresh", 8000]
 ];
 function test(name, test) {
     for (const [env, port] of environments) {
         const theTest = async () => {
-            Remult.apiBaseUrl = `http://localhost:${port}/api`;
-            path = Remult.apiBaseUrl + '/tasks';
+            remult.apiClient.url = `http://localhost:${port}/api`;
+            path = remult.apiClient.url + '/tasks';
             await test();
         };
         const testName = env + ` ${port}: ${name}`;
@@ -93,7 +93,7 @@ test("test http 201", async () => {
 });
 test("test regular api call", async () => {
     await create3Tasks();
-    let result = await axios.get(Remult.apiBaseUrl + "/test");
+    let result = await axios.get(remult.apiClient.url + "/test");
     expect(result.data.result).toBe(3);
 });
 class FreshResponseTest {
@@ -106,9 +106,11 @@ class FreshResponseTest {
     }
 }
 it("test fresh", async () => {
-    const api = remultFresh({ entities: [Categories],
+    const api = remultFresh({
+        entities: [Categories],
         dataProvider: new InMemoryDataProvider(),
-        rootPath: '/api' }, FreshResponseTest);
+        rootPath: '/api'
+    }, FreshResponseTest);
     const r = await api.handle({
         url: '/api/Categories',
         json() {
@@ -157,8 +159,7 @@ Task = __decorate([
 ], Task);
 export { Task };
 async function create3Tasks() {
-    const remult = new Remult(axios);
-    Remult.defaultHttpProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
+    remult.apiClient.httpClient = axios;
     const taskRepo = remult.repo(Task);
     for (const task of await taskRepo.find()) {
         await taskRepo.delete(task);

package/esm/src/context.d.ts

@@ -1,7 +1,8 @@
 import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-export interface HttpProvider {
+export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
     };
@@ -17,7 +18,7 @@ export interface HttpProvider {
 }
 export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
     private http;
-    constructor(http: HttpProvider);
+    constructor(http: ExternalHttpProvider);
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;
@@ -37,10 +38,7 @@ export declare class Remult {
      *
      */
     repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
-    /** Returns the current user's info */
-    get user(): UserInfo;
-    /** Set's the current user info */
-    setUser(info: UserInfo | undefined): Promise<void>;
+    user?: UserInfo;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
     /** checks if the user has any of the roles specified in the parameters
@@ -55,35 +53,32 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange(): EventDispatcher;
-    static defaultHttpProvider: RestDataProviderHttpProvider;
-    static setDefaultHttpProvider(provider: HttpProvider | typeof fetch): void;
     /** Creates a new instance of the `remult` object.
      *
      * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
      *
      * If no provider is specified, `fetch` will be used as an http provider
      */
-    constructor(provider?: HttpProvider | DataProvider | typeof fetch);
-    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
-     *
-     * Set this property in case you want to determine a non relative api url
-     */
-    static apiBaseUrl: string;
+    constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
+    constructor(p: DataProvider);
+    constructor();
+    call<T extends ((...args: any[]) => Promise<Y>), Y>(backendMethod: T, self?: any): T;
     /** The current data provider */
-    _dataSource: DataProvider;
-    /** sets the current data provider */
-    setDataProvider(dataProvider: DataProvider): void;
+    dataProvider: DataProvider;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
     readonly context: RemultContext;
+    apiClient: ApiClient;
 }
 export interface RemultContext {
 }
+export interface ApiClient {
+    httpClient?: ExternalHttpProvider | typeof fetch;
+    url?: string;
+}
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
     key: string;
@@ -95,11 +90,12 @@ export declare class ClassHelper {
 export declare class MethodHelper {
     classes: Map<any, ControllerOptions>;
 }
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider | RestDataProviderHttpProviderUsingFetch;
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;
-    name: string;
-    roles: string[];
+    name?: string;
+    roles?: string[];
 }
 export declare type Allowed = boolean | string | string[] | ((c: Remult) => boolean);
 export declare type AllowedForInstance<T> = boolean | string | string[] | ((c: Remult, entity?: T) => boolean);

package/esm/src/context.js

@@ -1,4 +1,4 @@
-import { actionInfo } from './server-action';
+import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
@@ -75,6 +75,8 @@ export async function processHttpException(ex) {
             message: error,
         };
     }
+    if (z.modelState)
+        error.modelState = z.modelState;
     let httpStatusCode = z.status;
     if (httpStatusCode === undefined)
         httpStatusCode = z.response?.status;
@@ -90,27 +92,31 @@ export function isBackend() {
     return actionInfo.runningOnServer;
 }
 export class Remult {
-    /** Creates a new instance of the `remult` object.
-     *
-     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
-     *
-     * If no provider is specified, `fetch` will be used as an http provider
-     */
     constructor(provider) {
-        /* @internal */
-        this._userChangeEvent = new EventSource();
         /* @internal */
         this.repCache = new Map();
+        /** The current data provider */
+        this.dataProvider = new RestDataProvider(() => this.apiClient);
         this.context = {};
+        this.apiClient = {
+            url: '/api'
+        };
         if (provider && provider.getEntityDataProvider) {
-            this._dataSource = provider;
+            this.dataProvider = provider;
             return;
         }
-        let httpDataProvider = buildRestDataProvider(provider);
-        if (!httpDataProvider) {
-            httpDataProvider = new UseDefaultRestDataProviderHttpProvider();
+        if (isExternalHttpProvider(provider)) {
+            this.apiClient.httpClient = provider;
+        }
+        else if (typeof (provider) === "function")
+            this.apiClient.httpClient = provider;
+        else if (provider) {
+            const apiClient = provider;
+            if (apiClient.httpClient)
+                this.apiClient.httpClient = apiClient.httpClient;
+            if (apiClient.url)
+                this.apiClient.url = apiClient.url;
         }
-        this._dataSource = new RestDataProvider(null, httpDataProvider);
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -120,7 +126,7 @@ export class Remult {
      */
     repo(entity, dataProvider) {
         if (dataProvider === undefined)
-            dataProvider = this._dataSource;
+            dataProvider = this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, dpCache = new Map());
@@ -130,39 +136,10 @@ export class Remult {
         }
         return r;
     }
-    /** Returns the current user's info */
-    get user() {
-        if (this._user === undefined) {
-            return {
-                id: undefined,
-                name: '',
-                roles: []
-            };
-        }
-        return this._user;
-    }
-    /** Set's the current user info */
-    async setUser(info) {
-        this._user = info;
-        if (this._user === null)
-            this._user = undefined;
-        let auth = info;
-        if (auth) {
-            if (!this._user.id && auth.sub)
-                this._user.id = auth.sub;
-            if (!this._user.roles && auth.permissions) {
-                this._user.roles = auth.permissions;
-            }
-            if (!this._user.name)
-                this._user.name = auth.username;
-        }
-        if (this._user && !this._user.roles)
-            this._user.roles = [];
-        await this._userChangeEvent.fire();
-    }
+    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
-        return this.user.id !== undefined;
+        return this.user?.id !== undefined;
     }
     /** checks if the user has any of the roles specified in the parameters
      * @example
@@ -187,7 +164,7 @@ export class Remult {
         if (typeof roles === 'boolean')
             return roles;
         if (typeof roles === 'string')
-            if (this.user.roles.indexOf(roles.toString()) >= 0)
+            if (this.user?.roles?.indexOf(roles.toString()) >= 0)
                 return true;
         return false;
     }
@@ -210,46 +187,22 @@ export class Remult {
         else
             return this.isAllowed(allowed);
     }
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange() {
-        return this._userChangeEvent.dispatcher;
-    }
-    static setDefaultHttpProvider(provider) {
-        const r = buildRestDataProvider(provider);
-        if (!r)
-            throw provider + " doesn't match http provider or fetch interface";
-        Remult.defaultHttpProvider = r;
-    }
-    /** sets the current data provider */
-    setDataProvider(dataProvider) {
-        this._dataSource = dataProvider;
+    call(backendMethod, self) {
+        const z = (backendMethod[serverActionField]);
+        if (!z.doWork)
+            throw Error("The method received is not a valid backend method");
+        //@ts-ignore
+        return (...args) => {
+            return z.doWork(args, self, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
+        };
     }
     clearAllCache() {
         this.repCache.clear();
     }
 }
-Remult.defaultHttpProvider = new RestDataProviderHttpProviderUsingFetch();
-/** The api Base Url to be used in all remult calls. by default it's set to `/api`.
- *
- * Set this property in case you want to determine a non relative api url
- */
-Remult.apiBaseUrl = '/api';
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
-class UseDefaultRestDataProviderHttpProvider {
-    post(url, data) {
-        return Remult.defaultHttpProvider.post(url, data);
-    }
-    delete(url) {
-        return Remult.defaultHttpProvider.delete(url);
-    }
-    put(url, data) {
-        return Remult.defaultHttpProvider.put(url, data);
-    }
-    get(url) {
-        return Remult.defaultHttpProvider.get(url);
-    }
-}
+;
 export const allEntities = [];
 export const classHelpers = new Map();
 export class ClassHelper {
@@ -262,12 +215,19 @@ export class MethodHelper {
         this.classes = new Map();
     }
 }
-function buildRestDataProvider(provider) {
+function isExternalHttpProvider(item) {
+    let http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+export function buildRestDataProvider(provider) {
+    if (!provider)
+        return new RestDataProviderHttpProviderUsingFetch();
     let httpDataProvider;
     if (!httpDataProvider) {
-        let http = provider;
-        if (http && http.get && http.put && http.post && http.delete) {
-            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
+        if (isExternalHttpProvider(provider)) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
         }
     }
     if (!httpDataProvider) {

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

@@ -1,7 +1,6 @@
 import { Sort } from './sort';
 import { Filter } from './filter/filter-interfaces';
 import { EntityMetadata, OmitEB } from './remult3';
-import { HttpProvider } from './context';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
@@ -20,7 +19,7 @@ export interface EntityDataProviderFindOptions {
     page?: number;
     orderBy?: Sort;
 }
-export interface RestDataProviderHttpProvider extends HttpProvider {
+export interface RestDataProviderHttpProvider {
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -2,10 +2,10 @@ import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDa
 import { UrlBuilder } from '../../urlBuilder';
 import { Filter } from '../filter/filter-interfaces';
 import { EntityMetadata } from '../remult3';
+import { ApiClient } from '../context';
 export declare class RestDataProvider implements DataProvider {
-    private url;
-    private http;
-    constructor(url: string | null, http: RestDataProviderHttpProvider);
+    private apiProvider;
+    constructor(apiProvider: () => ApiClient);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;
@@ -14,7 +14,7 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;
     private http;
     private entity;
-    constructor(url: string, http: RestDataProviderHttpProvider, entity: EntityMetadata);
+    constructor(url: () => string, http: () => RestDataProviderHttpProvider, entity: EntityMetadata);
     translateFromJson(row: any): {};
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;
@@ -30,6 +30,9 @@ export declare class RestDataProviderHttpProviderUsingFetch implements RestDataP
     put(url: string, data: any): Promise<any>;
     delete(url: string): Promise<any>;
     post(url: string, data: any): Promise<any>;
-    myFetch(url: string, init?: RequestInit): Promise<any>;
+    myFetch(url: string, options?: {
+        method?: string;
+        body?: string;
+    }): Promise<any>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;