remult 0.25.8-exp.2 → 0.25.8-exp.4

package/esm/graphql.js

@@ -904,7 +904,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }));
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
     }
-    return result;
+    return { where: result };
 }

package/esm/server/expressBridge.js

@@ -250,8 +250,8 @@ export class RemultServerImplementation {
             console.info('[remult] ' + myRoute);
         r.route(myRoute)
             .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c))))
-            .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).put(res, '', await this.coreOptions.getRequestBody(orig))))
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
+            .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).updateMany(res, req, await this.coreOptions.getRequestBody(orig))))
+            .delete(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).deleteMany(res, req, undefined)))
             .post(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).httpPost(res, req, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));
         r.route(myRoute + '/:id')
             //@ts-ignore
@@ -467,6 +467,17 @@ export class RemultServerImplementation {
                     return secureBase(condition, def, item);
                 };
                 let apiPath = (spec.paths[this.options.rootPath + '/' + key] = {});
+                let itemInBody = {
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/' + mutationKey,
+                                },
+                            },
+                        },
+                    },
+                };
                 let apiPathWithId = (spec.paths[this.options.rootPath + '/' + key + '/{id}'] = {});
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
@@ -519,6 +530,73 @@ export class RemultServerImplementation {
                         },
                     },
                 });
+                apiPath.delete = secure(meta.options.allowApiDelete, true, {
+                    description: 'deletes row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: [...parameters],
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of deleted rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            deleted: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                apiPath.put = secure(meta.options.allowApiDelete, true, {
+                    description: 'updates row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: [...parameters],
+                    ...itemInBody,
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of updated rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            updated: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
                 let idParameter = {
                     name: 'id',
                     in: 'path',
@@ -526,17 +604,6 @@ export class RemultServerImplementation {
                     required: true,
                     schema: { type: 'string' },
                 };
-                let itemInBody = {
-                    requestBody: {
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    $ref: '#/components/schemas/' + mutationKey,
-                                },
-                            },
-                        },
-                    },
-                };
                 apiPath.post = secure(meta.options.allowApiInsert, false, {
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,

package/esm/src/CompoundIdField.js

@@ -22,11 +22,17 @@ export class CompoundIdField {
         return Promise.resolve('');
     }
     getId(instance) {
+        let get = (field) => {
+            return instance[field.key];
+        };
+        if (typeof instance === 'function') {
+            get = instance;
+        }
         let r = '';
         this.fields.forEach((c) => {
             if (r.length > 0)
                 r += ',';
-            r += instance[c.key];
+            r += c.valueConverter.toJson(get(c));
         });
         return r;
     }
@@ -49,7 +55,7 @@ export class CompoundIdField {
         let val = value.toString();
         let id = val.split(',');
         this.fields.forEach((c, i) => {
-            result[c.key] = id[i];
+            result[c.key] = c.valueConverter.fromJson(id[i]);
         });
         return result;
     }

package/esm/src/data-api.js

@@ -23,17 +23,31 @@ export class DataApi {
     }
     async httpPost(res, req, body, serializeContext) {
         const action = req?.get('__action');
-        if (action?.startsWith(liveQueryAction))
+        function validateWhereInBody() {
+            if (!body?.where) {
+                throw {
+                    message: `POST with action ${action} must have a where clause in the body`,
+                    httpStatusCode: 400,
+                };
+            }
+        }
+        if (action?.startsWith(liveQueryAction)) {
+            validateWhereInBody();
             return this.liveQuery(res, req, body, serializeContext, action.substring(liveQueryAction.length));
+        }
         switch (action) {
             case 'get':
+                validateWhereInBody();
                 return this.getArray(res, req, body);
             case 'count':
+                validateWhereInBody();
                 return this.count(res, req, body);
             case 'deleteMany':
+                validateWhereInBody();
                 return this.deleteMany(res, req, body);
             case 'updateMany':
-                return this.updateMany(res, req, body);
+                validateWhereInBody();
+                return this.updateManyImplementation(res, req, body);
             case 'endLiveQuery':
                 await this.remult.liveQueryStorage.remove(body.id);
                 res.success('ok');
@@ -50,26 +64,28 @@ export class DataApi {
         }
         await this.doOnId(response, id, async (row) => response.success(this.repository.getEntityRef(row).toApiJson()));
     }
-    async count(response, request, filterBody) {
+    async count(response, request, body) {
         if (!this.repository.metadata.apiReadAllowed) {
             response.forbidden();
             return;
         }
         try {
             response.success({
-                count: +(await this.repository.count(await this.buildWhere(request, filterBody))),
+                count: +(await this.repository.count(await this.buildWhere(request, body))),
             });
         }
         catch (err) {
             response.error(err, this.repository.metadata);
         }
     }
-    async deleteMany(response, request, filterBody) {
+    async deleteMany(response, request, body) {
         try {
+            let deleted = 0;
+            let where = await this.buildWhere(request, body);
+            Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
             return await doTransaction(this.remult, async () => {
-                let deleted = 0;
                 for await (const x of this.repository.query({
-                    where: await this.buildWhere(request, filterBody),
+                    where,
                     include: this.includeNone(),
                 })) {
                     await this.actualDelete(x);
@@ -82,12 +98,12 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async getArrayImpl(response, request, filterBody) {
+    async getArrayImpl(response, request, body) {
         let findOptions = {
             load: () => [],
             include: this.includeNone(),
         };
-        findOptions.where = await this.buildWhere(request, filterBody);
+        findOptions.where = await this.buildWhere(request, body);
         if (request) {
             let sort = request.get('_sort');
             if (sort != undefined) {
@@ -146,13 +162,13 @@ export class DataApi {
         }
         return include;
     }
-    async getArray(response, request, filterBody) {
+    async getArray(response, request, body) {
         if (!this.repository.metadata.apiReadAllowed) {
             response.forbidden();
             return;
         }
         try {
-            const { r } = await this.getArrayImpl(response, request, filterBody);
+            const { r } = await this.getArrayImpl(response, request, body);
             response.success(r);
         }
         catch (err) {
@@ -162,13 +178,13 @@ export class DataApi {
                 response.error(err, this.repository.metadata);
         }
     }
-    async liveQuery(response, request, filterBody, serializeContext, queryChannel) {
+    async liveQuery(response, request, body, serializeContext, queryChannel) {
         if (!this.repository.metadata.apiReadAllowed) {
             response.forbidden();
             return;
         }
         try {
-            const r = await this.getArrayImpl(response, request, filterBody);
+            const r = await this.getArrayImpl(response, request, body);
             const data = {
                 requestJson: await serializeContext(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
@@ -188,7 +204,7 @@ export class DataApi {
                 response.error(err, this.repository.metadata);
         }
     }
-    async buildWhere(request, filterBody) {
+    async buildWhere(request, body) {
         var where = [];
         if (this.repository.metadata.options.apiPrefilter) {
             if (typeof this.repository.metadata.options.apiPrefilter === 'function')
@@ -208,8 +224,8 @@ export class DataApi {
                 },
             }));
         }
-        if (filterBody)
-            where.push(Filter.entityFilterFromJson(this.repository.metadata, filterBody));
+        if (body?.where)
+            where.push(Filter.entityFilterFromJson(this.repository.metadata, body.where));
         return { $and: where };
     }
     async doOnId(response, id, what) {
@@ -245,11 +261,23 @@ export class DataApi {
         }
     }
     async updateMany(response, request, body) {
+        const action = request?.get('__action');
+        if (action == 'emptyId') {
+            return this.put(response, '', body);
+        }
+        let where = await this.buildWhere(request, body);
+        Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
+        return this.updateManyImplementation(response, request, {
+            where: undefined,
+            set: body,
+        });
+    }
+    async updateManyImplementation(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),
+                    where: await this.buildWhere(request, body),
                     include: this.includeNone(),
                 })) {
                     await this.actualUpdate(x, body.set);

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

@@ -120,26 +120,27 @@ export class RestEntityDataProvider {
         return run('count').then((r) => +r.count);
     }
     async deleteMany(where) {
-        const { run } = this.buildFindRequest({ where }, true);
+        const { run } = this.buildFindRequest({ where }, 'delete');
         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);
+        const { run } = this.buildFindRequest({ where }, 'put');
+        return run('updateMany', 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, forcePost = false) {
+    buildFindRequest(options, method) {
+        if (!method)
+            method = 'get';
         let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
             if (options.where) {
                 filterObject = options.where.toJson(); //        options.where.__applyToConsumer(new FilterConsumnerBridgeToUrlBuilder(url));
-                if (!forcePost &&
-                    addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
+                if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
                     filterObject = undefined;
             }
             if (options.orderBy && options.orderBy.Segments) {
@@ -173,15 +174,12 @@ export class RestEntityDataProvider {
             }
             if (action)
                 u.add('__action', action);
-            if (filterObject || forcePost) {
-                if (!body)
-                    body = filterObject;
-                else
-                    body = { ...body, where: filterObject };
+            if (filterObject) {
+                body = { set: body, where: filterObject };
                 return this.http().post(u.url, body);
             }
             else
-                return this.http().get(u.url);
+                return this.http()[method](u.url, body);
         };
         return {
             createKey: () => JSON.stringify({ url, filterObject }),
@@ -201,7 +199,8 @@ export class RestEntityDataProvider {
     }
     update(id, data) {
         return this.http()
-            .put(this.url() + '/' + encodeURIComponent(id), this.toJsonOfIncludedKeys(data))
+            .put(this.url() +
+            (id != '' ? '/' + encodeURIComponent(id) : '?__action=emptyId'), this.toJsonOfIncludedKeys(data))
             .then((y) => this.translateFromJson(y));
     }
     toJsonOfIncludedKeys(data) {
@@ -213,8 +212,11 @@ export class RestEntityDataProvider {
         }
         return result;
     }
-    delete(id) {
-        return this.http().delete(this.url() + '/' + encodeURIComponent(id));
+    async delete(id) {
+        if (id == '')
+            await this.deleteMany(Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)));
+        else
+            return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
     insert(data) {
         return this.http()

package/esm/src/filter/filter-interfaces.js

@@ -6,6 +6,37 @@ import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
  */
 export class Filter {
     apply;
+    //@internal
+    static throwErrorIfFilterIsEmpty(where, methodName) {
+        if (Filter.isFilterEmpty(where)) {
+            throw {
+                message: `${methodName}: requires a filter to protect against accidental delete/update of all rows`,
+                httpStatusCode: 400,
+            };
+        }
+    }
+    //@internal
+    static isFilterEmpty(where) {
+        if (where.$and) {
+            for (const a of where.$and) {
+                if (!Filter.isFilterEmpty(a)) {
+                    return false;
+                }
+            }
+        }
+        if (where.$or) {
+            for (const a of where.$or) {
+                if (Filter.isFilterEmpty(a)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (Object.keys(where).filter((x) => !['$or', '$and'].includes(x)).length == 0) {
+            return true;
+        }
+        return false;
+    }
     static createCustom(rawFilterTranslator, key = '') {
         let rawFilterInfo = { key: key, rawFilterTranslator };
         return Object.assign((x) => {

package/esm/src/remult3/RepositoryImplementation.js

@@ -270,6 +270,7 @@ export class RepositoryImplementation {
         }
     }
     async updateMany(where, set) {
+        Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
         if (this._dataProvider.isProxy) {
             return this._edp.updateMany(await this._translateWhereToFilter(where), set);
         }
@@ -636,6 +637,7 @@ export class RepositoryImplementation {
         return this._edp.count(await this._translateWhereToFilter(where));
     }
     async deleteMany(where) {
+        Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
         if (this._dataProvider.isProxy) {
             return this._edp.deleteMany(await this._translateWhereToFilter(where));
         }
@@ -1184,7 +1186,7 @@ export class rowHelperImplementation extends rowHelperBase {
             return this.instance[y.key];
         };
         if (this.metadata.idMetadata.field instanceof CompoundIdField)
-            return this.metadata.idMetadata.field.fields.map(getVal).join(',');
+            return this.metadata.idMetadata.field.getId(getVal);
         return getVal(this.metadata.idMetadata.field);
     }
     saveMoreOriginalData() {

package/esm/src/remult3/remult3.js

@@ -1,16 +1,8 @@
 export {};
+//p1 - should the remult api be deleteMany({id:[1,2]}) or deleteMany({where:{id:[1,2]}})
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-/*p1 - discuss using delete & put - with url query language for deleteMany and updateMany -
-- put & delete, similar to get
-- add where to count, deleteMany,updateMany,
-- prevent delete all and update all - must have meaningful where.
-- try forcing this also in typescript
-
-- protect against deleting of all rows by mistake
-- https://github.com/remult/remult/issues/221#issuecomment-2016519746
-
-*/
 //y1 - getFields didn't work for kobi in the home component
+//y1 - consider replacing all errors with error classes that extend the base Error class
 //p1 - document offline support
 //p1 - add section to Fields doc, explaining field type in db
 //p1 - add section about union type

package/esm/src/valueConverters.js

@@ -136,7 +136,7 @@ export class ValueConverters {
         toJson: (value) => ValueConverters.Number.toDb(value),
         fromInput: (x, type) => {
             let r = +x;
-            if (!x)
+            if (x === null || x === undefined)
                 return undefined;
             return r;
         },

package/graphql.js

@@ -1081,10 +1081,8 @@ function translateWhereToRestBody(fields, _a) {
         finally { if (e_7) throw e_7.error; }
     }
     if (where.OR) {
-        result.OR = where.OR.map(function (where) {
-            return translateWhereToRestBody(fields, { where: where });
-        });
+        result.OR = where.OR.map(function (where) { return translateWhereToRestBody(fields, { where: where }).where; });
     }
-    return result;
+    return { where: result };
 }
 exports.translateWhereToRestBody = translateWhereToRestBody;

package/package.json

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

package/server/expressBridge.js

@@ -444,16 +444,16 @@ var RemultServerImplementation = /** @class */ (function () {
             return tslib_1.__generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
-                        _b = (_a = dataApiFactory(c)).put;
+                        _b = (_a = dataApiFactory(c)).updateMany;
                         _c = [res,
-                            ''];
+                            req];
                         return [4 /*yield*/, this.coreOptions.getRequestBody(orig)];
                     case 1: return [2 /*return*/, _b.apply(_a, _c.concat([_d.sent()]))];
                 }
             });
         }); }))
-            .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-            return [2 /*return*/, dataApiFactory(c).delete(res, '')];
+            .delete(this.process(function (c, req, res, _, __, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).deleteMany(res, req, undefined)];
         }); }); }))
             .post(this.process(function (c, req, res, _, __, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
             var _a, _b, _c;
@@ -792,6 +792,17 @@ var RemultServerImplementation = /** @class */ (function () {
                     return secureBase(condition, def, item);
                 };
                 var apiPath = (spec.paths[this_2.options.rootPath + '/' + key] = {});
+                var itemInBody = {
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/' + mutationKey,
+                                },
+                            },
+                        },
+                    },
+                };
                 var apiPathWithId = (spec.paths[this_2.options.rootPath + '/' + key + '/{id}'] = {});
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
@@ -843,6 +854,68 @@ var RemultServerImplementation = /** @class */ (function () {
                         },
                     },
                 });
+                apiPath.delete = secure(meta.options.allowApiDelete, true, {
+                    description: 'deletes row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: tslib_1.__spreadArray([], tslib_1.__read(parameters), false),
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of deleted rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            deleted: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                apiPath.put = secure(meta.options.allowApiDelete, true, tslib_1.__assign(tslib_1.__assign({ description: 'updates row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)', parameters: tslib_1.__spreadArray([], tslib_1.__read(parameters), false) }, itemInBody), { responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of updated rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            updated: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    } }));
                 var idParameter = {
                     name: 'id',
                     in: 'path',
@@ -850,17 +923,6 @@ var RemultServerImplementation = /** @class */ (function () {
                     required: true,
                     schema: { type: 'string' },
                 };
-                var itemInBody = {
-                    requestBody: {
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    $ref: '#/components/schemas/' + mutationKey,
-                                },
-                            },
-                        },
-                    },
-                };
                 apiPath.post = secure(meta.options.allowApiInsert, false, tslib_1.__assign(tslib_1.__assign({ 
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,

package/src/CompoundIdField.js

@@ -28,11 +28,17 @@ var CompoundIdField = /** @class */ (function () {
         return Promise.resolve('');
     };
     CompoundIdField.prototype.getId = function (instance) {
+        var get = function (field) {
+            return instance[field.key];
+        };
+        if (typeof instance === 'function') {
+            get = instance;
+        }
         var r = '';
         this.fields.forEach(function (c) {
             if (r.length > 0)
                 r += ',';
-            r += instance[c.key];
+            r += c.valueConverter.toJson(get(c));
         });
         return r;
     };
@@ -48,7 +54,7 @@ var CompoundIdField = /** @class */ (function () {
         var val = value.toString();
         var id = val.split(',');
         this.fields.forEach(function (c, i) {
-            result[c.key] = id[i];
+            result[c.key] = c.valueConverter.fromJson(id[i]);
         });
         return result;
     };