remult 0.13.19 → 0.13.20

package/graphql.js

@@ -98,15 +98,15 @@ function remultGraphql(api) {
             root[key] = function (_a, req) {
                 var options = _a.options, filter = _a.filter;
                 return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var remult, repo, dapi, result, err;
+                    var remult, repo, dApi, result, err;
                     return tslib_1.__generator(this, function (_b) {
                         switch (_b.label) {
                             case 0: return [4 /*yield*/, api.getRemult(req)];
                             case 1:
                                 remult = _b.sent();
                                 repo = remult.repo(e);
-                                dapi = new data_api_1.DataApi(repo, remult);
-                                return [4 /*yield*/, dapi.getArray({
+                                dApi = new data_api_1.DataApi(repo, remult);
+                                return [4 /*yield*/, dApi.getArray({
                                         success: function (x) { return result = x; },
                                         created: undefined,
                                         deleted: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.13.19",
+    "version": "0.13.20",
     "description": "remult core lib",
     "homepage": "https://remult.dev/",
     "repository": {

package/server/expressBridge.js

@@ -453,6 +453,8 @@ var SiteArea = /** @class */ (function () {
                         _b.apply(_a, [_c.sent()]);
                         if (req) {
                             user = req['user'];
+                            if (!user)
+                                user = req['auth'];
                             if (user)
                                 remult.setUser(user);
                         }

package/src/column-interfaces.d.ts

@@ -2,24 +2,65 @@ import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
-    key?: string;
-    target?: ClassType<entityType>;
-    valueType?: any;
+    /**A human readable name for the field */
     caption?: string;
-    displayValue?: (entity: entityType, value: valueType) => string;
-    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
+    /** If it can store null in the database */
+    allowNull?: boolean;
+    /** If this field data is included in the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    includeInApi?: Allowed;
+    /** If this field data can be updated in the api.
+    * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    allowApiUpdate?: AllowedForInstance<entityType>;
+    /** An arrow function that'll be used to perform validations on it
+     * @example
+     * .@Fields.string({
+     *   validate: Validators.required
+     * })
+     * @example
+     * .@Fields.string<Task>({
+     *    validate: task=>{
+     *      if (task.title.length<3)
+     *          throw "Too Short";
+     *   }
+     * })
+     * @example
+     * .@Fields.string({
+     *    validate: (_, fieldRef)=>{
+     *      if (fieldRef.value.length<3)
+     *          fieldRef.error = "Too Short";
+     *   }
+     * })
+     */
     validate?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    /** Will be fired before this field is saved to the server/database */
     saving?: ((entity: entityType, col: FieldRef<entityType, valueType>) => (any | Promise<any>));
-    inputType?: string;
-    allowNull?: boolean;
+    /**  An expression that will determine this fields value on the backend and be provided to the front end*/
+    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
+    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
     dbName?: string;
+    /** Used or fields that are based on an sql expressions, instead of a physical table column */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
-    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
+    /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
+    /** The value converter to be used when loading and saving this field */
     valueConverter?: ValueConverter<valueType>;
-    includeInApi?: Allowed;
-    allowApiUpdate?: AllowedForInstance<entityType>;
+    /** an arrow function that translates the value to a display value */
+    displayValue?: (entity: entityType, value: valueType) => string;
+    /** an arrow function that determines the default value of the field, when the entity is created using the `repo.create` method */
+    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
+    /** The html input type for this field */
+    inputType?: string;
+    /** Determines if the referenced entity will be loaded immediately or on demand.
+     * @see[Lazy loading of related entities](http://remult.dev/docs/lazy-loading-of-related-entities.html)
+     */
     lazy?: boolean;
+    /** The value type for this field */
+    valueType?: any;
+    /** The entity type to which this field belongs */
+    target?: ClassType<entityType>;
+    /** The key to be used for this field */
+    key?: string;
 }
 export interface FieldMetadata<valueType = any> {
     readonly key: string;

package/src/column.d.ts

@@ -44,7 +44,6 @@ export declare class OneToMany<T> {
     private _currentPromise;
     get lazyItems(): T[];
     load(): Promise<T[]>;
-    reload(): Promise<T[]>;
     private find;
     create(item?: Partial<T>): T;
 }

package/src/column.js

@@ -131,8 +131,6 @@ var OneToMany = /** @class */ (function () {
     function OneToMany(provider, settings) {
         this.provider = provider;
         this.settings = settings;
-        if (!this.settings)
-            this.settings = {};
     }
     Object.defineProperty(OneToMany.prototype, "lazyItems", {
         get: function () {
@@ -159,14 +157,6 @@ var OneToMany = /** @class */ (function () {
             });
         });
     };
-    OneToMany.prototype.reload = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                this._currentPromise = undefined;
-                return [2 /*return*/, this.load()];
-            });
-        });
-    };
     OneToMany.prototype.find = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
@@ -178,8 +168,6 @@ var OneToMany = /** @class */ (function () {
         var r = this.provider.create();
         remult3_1.__updateEntityBasedOnWhere(this.provider.metadata, this.settings.where, r);
         assign_1.assign(r, item);
-        if (this.settings.create)
-            this.settings.create(r);
         return r;
     };
     return OneToMany;

package/src/context.d.ts

@@ -1,4 +1,4 @@
-import { DataProvider } from "./data-interfaces";
+import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
 export interface HttpProvider {
@@ -15,33 +15,76 @@ export interface HttpProvider {
         toPromise(): Promise<any>;
     };
 }
+export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
+    private http;
+    constructor(http: HttpProvider);
+    post(url: string, data: any): Promise<any>;
+    delete(url: string): Promise<void>;
+    put(url: string, data: any): Promise<any>;
+    get(url: string): Promise<any>;
+}
+export declare function retry<T>(what: () => Promise<T>): Promise<T>;
 export declare function toPromise<T>(p: Promise<T> | {
     toPromise(): Promise<T>;
 }): Promise<any>;
 export declare function processHttpException(ex: any): Promise<any>;
 export declare function isBackend(): boolean;
 export declare class Remult {
-    static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
-    clearAllCache(): any;
-    static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
-    authenticated(): boolean;
-    constructor(provider?: HttpProvider | DataProvider);
-    _dataSource: DataProvider;
-    setDataProvider(dataProvider: DataProvider): void;
-    protected _user: UserInfo;
+    /**Return's a `Repository` of the specific entity type
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * @see [Repository](https://remult.dev/docs/ref_repository.html)
+     *
+     */
+    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** Returns the current user's info */
     get user(): UserInfo;
-    private _userChangeEvent;
-    get userChange(): EventDispatcher;
+    /** Set's the current user info */
     setUser(info: UserInfo | {
         sub?: string;
         name?: string;
         permissions?: string[];
     }): Promise<void>;
-    static apiBaseUrl: string;
-    isAllowedForInstance(instance: any, x: AllowedForInstance<any>): boolean;
+    private _user;
+    private _userChangeEvent;
+    /** Checks if a user was authenticated */
+    authenticated(): boolean;
+    /** checks if the user has any of the roles specified in the parameters
+     * @example
+     * remult.isAllowed("admin")
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
     isAllowed(roles: Allowed): boolean;
+    /** checks if the user matches the allowedForInstance callback
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
+    isAllowedForInstance(instance: any, x: AllowedForInstance<any>): boolean;
+    /** returns a dispatcher object that fires once a user has changed*/
+    get userChange(): EventDispatcher;
     private repCache;
-    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
+    /** 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);
+    /** 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;
+    /** The current data provider */
+    _dataSource: DataProvider;
+    /** sets the current data provider */
+    setDataProvider(dataProvider: DataProvider): void;
+    /** 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;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {

package/src/context.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSource = exports.queryConfig = exports.Allow = exports.setControllerSettings = exports.MethodHelper = exports.ClassHelper = exports.classHelpers = exports.allEntities = exports.Remult = exports.isBackend = exports.processHttpException = exports.toPromise = void 0;
+exports.EventSource = exports.queryConfig = exports.Allow = exports.setControllerSettings = exports.MethodHelper = exports.ClassHelper = exports.classHelpers = exports.allEntities = exports.Remult = exports.isBackend = exports.processHttpException = exports.toPromise = exports.retry = exports.HttpProviderBridgeToRestDataProviderHttpProvider = void 0;
 var tslib_1 = require("tslib");
 var server_action_1 = require("./server-action");
 var rest_data_provider_1 = require("./data-providers/rest-data-provider");
@@ -39,29 +39,30 @@ var HttpProviderBridgeToRestDataProviderHttpProvider = /** @class */ (function (
     };
     return HttpProviderBridgeToRestDataProviderHttpProvider;
 }());
+exports.HttpProviderBridgeToRestDataProviderHttpProvider = HttpProviderBridgeToRestDataProviderHttpProvider;
 function retry(what) {
-    var _a, _b;
+    var _a, _b, _c;
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var err_1;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     if (!true) return [3 /*break*/, 7];
-                    _c.label = 1;
+                    _d.label = 1;
                 case 1:
-                    _c.trys.push([1, 3, , 6]);
+                    _d.trys.push([1, 3, , 6]);
                     return [4 /*yield*/, what()];
-                case 2: return [2 /*return*/, _c.sent()];
+                case 2: return [2 /*return*/, _d.sent()];
                 case 3:
-                    err_1 = _c.sent();
-                    if (!(((_a = err_1.message) === null || _a === void 0 ? void 0 : _a.startsWith("Error occurred while trying to proxy")) || ((_b = err_1.message) === null || _b === void 0 ? void 0 : _b.startsWith("Error occured while trying to proxy")))) return [3 /*break*/, 5];
+                    err_1 = _d.sent();
+                    if (!(((_a = err_1.message) === null || _a === void 0 ? void 0 : _a.startsWith("Error occurred while trying to proxy")) || ((_b = err_1.message) === null || _b === void 0 ? void 0 : _b.startsWith("Error occured while trying to proxy")) || ((_c = err_1.message) === null || _c === void 0 ? void 0 : _c.startsWith("Gateway Timeout")))) return [3 /*break*/, 5];
                     return [4 /*yield*/, new Promise(function (res, req) {
                             setTimeout(function () {
                                 res({});
                             }, 250);
                         })];
                 case 4:
-                    _c.sent();
+                    _d.sent();
                     return [3 /*break*/, 0];
                 case 5: throw err_1;
                 case 6: return [3 /*break*/, 0];
@@ -70,6 +71,7 @@ function retry(what) {
         });
     });
 }
+exports.retry = retry;
 function toPromise(p) {
     var _this = this;
     var r;
@@ -139,6 +141,12 @@ function isBackend() {
 }
 exports.isBackend = isBackend;
 var Remult = /** @class */ (function () {
+    /** 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
+     */
     function Remult(provider) {
         this._userChangeEvent = new EventSource();
         this.repCache = new Map();
@@ -158,16 +166,26 @@ var Remult = /** @class */ (function () {
         if (!server_action_1.Action.provider)
             server_action_1.Action.provider = dataProvider;
     }
-    Remult.prototype.clearAllCache = function () {
-        this.repCache.clear();
-    };
-    Remult.prototype.authenticated = function () {
-        return this.user.id !== undefined;
-    };
-    Remult.prototype.setDataProvider = function (dataProvider) {
-        this._dataSource = dataProvider;
+    /**Return's a `Repository` of the specific entity type
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * @see [Repository](https://remult.dev/docs/ref_repository.html)
+     *
+     */
+    Remult.prototype.repo = function (entity, dataProvider) {
+        if (dataProvider === undefined)
+            dataProvider = this._dataSource;
+        var dpCache = this.repCache.get(dataProvider);
+        if (!dpCache)
+            this.repCache.set(dataProvider, dpCache = new Map());
+        var r = dpCache.get(entity);
+        if (!r) {
+            dpCache.set(entity, r = new RepositoryImplementation_1.RepositoryImplementation(entity, this, dataProvider));
+        }
+        return r;
     };
     Object.defineProperty(Remult.prototype, "user", {
+        /** Returns the current user's info */
         get: function () {
             if (this._user === undefined) {
                 return {
@@ -181,70 +199,44 @@ var Remult = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(Remult.prototype, "userChange", {
-        get: function () {
-            return this._userChangeEvent.dispatcher;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    /** Set's the current user info */
     Remult.prototype.setUser = function (info) {
-        var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var auth;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
                         this._user = info;
                         auth = info;
                         if (auth) {
                             if (!this._user.id && auth.sub)
                                 this._user.id = auth.sub;
-                            if (!this._user.name && auth.name)
-                                this._user.name = auth.name;
                             if (!this._user.roles && auth.permissions) {
                                 this._user.roles = auth.permissions;
                             }
                         }
-                        if (this._user && !((_a = this._user) === null || _a === void 0 ? void 0 : _a.roles))
+                        if (this._user && !this._user.roles)
                             this._user.roles = [];
                         return [4 /*yield*/, this._userChangeEvent.fire()];
                     case 1:
-                        _b.sent();
+                        _a.sent();
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Remult.prototype.isAllowedForInstance = function (instance, x) {
-        var e_1, _a;
-        if (Array.isArray(x)) {
-            {
-                try {
-                    for (var x_1 = tslib_1.__values(x), x_1_1 = x_1.next(); !x_1_1.done; x_1_1 = x_1.next()) {
-                        var item = x_1_1.value;
-                        if (this.isAllowedForInstance(instance, item))
-                            return true;
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (x_1_1 && !x_1_1.done && (_a = x_1.return)) _a.call(x_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-        }
-        else if (typeof (x) === "function") {
-            return x(this, instance);
-        }
-        else
-            return this.isAllowed(x);
+    /** Checks if a user was authenticated */
+    Remult.prototype.authenticated = function () {
+        return this.user.id !== undefined;
     };
+    /** checks if the user has any of the roles specified in the parameters
+     * @example
+     * remult.isAllowed("admin")
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
     Remult.prototype.isAllowed = function (roles) {
-        var e_2, _a;
-        var _b, _c;
+        var e_1, _a;
         if (roles == undefined)
             return undefined;
         if (roles instanceof Array) {
@@ -256,12 +248,12 @@ var Remult = /** @class */ (function () {
                     }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
                     if (roles_1_1 && !roles_1_1.done && (_a = roles_1.return)) _a.call(roles_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_1) throw e_1.error; }
             }
             return false;
         }
@@ -270,27 +262,63 @@ var Remult = /** @class */ (function () {
         }
         if (typeof roles === 'boolean')
             return roles;
-        if (!this.user)
-            return false;
         if (typeof roles === 'string')
-            if (((_c = (_b = this.user) === null || _b === void 0 ? void 0 : _b.roles) === null || _c === void 0 ? void 0 : _c.indexOf(roles.toString())) >= 0)
+            if (this.user.roles.indexOf(roles.toString()) >= 0)
                 return true;
         return false;
     };
-    Remult.prototype.repo = function (entity, dataProvider) {
-        if (dataProvider === undefined)
-            dataProvider = this._dataSource;
-        var dpCache = this.repCache.get(dataProvider);
-        if (!dpCache)
-            this.repCache.set(dataProvider, dpCache = new Map());
-        var r = dpCache.get(entity);
-        if (!r) {
-            dpCache.set(entity, r = new RepositoryImplementation_1.RepositoryImplementation(entity, this, dataProvider));
+    /** checks if the user matches the allowedForInstance callback
+     * @see
+     * [Allowed](https://remult.dev/docs/allowed.html)
+     */
+    Remult.prototype.isAllowedForInstance = function (instance, x) {
+        var e_2, _a;
+        if (Array.isArray(x)) {
+            {
+                try {
+                    for (var x_1 = tslib_1.__values(x), x_1_1 = x_1.next(); !x_1_1.done; x_1_1 = x_1.next()) {
+                        var item = x_1_1.value;
+                        if (this.isAllowedForInstance(instance, item))
+                            return true;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (x_1_1 && !x_1_1.done && (_a = x_1.return)) _a.call(x_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
         }
-        return r;
+        else if (typeof (x) === "function") {
+            return x(this, instance);
+        }
+        else
+            return this.isAllowed(x);
     };
-    Remult.onFind = function (metadata, options) { };
+    Object.defineProperty(Remult.prototype, "userChange", {
+        /** returns a dispatcher object that fires once a user has changed*/
+        get: function () {
+            return this._userChangeEvent.dispatcher;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** sets the current data provider */
+    Remult.prototype.setDataProvider = function (dataProvider) {
+        this._dataSource = dataProvider;
+    };
+    Remult.prototype.clearAllCache = function () {
+        this.repCache.clear();
+    };
+    /** 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 = function (metadata, options) { };
     return Remult;
 }());
 exports.Remult = Remult;

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

@@ -24,11 +24,12 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     insert(data: any): Promise<any>;
 }
 export declare class RestDataProviderHttpProviderUsingFetch implements RestDataProviderHttpProvider {
-    private addRequestHeader?;
-    constructor(addRequestHeader?: (add: ((name: string, value: string) => void)) => void);
+    private fetch?;
+    constructor(fetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
     get(url: string): Promise<any>;
     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>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;