remult 0.16.0-exp.7 → 0.16.1

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

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../src/column-interfaces';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;

package/esm/postgres/postgresColumnSyntax.js

@@ -0,0 +1,30 @@
+import { ValueConverters } from '../valueConverters';
+export function postgresColumnSyntax(x, dbName) {
+    let result = dbName;
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb)
+            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}

package/esm/remult-express.js

@@ -17,6 +17,7 @@ export function remultExpress(options) {
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
-        registerRouter: x => server.registerRouter(x)
+        registerRouter: x => server.registerRouter(x),
+        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/remult-middleware.d.ts

@@ -0,0 +1,2 @@
+import { RemultMiddlewareOptions } from './server/expressBridge';
+export declare function remultMiddleware(options?: RemultMiddlewareOptions): import("./server/expressBridge").RemultExpressBridge;

package/esm/remult-middleware.js

@@ -0,0 +1,65 @@
+import { remultMiddlewareBase } from './server/expressBridge';
+export function remultMiddleware(options) {
+    const m = new middleware();
+    let app = Object.assign((req, res, next) => m.handleRequest(req, res, next), {
+        route: (path) => m.route(path)
+    });
+    return remultMiddlewareBase(app, options);
+}
+class middleware {
+    constructor() {
+        this.map = new Map();
+    }
+    route(path) {
+        //consider using:
+        //* https://raw.githubusercontent.com/cmorten/opine/main/src/utils/pathToRegex.ts
+        //* https://github.com/pillarjs/path-to-regexp
+        let r = path.toLowerCase();
+        let m = new Map();
+        this.map.set(r, m);
+        const route = {
+            get: (h) => {
+                m.set("get", h);
+                return route;
+            },
+            put: (h) => {
+                m.set("put", h);
+                return route;
+            },
+            post: (h) => {
+                m.set("post", h);
+                return route;
+            },
+            delete: (h) => {
+                m.set("delete", h);
+                return route;
+            }
+        };
+        return route;
+    }
+    handleRequest(req, res, next) {
+        let lowerPath = req.path.toLowerCase();
+        let m = this.map.get(lowerPath);
+        if (m) {
+            let h = m.get(req.method.toLowerCase());
+            if (h) {
+                h(req, res, next);
+                return;
+            }
+        }
+        let idPosition = req.path.lastIndexOf('/');
+        if (idPosition >= 0) {
+            lowerPath = req.path.substring(0, idPosition) + '/:id';
+            m = this.map.get(lowerPath);
+            if (m) {
+                let h = m.get(req.method.toLowerCase());
+                if (h) {
+                    req.params.id = req.path.substring(idPosition + 1);
+                    h(req, res, next);
+                    return;
+                }
+            }
+        }
+        next();
+    }
+}

package/esm/server/expressBridge.d.ts

@@ -33,6 +33,7 @@ export interface RemultServer {
     }): any;
     registerRouter(r: GenericRouter): void;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
+    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,16 +105,9 @@ 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");
-            };
-        }
+    }
+    withRemult(req, res, next) {
+        this.process(async () => { next(); })(req, res);
     }
     handle(req, gRes) {
         if (!this.routeImpl) {
@@ -120,7 +147,8 @@ class RemultServerImplementation {
                             else
                                 res.success(job.info);
                         });
-                    }
+                    },
+                    doWork: undefined
                 }, r);
         }
         this.options.entities.forEach(e => {
@@ -152,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) {
@@ -165,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/server/register-actions-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerActionsOnServer(area: SiteArea, controllers?: ClassType<any>[]): void;

package/esm/server/register-actions-on-server.js

@@ -0,0 +1,24 @@
+import { serverActionField, actionInfo, classBackendMethodsArray } from '../src/server-action';
+export function registerActionsOnServer(area, controllers) {
+    var addAction = (a) => {
+        let x = a[serverActionField];
+        if (!x) {
+            throw 'failed to set server action, did you forget the BackendMethod Decorator?';
+        }
+        area.addAction(x);
+    };
+    actionInfo.runningOnServer = true;
+    if (controllers && controllers.length > 0) {
+        for (const c of controllers) {
+            let z = c[classBackendMethodsArray];
+            if (z)
+                for (const a of z) {
+                    addAction(a);
+                }
+        }
+    }
+    else
+        actionInfo.allActions.forEach((a) => {
+            addAction(a);
+        });
+}

package/esm/server/register-entities-on-server.d.ts

@@ -0,0 +1,3 @@
+import { SiteArea } from "./expressBridge";
+import { ClassType } from "../classType";
+export declare function registerEntitiesOnServer(area: SiteArea, entities?: ClassType<any>[]): void;

package/esm/server/register-entities-on-server.js

@@ -0,0 +1,15 @@
+import { getEntityKey } from "../src/remult3";
+import { allEntities } from "../src/context";
+import { DataApi } from "../src/data-api";
+export function registerEntitiesOnServer(area, entities) {
+    if (!entities)
+        entities = allEntities;
+    //add Api Entries
+    entities.forEach(e => {
+        let key = getEntityKey(e);
+        if (key != undefined)
+            area.add(key, c => {
+                return new DataApi(c.repo(e), c);
+            });
+    });
+}

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);