remult 0.25.7-exp.0 → 0.25.7-exp.2

package/esm/postgres/postgres-data-provider.js

@@ -80,6 +80,9 @@ class PostgresBridgeToSQLCommand {
     }
     values = [];
     addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
         if (Array.isArray(val))
             val = JSON.stringify(val);
         this.values.push(val);

package/esm/postgres/schema-builder.js

@@ -65,9 +65,9 @@ export class PostgresSchemaBuilder {
         }
         const where = [];
         if (schema) {
-            where.push(`table_schema=${cmd.addParameterAndReturnSqlToken(this.removeQuotes(schema))}`);
+            where.push(`table_schema=${cmd.param(this.removeQuotes(schema))}`);
         }
-        where.push(`table_name=${cmd.addParameterAndReturnSqlToken(this.removeQuotes(table))}`);
+        where.push(`table_name=${cmd.param(this.removeQuotes(table))}`);
         return where.join(' AND ');
     }
     schemaAndName(e) {
@@ -162,7 +162,7 @@ CREATE table ${this.schemaAndName(e)} (${result}\r\n)`;
             const colName = e.$dbNameOf(c(entity));
             if ((await cmd.execute(`SELECT 1 FROM information_schema.columns WHERE ` +
                 `${this.whereTableAndSchema(cmd, e)} ` +
-                `AND column_name=${cmd.addParameterAndReturnSqlToken(colName.toLocaleLowerCase())}`)).rows.length == 0) {
+                `AND column_name=${cmd.param(colName.toLocaleLowerCase())}`)).rows.length == 0) {
                 let sql = `ALTER table ${this.schemaAndName(e)} ` +
                     `ADD column ${postgresColumnSyntax(c(entity), colName)}`;
                 if (PostgresSchemaBuilder.logToConsole)

package/esm/remult-sql-js.js

@@ -92,6 +92,9 @@ class SqlJsCommand {
         return new SqlJsSqlResult((await this.db).exec(sql, this.values));
     }
     addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
         if (val instanceof Date)
             val = val.valueOf();
         const key = ':' + ++this.i;

package/esm/src/data-api.js

@@ -30,6 +30,10 @@ export class DataApi {
                 return this.getArray(res, req, body);
             case 'count':
                 return this.count(res, req, body);
+            case 'deleteMany':
+                return this.deleteMany(res, req, body);
+            case 'updateMany':
+                return this.updateMany(res, req, body);
             case 'endLiveQuery':
                 await this.remult.liveQueryStorage.remove(body.id);
                 res.success('ok');
@@ -60,6 +64,24 @@ export class DataApi {
             response.error(err);
         }
     }
+    async deleteMany(response, request, filterBody) {
+        try {
+            return await doTransaction(this.remult, async () => {
+                let deleted = 0;
+                for await (const x of this.repository.query({
+                    where: await this.buildWhere(request, filterBody),
+                    include: this.includeNone(),
+                })) {
+                    await this.actualDelete(x);
+                    deleted++;
+                }
+                response.success({ deleted });
+            });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
     async getArrayImpl(response, request, filterBody) {
         let findOptions = {
             load: () => [],
@@ -219,25 +241,48 @@ export class DataApi {
             response.error(err);
         }
     }
+    async updateMany(response, request, body) {
+        try {
+            return await doTransaction(this.remult, async () => {
+                let updated = 0;
+                for await (const x of this.repository.query({
+                    where: await this.buildWhere(request, body.where),
+                    include: this.includeNone(),
+                })) {
+                    await this.actualUpdate(x, body.set);
+                    updated++;
+                }
+                response.success({ updated });
+            });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async actualUpdate(row, body) {
+        let ref = this.repository.getEntityRef(row);
+        await ref._updateEntityBasedOnApi(body);
+        if (!ref.apiUpdateAllowed) {
+            throw new ForbiddenError();
+        }
+        await ref.save();
+        return ref;
+    }
     async put(response, id, body) {
         await this.doOnId(response, id, async (row) => {
-            let ref = this.repository.getEntityRef(row);
-            await ref._updateEntityBasedOnApi(body);
-            if (!ref.apiUpdateAllowed) {
-                response.forbidden();
-                return;
-            }
-            await ref.save();
+            const ref = await this.actualUpdate(row, body);
             response.success(ref.toApiJson());
         });
     }
+    async actualDelete(row) {
+        if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
+            throw new ForbiddenError();
+        }
+        await this.repository.getEntityRef(row).delete();
+    }
     async delete(response, id) {
         await this.doOnId(response, id, async (row) => {
-            if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
-                response.forbidden();
-                return;
-            }
-            await this.repository.getEntityRef(row).delete();
+            await this.actualDelete(row);
             response.deleted();
         });
     }

package/esm/src/data-providers/array-entity-data-provider.js

@@ -3,6 +3,7 @@ import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sq
 import { Filter, customDatabaseFilterToken, } from '../filter/filter-interfaces.js';
 export class ArrayEntityDataProvider {
     entity;
+    rows;
     static rawFilter(filter) {
         return {
             [customDatabaseFilterToken]: {
@@ -10,14 +11,9 @@ export class ArrayEntityDataProvider {
             },
         };
     }
-    //@internal
-    rows;
     constructor(entity, rows) {
         this.entity = entity;
-        if (rows === undefined)
-            this.rows = [];
-        else
-            this.rows = rows;
+        this.rows = rows;
     }
     //@internal
     __names;
@@ -26,7 +22,7 @@ export class ArrayEntityDataProvider {
         if (this.__names)
             return this.__names;
         this.__names = await dbNamesOf(this.entity, (x) => x);
-        for (const r of this.rows) {
+        for (const r of this.rows()) {
             this.verifyThatRowHasAllNotNullColumns(r, this.__names);
         }
         return this.__names;
@@ -53,7 +49,7 @@ export class ArrayEntityDataProvider {
         }
     }
     async count(where) {
-        let rows = this.rows;
+        let rows = this.rows();
         const names = await this.init();
         let j = 0;
         for (let i = 0; i < rows.length; i++) {
@@ -70,7 +66,7 @@ export class ArrayEntityDataProvider {
         return j;
     }
     async find(options) {
-        let rows = this.rows;
+        let rows = this.rows();
         const dbNames = await this.init();
         if (options) {
             if (options.where) {
@@ -122,8 +118,8 @@ export class ArrayEntityDataProvider {
         const names = await this.init();
         let idMatches = this.idMatches(id, names);
         let keys = Object.keys(data);
-        for (let i = 0; i < this.rows.length; i++) {
-            let r = this.rows[i];
+        for (let i = 0; i < this.rows().length; i++) {
+            let r = this.rows()[i];
             if (idMatches(r)) {
                 let newR = { ...r };
                 for (const f of this.entity.fields) {
@@ -134,8 +130,8 @@ export class ArrayEntityDataProvider {
                     }
                 }
                 this.verifyThatRowHasAllNotNullColumns(newR, names);
-                this.rows[i] = newR;
-                return Promise.resolve(this.translateFromJson(this.rows[i], names));
+                this.rows()[i] = newR;
+                return Promise.resolve(this.translateFromJson(this.rows()[i], names));
             }
         }
         throw new Error("couldn't find id to update: " + id);
@@ -143,9 +139,9 @@ export class ArrayEntityDataProvider {
     async delete(id) {
         const names = await this.init();
         let idMatches = this.idMatches(id, names);
-        for (let i = 0; i < this.rows.length; i++) {
-            if (idMatches(this.rows[i])) {
-                this.rows.splice(i, 1);
+        for (let i = 0; i < this.rows().length; i++) {
+            if (idMatches(this.rows()[i])) {
+                this.rows().splice(i, 1);
                 return Promise.resolve();
             }
         }
@@ -158,19 +154,19 @@ export class ArrayEntityDataProvider {
         if (!(idf instanceof CompoundIdField)) {
             if (idf.valueConverter.fieldTypeInDb === 'autoincrement') {
                 j[idf.key] = 1;
-                for (const row of this.rows) {
+                for (const row of this.rows()) {
                     if (row[idf.key] >= j[idf.key])
                         j[idf.key] = row[idf.key] + 1;
                 }
             }
             if (j[idf.key])
-                this.rows.forEach((i) => {
+                this.rows().forEach((i) => {
                     if (j[idf.key] == i[idf.key])
                         throw Error('id already exists');
                 });
         }
         this.verifyThatRowHasAllNotNullColumns(j, names);
-        this.rows.push(j);
+        this.rows().push(j);
         return Promise.resolve(this.translateFromJson(j, names));
     }
 }

package/esm/src/data-providers/in-memory-database.js

@@ -1,14 +1,21 @@
 import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class InMemoryDataProvider {
     async transaction(action) {
-        await action(this);
+        let before = JSON.stringify(this.rows);
+        try {
+            await action(this);
+        }
+        catch (e) {
+            this.rows = JSON.parse(before);
+            throw e;
+        }
     }
     rows = {};
     getEntityDataProvider(entity) {
         let name = entity.key;
         if (!this.rows[name])
             this.rows[name] = [];
-        return new ArrayEntityDataProvider(entity, this.rows[name]);
+        return new ArrayEntityDataProvider(entity, () => this.rows[name]);
     }
     toString() {
         return 'InMemoryDataProvider';

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

@@ -24,7 +24,7 @@ class JsonEntityDataProvider {
         let s = await this.helper.getItem(dbName);
         if (s)
             data = JSON.parse(s);
-        let dp = new ArrayEntityDataProvider(this.entity, data);
+        let dp = new ArrayEntityDataProvider(this.entity, () => data);
         return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
     }
     p = Promise.resolve();

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

@@ -119,18 +119,27 @@ export class RestEntityDataProvider {
         const { run } = this.buildFindRequest({ where });
         return run('count').then((r) => +r.count);
     }
+    async deleteMany(where) {
+        const { run } = this.buildFindRequest({ where }, true);
+        return run('deleteMany').then((r) => +r.deleted);
+    }
+    async updateMany(where, data) {
+        const { run } = this.buildFindRequest({ where }, true);
+        return run('updateMany', { set: this.toJsonOfIncludedKeys(data) }).then((r) => +r.updated);
+    }
     find(options) {
         let { run } = this.buildFindRequest(options);
         return run().then((x) => x.map((y) => this.translateFromJson(y)));
     }
     //@internal
-    buildFindRequest(options) {
+    buildFindRequest(options, forcePost = false) {
         let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
             if (options.where) {
                 filterObject = options.where.toJson(); //        options.where.__applyToConsumer(new FilterConsumnerBridgeToUrlBuilder(url));
-                if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
+                if (!forcePost &&
+                    addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
                     filterObject = undefined;
             }
             if (options.orderBy && options.orderBy.Segments) {
@@ -157,15 +166,19 @@ export class RestEntityDataProvider {
             if (options.page)
                 url.add('_page', options.page);
         }
-        const run = (action) => {
+        const run = (action, body) => {
             let u = new UrlBuilder(url.url);
             if (!action && filterObject) {
                 action = 'get';
             }
             if (action)
                 u.add('__action', action);
-            if (filterObject) {
-                return this.http().post(u.url, filterObject);
+            if (filterObject || forcePost) {
+                if (!body)
+                    body = filterObject;
+                else
+                    body = { ...body, where: filterObject };
+                return this.http().post(u.url, body);
             }
             else
                 return this.http().get(u.url);
@@ -187,15 +200,18 @@ export class RestEntityDataProvider {
         };
     }
     update(id, data) {
+        return this.http()
+            .put(this.url() + '/' + encodeURIComponent(id), this.toJsonOfIncludedKeys(data))
+            .then((y) => this.translateFromJson(y));
+    }
+    toJsonOfIncludedKeys(data) {
         let result = {};
         let keys = Object.keys(data);
         for (const col of this.entity.fields) {
             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 result;
     }
     delete(id) {
         return this.http().delete(this.url() + '/' + encodeURIComponent(id));
@@ -205,6 +221,11 @@ export class RestEntityDataProvider {
             .post(this.url(), this.translateToJson(data))
             .then((y) => this.translateFromJson(y));
     }
+    insertMany(data) {
+        return this.http()
+            .post(this.url(), data.map((data) => this.translateToJson(data)))
+            .then((y) => y.map((y) => this.translateFromJson(y)));
+    }
 }
 export class RestDataProviderHttpProviderUsingFetch {
     fetch;

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

@@ -58,7 +58,10 @@ export class SqlDatabase {
                     createCommand: () => {
                         let c = x.createCommand();
                         return {
-                            addParameterAndReturnSqlToken: (x) => c.addParameterAndReturnSqlToken(x),
+                            addParameterAndReturnSqlToken: (val) => {
+                                return c.param(val);
+                            },
+                            param: (x) => c.param(x),
                             execute: async (sql) => {
                                 if (completed)
                                     throw "can't run a command after the transaction was completed";
@@ -139,7 +142,10 @@ class LogSQLCommand {
     }
     args = {};
     addParameterAndReturnSqlToken(val) {
-        let r = this.origin.addParameterAndReturnSqlToken(val);
+        return this.param(val);
+    }
+    param(val, name) {
+        let r = this.origin.param(val);
         this.args[r] = val;
         return r;
     }
@@ -321,8 +327,7 @@ class ActualSQLServerDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement +=
-                        e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                    statement += e.$dbNameOf(x) + ' = ' + r.param(v);
                 }
             }
         }
@@ -364,7 +369,7 @@ class ActualSQLServerDataProvider {
                         vals += ', ';
                     }
                     cols += e.$dbNameOf(x);
-                    vals += r.addParameterAndReturnSqlToken(v);
+                    vals += r.param(v);
                 }
             }
         }
@@ -382,6 +387,9 @@ class myDummySQLCommand {
         throw new Error('Method not implemented.');
     }
     addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
         if (val === null)
             return 'null';
         if (val instanceof Date)
@@ -410,7 +418,7 @@ async function bulkInsert(array, db) {
         sql += items
             .map((row) => '(' +
             row.$.toArray()
-                .map((f) => c.addParameterAndReturnSqlToken(f.metadata.valueConverter.toDb(f.value)))
+                .map((f) => c.param(f.metadata.valueConverter.toDb(f.value)))
                 .join(', ') +
             ')')
             .join(',');

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

@@ -101,6 +101,9 @@ class WebSqlBridgeToSQLCommand {
     }
     values = [];
     addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
         this.values.push(val);
         return '~' + this.values.length + '~';
     }

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

@@ -61,7 +61,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 this.addToWhere(this.nameProvider.$dbNameOf(col) +
                     ' in (' +
                     val
-                        .map((x) => this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x)))
+                        .map((x) => this.r.param(col.valueConverter.toDb(x)))
                         .join(',') +
                     ')');
             else
@@ -110,7 +110,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 ' ' +
                 operator +
                 ' ' +
-                this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
+                this.r.param(col.valueConverter.toDb(val));
             this.addToWhere(x);
         })());
     }
@@ -141,10 +141,15 @@ export class CustomSqlFilterBuilder {
         this.r = r;
     }
     sql = '';
-    addParameterAndReturnSqlToken(val, field) {
-        if (field)
+    /** @deprecated @deprecated use `param` instead*/
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val, field) {
+        if (typeof field === 'object' && field.valueConverter.toDb) {
             val = field.valueConverter.toDb(val);
-        return this.r.addParameterAndReturnSqlToken(val);
+        }
+        return this.r.param(val);
     }
     async filterToRaw(repo, condition) {
         return SqlDatabase.filterToRaw(repo, condition, this);

package/esm/src/remult3/RepositoryImplementation.js

@@ -39,6 +39,12 @@ export class RepositoryImplementation {
     dataProvider;
     _info;
     defaultFindOptions;
+    notFoundError(id) {
+        return {
+            message: `id ${id} not found in entity ${this.metadata.key}`,
+            httpStatusCode: 404,
+        };
+    }
     [getInternalKey]() {
         return this;
     }
@@ -191,8 +197,9 @@ export class RepositoryImplementation {
                 return this.edp.delete(item);
             else {
                 let ref2 = await this.findId(item);
-                if (ref2)
-                    return await getEntityRef(ref2).delete();
+                if (!ref2)
+                    throw this.notFoundError(item);
+                return await getEntityRef(ref2).delete();
             }
         let ref2 = this.getRefForExistingRow(item, undefined);
         if (!this.dataProvider.isProxy)
@@ -201,11 +208,30 @@ export class RepositoryImplementation {
     }
     async insert(entity) {
         if (Array.isArray(entity)) {
-            let r = [];
-            for (const item of entity) {
-                r.push(await this.insert(item));
+            if (this.dataProvider.isProxy) {
+                let refs = [];
+                let raw = [];
+                for (const item of entity) {
+                    let ref = getEntityRef(entity, false);
+                    if (ref) {
+                        if (!ref.isNew())
+                            throw 'Item is not new';
+                    }
+                    else {
+                        ref = (await this.getEntityRef(this.create(item)));
+                    }
+                    refs.push(ref);
+                    raw.push(await ref.buildDtoForInsert());
+                }
+                return Promise.all((await this.edp.insertMany(raw)).map((item, i) => refs[i].processInsertResponseDto(item)));
+            }
+            else {
+                let r = [];
+                for (const item of entity) {
+                    r.push(await this.insert(item));
+                }
+                return r;
             }
-            return r;
         }
         else {
             let ref = getEntityRef(entity, false);
@@ -243,6 +269,20 @@ export class RepositoryImplementation {
             }
         }
     }
+    async updateMany(where, set) {
+        if (this.dataProvider.isProxy) {
+            return this.edp.updateMany(await this.translateWhereToFilter(where), set);
+        }
+        else {
+            let updated = 0;
+            for await (const item of this.query({ where })) {
+                assign(item, set);
+                await getEntityRef(item).save();
+                updated++;
+            }
+            return updated;
+        }
+    }
     async update(id, entity) {
         {
             let ref = getEntityRef(entity, false);
@@ -269,7 +309,7 @@ export class RepositoryImplementation {
         else {
             const r = await ref.reload();
             if (!r)
-                throw new Error('Not Found');
+                throw this.notFoundError(ref.id);
             for (const key in entity) {
                 if (Object.prototype.hasOwnProperty.call(entity, key)) {
                     let f = ref.fields[key];
@@ -595,6 +635,19 @@ export class RepositoryImplementation {
     async count(where) {
         return this.edp.count(await this.translateWhereToFilter(where));
     }
+    async deleteMany(where) {
+        if (this.dataProvider.isProxy) {
+            return this.edp.deleteMany(await this.translateWhereToFilter(where));
+        }
+        else {
+            let deleted = 0;
+            for await (const item of this.query({ where })) {
+                await getEntityRef(item).delete();
+                deleted++;
+            }
+            return deleted;
+        }
+    }
     cache = new Map();
     async findOne(options, skipOrderByAndLimit = false) {
         let r;
@@ -1147,7 +1200,11 @@ export class rowHelperImplementation extends rowHelperBase {
         this.__clearErrorsAndReportChanged();
     }
     async reload() {
-        await this.edp.find({ where: this.getIdFilter() }).then(async (newData) => {
+        await this.edp
+            .find({ where: await this.getIdFilter() })
+            .then(async (newData) => {
+            if (newData.length === 0)
+                throw this.repository.notFoundError(this.id);
             await this.loadDataFrom(newData[0]);
             this.saveOriginalData();
         });
@@ -1232,7 +1289,7 @@ export class rowHelperImplementation extends rowHelperBase {
                     if (!wasChanged)
                         return this.instance;
                     if (doNotSave) {
-                        updatedRow = (await this.edp.find({ where: this.getIdFilter() }))[0];
+                        updatedRow = (await this.edp.find({ where: await this.getIdFilter() }))[0];
                     }
                     else {
                         updatedRow = await this.edp.update(this.id, changesOnly);
@@ -1262,6 +1319,27 @@ export class rowHelperImplementation extends rowHelperBase {
             this._saving = false;
         }
     }
+    async processInsertResponseDto(updatedRow) {
+        await this.loadDataFrom(updatedRow);
+        this.saveOriginalData();
+        this._isNew = false;
+        return this.instance;
+    }
+    async buildDtoForInsert() {
+        await this.__validateEntity();
+        this.__assertValidity();
+        let d = this.copyDataToObject(this.isNew());
+        let ignoreKeys = [];
+        for (const field of this.metadata.fields) {
+            if (field.dbReadOnly) {
+                d[field.key] = undefined;
+                ignoreKeys.push(field.key);
+                let f = this.fields.find(field);
+                f.value = f.originalValue;
+            }
+        }
+        return d;
+    }
     buildLifeCycleEvent(preventDefault = () => { }) {
         const self = this;
         return {
@@ -1275,8 +1353,8 @@ export class rowHelperImplementation extends rowHelperBase {
             relations: self.repository.relations(self.instance),
         };
     }
-    getIdFilter() {
-        return Filter.fromEntityFilter(this.metadata, this.repository.metadata.idMetadata.getIdFilter(this.id));
+    async getIdFilter() {
+        return await this.repository.translateWhereToFilter(this.repository.metadata.idMetadata.getIdFilter(this.id));
     }
     async delete() {
         this.__clearErrorsAndReportChanged();