remult 0.21.1 → 0.22.0

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

@@ -1,11 +1,11 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { customUrlToken, Filter } from '../filter/filter-interfaces';
-import { buildRestDataProvider, retry } from "../buildRestDataProvider";
+import { buildRestDataProvider, retry } from '../buildRestDataProvider';
 import { actionInfo } from '../server-action';
 export class RestDataProvider {
     constructor(apiProvider) {
         this.apiProvider = apiProvider;
-        this.supportsRawFilter = true;
+        this.isProxy = true;
     }
     getEntityDataProvider(entity) {
         return new RestEntityDataProvider(() => {
@@ -18,7 +18,7 @@ export class RestDataProvider {
         }, entity);
     }
     async transaction(action) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 }
 //@internal
@@ -28,15 +28,15 @@ export function findOptionsToJson(options, meta) {
         where: Filter.entityFilterToJson(meta, options.where),
     };
     if (options.load)
-        r.load = options.load(meta.fields).map(y => y.key);
+        r.load = options.load(meta.fields).map((y) => y.key);
     return r;
 }
 //@internal
 export function findOptionsFromJson(json, meta) {
     let r = {};
-    for (const key of ["limit", "page", "where", "orderBy"]) {
+    for (const key of ['limit', 'page', 'where', 'orderBy']) {
         if (json[key] !== undefined) {
-            if (key === "where") {
+            if (key === 'where') {
                 r[key] = Filter.entityFilterFromJson(meta, json.where);
             }
             else
@@ -44,7 +44,7 @@ export function findOptionsFromJson(json, meta) {
         }
     }
     if (json.load) {
-        r.load = (z) => json.load.map(y => z.find(y));
+        r.load = (z) => json.load.map((y) => z.find(y));
     }
     return r;
 }
@@ -70,11 +70,11 @@ export class RestEntityDataProvider {
     }
     async count(where) {
         const { run } = this.buildFindRequest({ where });
-        return run("count").then(r => +r.count);
+        return run('count').then((r) => +r.count);
     }
     find(options) {
         let { run } = this.buildFindRequest(options);
-        return run().then(x => x.map(y => this.translateFromJson(y)));
+        return run().then((x) => x.map((y) => this.translateFromJson(y)));
     }
     //@internal
     buildFindRequest(options) {
@@ -90,13 +90,13 @@ export class RestEntityDataProvider {
                 let sort = '';
                 let order = '';
                 let hasDescending = false;
-                options.orderBy.Segments.forEach(c => {
+                options.orderBy.Segments.forEach((c) => {
                     if (sort.length > 0) {
-                        sort += ",";
-                        order += ",";
+                        sort += ',';
+                        order += ',';
                     }
                     sort += c.field.key;
-                    order += c.isDescending ? "desc" : "asc";
+                    order += c.isDescending ? 'desc' : 'asc';
                     if (c.isDescending)
                         hasDescending = true;
                 });
@@ -113,10 +113,10 @@ export class RestEntityDataProvider {
         const run = (action) => {
             let u = new UrlBuilder(url.url);
             if (!action && filterObject) {
-                action = "get";
+                action = 'get';
             }
             if (action)
-                u.add("__action", action);
+                u.add('__action', action);
             if (filterObject) {
                 return this.http().post(u.url, filterObject);
             }
@@ -131,12 +131,12 @@ export class RestEntityDataProvider {
                 return {
                     result,
                     unsubscribe: async () => {
-                        return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + "?__action=endLiveQuery", {
-                            id: queryId
+                        return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + '?__action=endLiveQuery', {
+                            id: queryId,
                         }));
-                    }
+                    },
                 };
-            }
+            },
         };
     }
     update(id, data) {
@@ -146,13 +146,17 @@ export class RestEntityDataProvider {
             if (keys.includes(col.key))
                 result[col.key] = col.valueConverter.toJson(data[col.key]);
         }
-        return this.http().put(this.url() + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
+        return this.http()
+            .put(this.url() + '/' + encodeURIComponent(id), result)
+            .then((y) => this.translateFromJson(y));
     }
     delete(id) {
         return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
     insert(data) {
-        return this.http().post(this.url(), this.translateToJson(data)).then(y => this.translateFromJson(y));
+        return this.http()
+            .post(this.url(), this.translateToJson(data))
+            .then((y) => this.translateFromJson(y));
     }
 }
 export class RestDataProviderHttpProviderUsingFetch {
@@ -160,14 +164,14 @@ export class RestDataProviderHttpProviderUsingFetch {
         this.fetch = fetch;
     }
     async get(url) {
-        return await retry(async () => this.myFetch(url).then(r => {
+        return await retry(async () => this.myFetch(url).then((r) => {
             return r;
         }));
     }
     put(url, data) {
         return this.myFetch(url, {
             method: 'put',
-            body: JSON.stringify(data)
+            body: JSON.stringify(data),
         });
     }
     delete(url) {
@@ -176,14 +180,16 @@ export class RestDataProviderHttpProviderUsingFetch {
     async post(url, data) {
         return await retry(() => this.myFetch(url, {
             method: 'post',
-            body: JSON.stringify(data)
+            body: JSON.stringify(data),
         }));
     }
     myFetch(url, options) {
         const headers = {};
         if (options?.body)
-            headers["Content-type"] = "application/json";
-        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
+            headers['Content-type'] = 'application/json';
+        if (typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined' &&
+            typeof (window.document.cookie !== 'undefined'))
             for (const cookie of window.document.cookie.split(';')) {
                 if (cookie.trim().startsWith('XSRF-TOKEN=')) {
                     headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
@@ -193,10 +199,12 @@ export class RestDataProviderHttpProviderUsingFetch {
             credentials: 'include',
             method: options?.method,
             body: options?.body,
-            headers
-        }).then(response => {
+            headers,
+        })
+            .then((response) => {
             return onSuccess(response);
-        }).catch(async (error) => {
+        })
+            .catch(async (error) => {
             let r = await error;
             throw r;
         });
@@ -208,13 +216,21 @@ function onSuccess(response) {
     if (response.status >= 200 && response.status < 300)
         return response.json();
     else {
-        throw response.json().then(x => {
-            return { ...x, message: x.message || response.statusText, url: response.url, status: response.status };
-        }).catch(() => {
+        throw response
+            .json()
+            .then((x) => {
+            return {
+                ...x,
+                message: x.message || response.statusText,
+                url: response.url,
+                status: response.status,
+            };
+        })
+            .catch(() => {
             throw {
                 message: response.statusText,
                 url: response.url,
-                status: response.status
+                status: response.status,
             };
         });
     }
@@ -235,10 +251,10 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
             const element = filter[key];
             if (Array.isArray(element)) {
-                if (key.endsWith(".in"))
+                if (key.endsWith('.in'))
                     url.add(key, JSON.stringify(element));
                 else
-                    element.forEach(e => url.add(key, e));
+                    element.forEach((e) => url.add(key, e));
             }
             else if (key.startsWith(customUrlToken))
                 url.add(key, JSON.stringify(element));
@@ -248,4 +264,4 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     }
     return true;
 }
-export const liveQueryAction = "liveQuery-";
+export const liveQueryAction = 'liveQuery-';

package/esm/src/data-providers/sql-database.d.ts

@@ -1,8 +1,8 @@
-import { EntityDataProvider, DataProvider } from "../data-interfaces";
-import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from "../sql-command";
-import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
-import { EntityMetadata, EntityFilter, RepositoryOverloads } from "../remult3";
-import { Remult } from "../context";
+import { EntityDataProvider, DataProvider } from '../data-interfaces';
+import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from '../sql-command';
+import { CustomSqlFilterBuilderFunction } from '../filter/filter-consumer-bridge-to-sql-request';
+import { EntityMetadata, EntityFilter, RepositoryOverloads } from '../remult3';
+import { Remult } from '../context';
 export declare class SqlDatabase implements DataProvider {
     private sql;
     static getDb(remult?: Remult): SqlDatabase;

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

@@ -1,10 +1,10 @@
-import { CompoundIdField } from "../column";
-import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+import { CompoundIdField } from '../column';
+import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
 import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
 import { Sort } from '../sort';
-import { getRepository } from "../remult3";
-import { RemultProxy } from "../remult-proxy";
-import { ValueConverters } from "../valueConverters";
+import { getRepository, } from '../remult3';
+import { remult as defaultRemult } from '../remult-proxy';
+import { ValueConverters } from '../valueConverters';
 // @dynamic
 export class SqlDatabase {
     constructor(sql) {
@@ -12,9 +12,9 @@ export class SqlDatabase {
         this.createdEntities = [];
     }
     static getDb(remult) {
-        const r = (remult || RemultProxy.defaultRemult).dataProvider;
+        const r = (remult || defaultRemult).dataProvider;
         if (!r.createCommand)
-            throw "the data provider is not an SqlDatabase";
+            throw 'the data provider is not an SqlDatabase';
         return r;
     }
     createCommand() {
@@ -34,9 +34,13 @@ export class SqlDatabase {
     getEntityDataProvider(entity) {
         if (!this.sql.supportsJsonColumnType) {
             for (const f of entity.fields.toArray()) {
-                if (f.valueConverter.fieldTypeInDb === "json") {
+                if (f.valueConverter.fieldTypeInDb === 'json') {
                     //@ts-ignore
-                    f.valueConverter = { ...f.valueConverter, toDb: ValueConverters.JsonString.toDb, fromDb: ValueConverters.JsonString.fromDb };
+                    f.valueConverter = {
+                        ...f.valueConverter,
+                        toDb: ValueConverters.JsonString.toDb,
+                        fromDb: ValueConverters.JsonString.fromDb,
+                    };
                 }
             }
         }
@@ -55,18 +59,18 @@ export class SqlDatabase {
                     createCommand: () => {
                         let c = x.createCommand();
                         return {
-                            addParameterAndReturnSqlToken: x => c.addParameterAndReturnSqlToken(x),
+                            addParameterAndReturnSqlToken: (x) => c.addParameterAndReturnSqlToken(x),
                             execute: async (sql) => {
                                 if (completed)
                                     throw "can't run a command after the transaction was completed";
                                 return c.execute(sql);
-                            }
+                            },
                         };
                     },
                     getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
-                    entityIsUsedForTheFirstTime: y => x.entityIsUsedForTheFirstTime(y),
-                    transaction: z => x.transaction(z),
-                    supportsJsonColumnType: this.sql.supportsJsonColumnType
+                    entityIsUsedForTheFirstTime: (y) => x.entityIsUsedForTheFirstTime(y),
+                    transaction: (z) => x.transaction(z),
+                    supportsJsonColumnType: this.sql.supportsJsonColumnType,
                 }));
             }
             finally {
@@ -77,8 +81,8 @@ export class SqlDatabase {
     static rawFilter(build) {
         return {
             [customDatabaseFilterToken]: {
-                buildSql: build
-            }
+                buildSql: build,
+            },
         };
     }
     static async filterToRaw(repo, condition, sqlCommand) {
@@ -88,7 +92,7 @@ export class SqlDatabase {
         const r = getRepository(repo);
         var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, await dbNamesOf(r.metadata));
         b._addWhere = false;
-        await (await (r.translateWhereToFilter(condition))).__applyToConsumer(b);
+        await (await r.translateWhereToFilter(condition)).__applyToConsumer(b);
         return await b.resolveWhere();
     }
 }
@@ -139,12 +143,15 @@ class LogSQLCommand {
                 var d = new Date().valueOf() - start.valueOf();
                 if (d > SqlDatabase.durationThreshold) {
                     const duration = d / 1000;
-                    if (this.logToConsole === "oneLiner") {
-                        const rawSql = sql.replace(/(\r\n|\n|\r|\t)/gm, ' ').replace(/  +/g, ' ').trim();
+                    if (this.logToConsole === 'oneLiner') {
+                        const rawSql = sql
+                            .replace(/(\r\n|\n|\r|\t)/gm, ' ')
+                            .replace(/  +/g, ' ')
+                            .trim();
                         const first = rawSql.split(' ')[0].toUpperCase();
-                        console.info(`${icons.get(first) || '💢'} (${(duration).toFixed(3)}) ${rawSql} ${JSON.stringify(this.args)}`);
+                        console.info(`${icons.get(first) || '💢'} (${duration.toFixed(3)}) ${rawSql} ${JSON.stringify(this.args)}`);
                     }
-                    else if (typeof this.logToConsole === "function") {
+                    else if (typeof this.logToConsole === 'function') {
                         this.logToConsole(duration, sql, this.args);
                     }
                     else {
@@ -181,7 +188,7 @@ class ActualSQLServerDataProvider {
             where.__applyToConsumer(wc);
             select += await wc.resolveWhere();
         }
-        return r.execute(select).then(r => {
+        return r.execute(select).then((r) => {
             return Number(r.rows[0].count);
         });
     }
@@ -208,7 +215,10 @@ class ActualSQLServerDataProvider {
                 let segs = [];
                 for (const s of options.orderBy.Segments) {
                     if (s.field instanceof CompoundIdField) {
-                        segs.push(...s.field.fields.map(c => ({ field: c, isDescending: s.isDescending })));
+                        segs.push(...s.field.fields.map((c) => ({
+                            field: c,
+                            isDescending: s.isDescending,
+                        })));
                     }
                     else
                         segs.push(s);
@@ -231,11 +241,13 @@ class ActualSQLServerDataProvider {
                     page = options.page;
                 if (page < 1)
                     page = 1;
-                select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
+                select +=
+                    ' ' +
+                        this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
             }
         }
-        return r.execute(select).then(r => {
-            return r.rows.map(y => {
+        return r.execute(select).then((r) => {
+            return r.rows.map((y) => {
                 return this.buildResultRow(colKeys, y, r);
             });
         });
@@ -248,7 +260,7 @@ class ActualSQLServerDataProvider {
                 result[col.key] = col.valueConverter.fromDb(y[r.getColumnKeyInResultForIndexInSelect(index)]);
             }
             catch (err) {
-                throw new Error("Failed to load from db:" + col.key + "\r\n" + err);
+                throw new Error('Failed to load from db:' + col.key + '\r\n' + err);
             }
         }
         return result;
@@ -278,7 +290,8 @@ class ActualSQLServerDataProvider {
         for (const x of this.entity.fields) {
             if (x instanceof CompoundIdField) {
             }
-            if (isDbReadonly(x, e)) { }
+            if (isDbReadonly(x, e)) {
+            }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
@@ -286,14 +299,15 @@ class ActualSQLServerDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement += e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                    statement +=
+                        e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
         statement += await f.resolveWhere();
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
-        return r.execute(statement).then(sqlResult => {
+        return r.execute(statement).then((sqlResult) => {
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }
@@ -313,7 +327,8 @@ class ActualSQLServerDataProvider {
         let vals = '';
         let added = false;
         for (const x of this.entity.fields) {
-            if (isDbReadonly(x, e)) { }
+            if (isDbReadonly(x, e)) {
+            }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
@@ -331,23 +346,25 @@ class ActualSQLServerDataProvider {
         let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = this.buildSelect(e);
         statement += ' returning ' + select;
-        return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));
+        return await r
+            .execute(statement)
+            .then((sql) => this.buildResultRow(colKeys, sql.rows[0], sql));
     }
 }
 ActualSQLServerDataProvider.LogToConsole = false;
 class myDummySQLCommand {
     execute(sql) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     addParameterAndReturnSqlToken(val) {
         if (val === null)
-            return "null";
+            return 'null';
         if (val instanceof Date)
             val = val.toISOString();
-        if (typeof (val) == "string") {
+        if (typeof val == 'string') {
             if (val == undefined)
                 val = '';
-            return '\'' + val.replace(/'/g, '\'\'') + '\'';
+            return "'" + val.replace(/'/g, "''") + "'";
         }
         return val.toString();
     }

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,7 +1,7 @@
-import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
-import { SqlCommand, SqlImplementation } from "../sql-command";
-import { EntityMetadata } from "../remult3";
-import { Remult } from "../context";
+import { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
+import { SqlCommand, SqlImplementation } from '../sql-command';
+import { EntityMetadata } from '../remult3';
+import { Remult } from '../context';
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
     rows: {

package/esm/src/data-providers/web-sql-data-provider.js

@@ -1,6 +1,6 @@
-import { isAutoIncrement } from "../remult3";
-import { SqlDatabase } from "./sql-database";
-import { dbNamesOf, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+import { isAutoIncrement } from '../remult3';
+import { SqlDatabase } from './sql-database';
+import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
 //SqlDatabase.LogToConsole = true;
 export class WebSqlDataProvider {
     constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
@@ -13,7 +13,7 @@ export class WebSqlDataProvider {
         const sql = SqlDatabase.getDb(remult);
         const me = sql._getSourceSql();
         if (!me.db) {
-            throw "the data provider is not a WebSqlDataProvider";
+            throw 'the data provider is not a WebSqlDataProvider';
         }
         return me.db;
     }
@@ -45,7 +45,7 @@ export class WebSqlDataProvider {
                 result += '\r\n  ';
                 if (isAutoIncrement(x)) {
                     if (x.key != entity.idMetadata.field.key)
-                        throw "in web sql, autoincrement is only allowed for primary key";
+                        throw 'in web sql, autoincrement is only allowed for primary key';
                     result += e.$dbNameOf(x) + ' integer primary key autoincrement';
                 }
                 else {
@@ -65,15 +65,15 @@ export class WebSqlDataProvider {
         return new WebSqlBridgeToSQLCommand(this.db);
     }
     async transaction(action) {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
     addColumnSqlSyntax(x, dbName) {
         let result = dbName;
-        const nullNumber = x.allowNull ? "" : " default 0 not null";
+        const nullNumber = x.allowNull ? '' : ' default 0 not null';
         if (x.valueType == Date)
-            result += " integer";
+            result += ' integer';
         else if (x.valueType == Boolean)
-            result += " integer " + nullNumber;
+            result += ' integer ' + nullNumber;
         else if (x.valueType == Number) {
             if (!x.valueConverter.fieldTypeInDb)
                 result += ' real ' + nullNumber;
@@ -81,10 +81,12 @@ export class WebSqlDataProvider {
                 result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
         }
         else
-            result += " text" + (x.allowNull ? " " : " default '' not null ");
+            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
         return result;
     }
-    toString() { return "WebSqlDataProvider"; }
+    toString() {
+        return 'WebSqlDataProvider';
+    }
 }
 class WebSqlBridgeToSQLCommand {
     //@ts-ignore
@@ -97,12 +99,12 @@ class WebSqlBridgeToSQLCommand {
         return '~' + this.values.length + '~';
     }
     execute(sql) {
-        return new Promise((resolve, reject) => this.source.transaction(t => {
+        return new Promise((resolve, reject) => this.source.transaction((t) => {
             let s = sql;
             let v = [];
             var m = s.match(/~\d+~/g);
             if (m != null)
-                m.forEach(mr => {
+                m.forEach((mr) => {
                     s = s.replace(mr, '?');
                     v.push(this.values[Number.parseInt(mr.substring(1, mr.length - 1)) - 1]);
                 });

package/esm/src/entity.d.ts

@@ -1,6 +1,6 @@
-import { Allowed, AllowedForInstance } from "./context";
+import { Allowed, AllowedForInstance } from './context';
 import { FieldMetadata } from './column-interfaces';
-import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from "./remult3";
+import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from './remult3';
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */
     caption?: string;
@@ -27,14 +27,14 @@ export interface EntityOptions<entityType = any> {
     /** A filter that determines which rows can be queries using the api.
      * @description
      * Use apiPrefilter in cases where you to restrict data based on user profile
-    * @example
-    * apiPrefilter: { archive:false }
-    *
-    * @example
-    * apiPrefilter: ()=> remult.isAllowed("admin")?{}:{ archive:false }
-    * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
-    *
-    */
+     * @example
+     * apiPrefilter: { archive:false }
+     *
+     * @example
+     * apiPrefilter: ()=> remult.isAllowed("admin")?{}:{ archive:false }
+     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
+     *
+     */
     apiPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
     /** A filter that will be used for all queries from this entity both from the API and from within the backend.
      * @example
@@ -51,15 +51,15 @@ export interface EntityOptions<entityType = any> {
      */
     defaultOrderBy?: EntityOrderBy<entityType>;
     /** An event that will be fired before the Entity will be saved to the database.
-    * If the `error` property of the entity's ref or any of its 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
-    * @Entity<Task>("tasks", {
-    * saving: async task => {
-    *      task.lastUpdated = new Date()
-    *  }
-    *})
-    */
+     * If the `error` property of the entity's ref or any of its 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
+     * @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. */
     saved?: (row: entityType) => Promise<any> | any;
@@ -70,10 +70,10 @@ export interface EntityOptions<entityType = 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'
-   */
+     * 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: EntityMetadata<entityType>) => string | Promise<string>);
@@ -84,7 +84,7 @@ export interface EntityOptions<entityType = any> {
      * @example
      * //Multiple columns id
      * @Entity<OrderDetails>("orderDetails", { id:od=> [od.orderId, od.productCode] })
-    */
+     */
     id?: (entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[];
     entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
     apiRequireId?: Allowed;

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -1,8 +1,8 @@
-import { SqlCommandWithParameters } from "../sql-command";
+import { SqlCommandWithParameters } from '../sql-command';
 import { Filter, FilterConsumer } from './filter-interfaces';
-import { FieldMetadata } from "../column-interfaces";
-import { EntityFilter, OmitEB } from "../remult3/remult3";
-import { EntityMetadataOverloads, RepositoryOverloads } from "../remult3";
+import { FieldMetadata } from '../column-interfaces';
+import { EntityFilter, OmitEB } from '../remult3/remult3';
+import { EntityMetadataOverloads, RepositoryOverloads } from '../remult3';
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
     private r;
     private nameProvider;