remult 0.13.19 → 0.13.22

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;

package/src/data-providers/rest-data-provider.js

@@ -4,6 +4,7 @@ exports.addFilterToUrlAndReturnTrueIfSuccessful = exports.RestDataProviderHttpPr
 var tslib_1 = require("tslib");
 var urlBuilder_1 = require("../../urlBuilder");
 var filter_interfaces_1 = require("../filter/filter-interfaces");
+var context_1 = require("../context");
 var RestDataProvider = /** @class */ (function () {
     function RestDataProvider(url, http) {
         this.url = url;
@@ -152,67 +153,76 @@ var RestEntityDataProvider = /** @class */ (function () {
     return RestEntityDataProvider;
 }());
 exports.RestEntityDataProvider = RestEntityDataProvider;
-function JsonContent(add) {
-    add('Content-type', "application/json");
-}
 var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
-    function RestDataProviderHttpProviderUsingFetch(addRequestHeader) {
-        this.addRequestHeader = addRequestHeader;
-        if (!addRequestHeader)
-            this.addRequestHeader = function () { };
+    function RestDataProviderHttpProviderUsingFetch(fetch) {
+        this.fetch = fetch;
     }
     RestDataProviderHttpProviderUsingFetch.prototype.get = function (url) {
-        return myFetch(url, undefined, this.addRequestHeader).then(function (r) {
-            return r;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, context_1.retry(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, this.myFetch(url).then(function (r) {
+                                        return r;
+                                    })];
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
         });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.put = function (url, data) {
-        return myFetch(url, {
+        return this.myFetch(url, {
             method: 'put',
             body: JSON.stringify(data)
-        }, this.addRequestHeader, JsonContent);
+        });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.delete = function (url) {
-        var h = new Headers();
-        this.addRequestHeader(function (name, value) { return h.append(name, value); });
-        return fetch(url, { method: 'delete', credentials: 'include' }).then(onSuccess, onError);
+        return this.myFetch(url, { method: 'delete', credentials: 'include' });
     };
     RestDataProviderHttpProviderUsingFetch.prototype.post = function (url, data) {
-        return myFetch(url, {
-            method: 'post',
-            body: JSON.stringify(data)
-        }, this.addRequestHeader, JsonContent);
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, context_1.retry(function () { return _this.myFetch(url, {
+                            method: 'post',
+                            body: JSON.stringify(data)
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    RestDataProviderHttpProviderUsingFetch.prototype.myFetch = function (url, init) {
+        var _this = this;
+        if (!init)
+            init = {};
+        if (!init.headers)
+            init.headers = new Headers();
+        var h = init.headers;
+        h.append('Content-type', "application/json");
+        init.credentials = 'include';
+        return (this.fetch || fetch)(url, init).then(function (response) {
+            return onSuccess(response);
+        }).catch(function (error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var r;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, error];
+                    case 1:
+                        r = _a.sent();
+                        throw r;
+                }
+            });
+        }); });
     };
     return RestDataProviderHttpProviderUsingFetch;
 }());
 exports.RestDataProviderHttpProviderUsingFetch = RestDataProviderHttpProviderUsingFetch;
-function myFetch(url, init) {
-    var _this = this;
-    var addRequestHeader = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        addRequestHeader[_i - 2] = arguments[_i];
-    }
-    if (!init)
-        init = {};
-    if (!init.headers)
-        init.headers = new Headers();
-    var h = init.headers;
-    addRequestHeader.forEach(function (x) { return x(function (n, v) { return h.append(n, v); }); });
-    init.credentials = 'include';
-    return fetch(url, init).then(function (response) {
-        return onSuccess(response);
-    }).catch(function (error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var r;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, error];
-                case 1:
-                    r = _a.sent();
-                    throw r;
-            }
-        });
-    }); });
-}
 function onSuccess(response) {
     if (response.status == 204)
         return;
@@ -220,9 +230,7 @@ function onSuccess(response) {
         return response.json();
     else {
         throw response.json().then(function (x) {
-            if (!x.message)
-                x.message = response.statusText;
-            return x;
+            return tslib_1.__assign(tslib_1.__assign({}, x), { message: x.message || response.statusText, url: response.url, status: response.status });
         }).catch(function () {
             throw {
                 message: response.statusText,
@@ -232,9 +240,6 @@ function onSuccess(response) {
         });
     }
 }
-function onError(error) {
-    throw Promise.resolve(error);
-}
 function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     for (var key in filter) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {

package/src/data-providers/sql-database.js

@@ -121,17 +121,13 @@ var LogSQLCommand = /** @class */ (function () {
                         if (this.allQueries) {
                             d = new Date().valueOf() - start.valueOf();
                             if (d > SqlDatabase.durationThreshold) {
-                                console.log('Query:', sql);
-                                console.log("Arguments:", this.args);
-                                console.log("Duration", d / 1000);
+                                console.log({ query: sql, arguments: this.args, duration: d / 1000 });
                             }
                         }
                         return [2 /*return*/, r];
                     case 2:
                         err_1 = _a.sent();
-                        console.error('Error:', err_1);
-                        console.error('Query:', sql);
-                        console.error("Arguments", this.args);
+                        console.error({ error: err_1, query: sql, arguments: this.args });
                         throw err_1;
                     case 3: return [2 /*return*/];
                 }

package/src/entity.d.ts

@@ -2,39 +2,35 @@ import { Allowed, AllowedForInstance } from "./context";
 import { FieldMetadata as FieldMetadata } from './column-interfaces';
 import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef } from "./remult3";
 export interface EntityOptions<entityType = any> {
-    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata;
-    /**
-     * The name of the table in the database that holds the data for this entity.
-     * If no name is set, the `key` will be used instead.
-     * @example
-     * dbName:'myProducts'
-     */
-    dbName?: string;
-    sqlExpression?: string | ((entity: FieldsMetadata<entityType>) => string | Promise<string>);
     /**A human readable name for the entity */
     caption?: string;
     /**
      * Determines if this Entity is available for get requests using Rest Api
-     * @see [allowed](http://remult.dev/guide/allowed.html)*/
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiRead?: Allowed;
     /**
      * Determines if this entity can be updated through the api.
-     * @see [allowed](http://remult.dev/guide/allowed.html)*/
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiUpdate?: AllowedForInstance<entityType>;
-    /** @see [allowed](http://remult.dev/guide/allowed.html)*/
+    /** Determines if entries for this entity can be deleted through the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiDelete?: AllowedForInstance<entityType>;
-    /** @see [allowed](http://remult.dev/guide/allowed.html)*/
+    /** Determines if new entries for this entity can be posted through the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiInsert?: AllowedForInstance<entityType>;
     /** sets  the `allowApiUpdate`, `allowApiDelete` and `allowApiInsert` properties in a single set */
     allowApiCrud?: Allowed;
     /** A filter that determines which rows can be queries using the api.
-  
+    * @example
+    * apiPrefilter: { archive:false }
+    *
+    * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
     */
     apiPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
-    apiRequireId?: Allowed;
-    /** A filter that will be used for all queries from this entity both from the API and from within the server.
+    /** A filter that will be used for all queries from this entity both from the API and from within the backend.
      * @example
-     * fixedWhereFilter: () => this.archive.isEqualTo(false)
+     * fixedWhereFilter: { archive:false }
+     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
      */
     backendPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
     /** An order by to be used, in case no order by was specified
@@ -42,23 +38,18 @@ export interface EntityOptions<entityType = any> {
      * defaultOrderBy: { name: "asc" }
      *
      * @example
-     * defaultOrderBy: { price: "asc", name: "asc" }
-     *
-     * @example
      * defaultOrderBy: { price: "desc", name: "asc" }
      */
     defaultOrderBy?: EntityOrderBy<entityType>;
     /** An event that will be fired before the Entity will be saved to the database.
-    * If the `validationError` property of the entity or any of it's columns will be set, the save will be aborted and an exception will be thrown.
+    * If the `error` property of the entity's ref or any of it's fields will be set, the save will be aborted and an exception will be thrown.
     * this is the place to run logic that we want to run in any case before an entity is saved.
     * @example
-    * saving: async (self) => {
-    *   if (isBackend()) {
-    *     if (self.isNew()) {
-    *         self.createDate.value = new Date();
-    *     }
-    *   }
-    * }
+    * .@Entity<Task>("tasks", {
+    * saving: async task => {
+    *      task.lastUpdated = new Date()
+    *  }
+    *})
     */
     saving?: (row: entityType, proceedWithoutSavingToDb: () => void) => Promise<any> | any;
     /** will be called after the Entity was saved to the data source. */
@@ -67,6 +58,18 @@ export interface EntityOptions<entityType = any> {
     deleting?: (row: entityType) => Promise<any> | any;
     /** Will be called after an Entity is deleted */
     deleted?: (row: entityType) => Promise<any> | any;
+    /** Will be called when the entity is being validated, usually prior to the `saving` event */
     validation?: (row: entityType, ref: EntityRef<entityType>) => Promise<any> | any;
+    /** The name of the table in the database that holds the data for this entity.
+   * If no name is set, the `key` will be used instead.
+   * @example
+   * dbName:'myProducts'
+   */
+    dbName?: string;
+    /** For entities that are based on SQL expressions instead of a physical table or view*/
+    sqlExpression?: string | ((entity: FieldsMetadata<entityType>) => string | Promise<string>);
+    /** An arrow function that identifies the `id` column to use for this entity */
+    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata;
     entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
+    apiRequireId?: Allowed;
 }

package/src/remult3/RepositoryImplementation.d.ts

@@ -26,17 +26,17 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     query(options?: QueryOptions<entityType>): QueryResult<entityType>;
     getEntityRef(entity: entityType): EntityRef<entityType>;
     delete(id: (entityType extends {
-        id: number;
+        id?: number;
     } ? number : entityType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number))): Promise<void>;
     delete(item: entityType): Promise<void>;
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
     update(id: (entityType extends {
-        id: number;
+        id?: number;
     } ? number : entityType extends {
-        id: string;
+        id?: string;
     } ? string : (string | number)), entity: Partial<OmitEB<entityType>>): Promise<entityType>;
     private getRefForExistingRow;
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
@@ -157,6 +157,7 @@ export declare class FieldRefImplementation<entityType, valueType> implements Fi
     get originalValue(): any;
     private rawOriginalValue;
     setId(id: (string | number)): void;
+    getId(): any;
     get inputValue(): string;
     set inputValue(val: string);
     valueChanged(): boolean;
@@ -249,6 +250,19 @@ export declare class ValueListInfo<T extends ValueListItem> implements ValueConv
 export declare function getValueList<T>(field: FieldRef<T>): T[];
 export declare function getValueList<T>(field: FieldMetadata<T>): T[];
 export declare function getValueList<T>(type: ClassType<T>): T[];
+/**Decorates fields that should be used as fields.
+ * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
+ *
+ * FieldOptions can be set in two ways:
+ * @example
+ * // as an object
+ * .@Fields.string({ includeInApi:false })
+ * title='';
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * .@Fields.string((options,remult) => options.includeInApi = true)
+ * title='';
+ */
 export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
 export declare const storableMember: unique symbol;
 export declare function decorateColumnSettings<valueType>(settings: FieldOptions<any, valueType>, remult: Remult): FieldOptions<any, valueType>;
@@ -260,6 +274,29 @@ export declare type BuildEntityFields<entityType> = {
     [Properties in keyof Partial<OmitEB<entityType>>]: any;
 };
 export declare function BuildEntity<entityType>(c: ClassType<entityType>, key: string, fields: BuildEntityFields<entityType>, ...options: (EntityOptions<entityType> | ((options: EntityOptions<entityType>, remult: Remult) => void))[]): void;
+/**Decorates classes that should be used as entities.
+ * Receives a key and an array of EntityOptions.
+ * @example
+ * import { Entity, Fields } from "remult";
+ * @Entity("tasks", {
+ *    allowApiCrud: true
+ * })
+ * export class Task {
+ *    @Fields.uuid()
+ *    id!: string;
+ *    @Fields.string()
+ *    title = '';
+ *    @Fields.boolean()
+ *    completed = false;
+ * }
+ * *EntityOptions can be set in two ways:*
+ * @example
+ * // as an object
+ * .@Entity("tasks",{ allowApiCrud:true })
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * .@Entity("tasks", (options,remult) => options.allowApiCrud = true)
+ */
 export declare function Entity<entityType>(key: string, ...options: (EntityOptions<entityType> | ((options: EntityOptions<entityType>, remult: Remult) => void))[]): (target: any) => any;
 export declare class EntityBase {
     get _(): EntityRef<this>;