remult 0.25.7-exp.1 → 0.25.7-exp.2

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/remult3/RepositoryImplementation.js

@@ -208,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);
@@ -250,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);
@@ -602,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;
@@ -1273,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 {

package/esm/src/remult3/remult3.js

@@ -13,17 +13,12 @@ export {};
 
 
 //p1 - add section to Fields doc, explaining field type in db
-/*p1 - JYC - Delete many, update many, insert many
-//p1 - @jycouet regarding required - are you ok with leaving '' as not a good value? (0 will be a good value)
-
-  - post + __action=delet
-  */
-//p1 - JYC - there should be a required that says not null or undefined, but space, 0 etc... should be ok - NOAM- check if removing zero is good enough
 /*y1 - Talk JYC - JYC - add some integrity checks on delete
   - soft delete
   - delete restrict (implicit, or user selected - and if so, how) (delete & update of id)
 
 */
+//y1 תגיד - updateMany צריך להחזיר את השורות שעודכנו (כמו update או insert) או כמה שורות עודכנו (כמו deleteMany)
 /*y1 currency.ts:10 Uncaught TypeError: Currency_1 is not a constructor
 
 @ValueListFieldType()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.7-exp.1",
+    "version": "0.25.7-exp.2",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/data-api.d.ts

@@ -1,6 +1,7 @@
 import type { Remult } from './context.js';
 import type { ErrorInfo } from './data-interfaces.js';
 import type { FindOptions, Repository } from './remult3/remult3.js';
+import type { rowHelperImplementation } from './remult3/RepositoryImplementation.js';
 export declare class DataApi<T = any> {
     private repository;
     private remult;
@@ -10,6 +11,7 @@ export declare class DataApi<T = any> {
     static defaultGetLimit: number;
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
+    deleteMany(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
     getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
         r: any[];
         findOptions: FindOptions<T>;
@@ -19,7 +21,10 @@ export declare class DataApi<T = any> {
     liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
+    updateMany(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    actualUpdate(row: any, body: any): Promise<rowHelperImplementation<T>>;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
+    actualDelete(row: any): Promise<void>;
     delete(response: DataApiResponse, id: any): Promise<void>;
     post(response: DataApiResponse, body: any): Promise<void>;
 }