remult 0.25.8-exp.1 → 0.25.8-exp.3

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/migrations/generate-migrations.js

@@ -5,6 +5,18 @@ import { updateMigrationsFile } from './update-migrations-ts-file.js';
 import { DefaultMigrationBuilder, } from './migration-types.js';
 import { isOfType } from '../src/isOfType.js';
 import { initDataProvider } from '../server/initDataProvider.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes to be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/server/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is true.
+ * @see [Migrations](http://remult.dev/docs/migrations.html)
+ */
 export async function generateMigrations(options) {
     const migrationDir = options.migrationsFolder ||
         path.join(process.cwd(), 'src/server/migrations');

package/esm/migrations/migrate.js

@@ -3,6 +3,16 @@ import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
 import { initDataProvider } from '../server/initDataProvider.js';
 import { doTransaction } from '../src/context.js';
 import { cast, isOfType } from '../src/isOfType.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is true.
+* @see [Migrations](http://remult.dev/docs/migrations.html)
+*/
 export async function migrate(options) {
     let migrationTableName = options.migrationsTable || '__remult_migrations_version';
     const dataProvider = await initDataProvider(options.dataProvider);

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

@@ -8,8 +8,8 @@ export class PostgresDataProvider {
     pool;
     options;
     supportsJsonColumnType = true;
-    static getDb(remult) {
-        const r = (remult || defaultRemult).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
         if (!r._getSourceSql)
             throw 'the data provider is not an SqlDatabase';
         const me = r._getSourceSql();

package/esm/remult-knex/index.js

@@ -41,8 +41,8 @@ export class KnexDataProvider {
     execute(sql) {
         return this.createCommand().execute(sql);
     }
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.knex)
             throw 'the data provider is not an KnexDataProvider';
         return r.knex;

package/esm/remult-mongo.js

@@ -16,8 +16,8 @@ export class MongoDataProvider {
     }
     session;
     disableTransactions = false;
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.db)
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };

package/esm/server/expressBridge.js

@@ -13,6 +13,7 @@ import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
 import remultAdminHtml from './remult-admin.js';
+import { isOfType } from '../src/isOfType.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -249,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
@@ -285,7 +286,7 @@ export class RemultServerImplementation {
                     genReq.params = req['_tempParams'];
             }
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
             try {
                 await this.runWithRemult(async (remult) => {
                     if (req) {
@@ -315,7 +316,7 @@ export class RemultServerImplementation {
                 });
             }
             catch (err) {
-                myRes.error(serializeError(err));
+                myRes.error(err, undefined);
             }
         };
     }
@@ -466,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, {
@@ -518,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',
@@ -525,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,
@@ -673,15 +741,17 @@ class ExpressRequestBridgeToDataApiRequest {
 class ExpressResponseBridgeToDataApiResponse {
     r;
     req;
+    handleError;
     forbidden() {
-        this.setStatus(403).end();
+        this.error({ message: 'Forbidden' }, undefined, 403);
     }
     setStatus(status) {
         return this.r.status(status);
     }
-    constructor(r, req) {
+    constructor(r, req, handleError) {
         this.r = r;
         this.req = req;
+        this.handleError = handleError;
     }
     progress(progress) { }
     success(data) {
@@ -694,22 +764,53 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(204).end();
     }
     notFound() {
-        this.setStatus(404).end();
+        this.error({ message: 'Forbidden' }, undefined, 404);
     }
-    error(data) {
-        data = serializeError(data);
-        console.error({
-            message: data.message,
-            stack: data.stack?.split('\n'),
-            url: this.req?.url,
-            method: this.req?.method,
+    async error(exception, entity, httpStatusCode) {
+        let data = serializeError(exception);
+        if (!httpStatusCode) {
+            if (data.httpStatusCode) {
+                httpStatusCode = data.httpStatusCode;
+            }
+            else if (isOfType(exception, 'isForbiddenError') &&
+                exception.isForbiddenError) {
+                httpStatusCode = 403;
+            }
+            else if (data.modelState) {
+                httpStatusCode = 400;
+            }
+            else {
+                httpStatusCode = 500;
+            }
+        }
+        let responseSent = false;
+        const sendError = (httpStatusCode, body) => {
+            if (responseSent) {
+                throw Error('Error response already sent');
+            }
+            responseSent = true;
+            console.error({
+                message: body.message,
+                httpStatusCode,
+                stack: data.stack?.split('\n'),
+                url: this.req?.url,
+                method: this.req?.method,
+            });
+            this.setStatus(httpStatusCode).json(body);
+        };
+        await this.handleError?.({
+            httpStatusCode,
+            req: this.req,
+            entity,
+            exception,
+            responseBody: data,
+            sendError,
         });
-        this.setStatus(400).json(data);
+        if (!responseSent) {
+            sendError(httpStatusCode, data);
+        }
     }
 }
-function throwError() {
-    throw 'Invalid';
-}
 class inProcessQueueHandler {
     storage;
     constructor(storage) {

package/esm/src/data-api.js

@@ -33,7 +33,7 @@ export class DataApi {
             case 'deleteMany':
                 return this.deleteMany(res, req, body);
             case 'updateMany':
-                return this.updateMany(res, req, body);
+                return this.updateManyImplementation(res, req, body);
             case 'endLiveQuery':
                 await this.remult.liveQueryStorage.remove(body.id);
                 res.success('ok');
@@ -50,26 +50,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);
+            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);
@@ -79,15 +81,15 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            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,29 +148,29 @@ 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) {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                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),
@@ -185,10 +187,10 @@ export class DataApi {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                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 +210,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) {
@@ -232,21 +234,36 @@ export class DataApi {
                 if (r.length == 0)
                     response.notFound();
                 else if (r.length > 1)
-                    response.error({ message: 'id is not unique' });
+                    response.error({
+                        message: `id "${id}" is not unique for entity ` +
+                            this.repository.metadata.key,
+                    }, this.repository.metadata, 500);
                 else
                     await what(r[0]);
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     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);
@@ -256,7 +273,7 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async actualUpdate(row, body) {
@@ -313,7 +330,7 @@ export class DataApi {
             if (err.isForbiddenError)
                 response.forbidden();
             else
-                response.error(err);
+                response.error(err, this.repository.metadata);
         }
     }
 }

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/data-providers/sql-database.js

@@ -10,8 +10,8 @@ import { isOfType } from '../isOfType.js';
 // @dynamic
 export class SqlDatabase {
     sql;
-    static getDb(remult) {
-        const r = (remult || defaultRemult).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
         if (isOfType(r, 'createCommand'))
             return r;
         else

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));
         }