remult 0.13.19 → 0.13.20

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

@@ -249,6 +249,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 +273,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>;