remult 0.25.8 → 0.26.0

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);
+            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 +95,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 +162,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 +201,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')
@@ -197,19 +213,29 @@ export class DataApi {
                 where.push(this.repository.metadata.options.apiPrefilter);
         }
         if (request) {
-            where.push(buildFilterFromRequestParameters(this.repository.metadata, {
+            let f = buildFilterFromRequestParameters(this.repository.metadata, {
                 get: (key) => {
-                    let result = request.get(key);
+                    let result = body?.where?.[key];
+                    if (result !== undefined)
+                        return result;
+                    result = request.get(key);
                     if (key.startsWith(customUrlToken) &&
                         result &&
                         typeof result === 'string')
                         return JSON.parse(result);
                     return result;
                 },
-            }));
+            });
+            if (this.repository.metadata.options.apiPreprocessFilter) {
+                f = await this.repository.metadata.options.apiPreprocessFilter(f, {
+                    metadata: this.repository.metadata,
+                    getFilterPreciseValues: async (filter) => {
+                        return Filter.getPreciseValues(this.repository.metadata, filter || f);
+                    },
+                });
+            }
+            where.push(f);
         }
-        if (filterBody)
-            where.push(Filter.entityFilterFromJson(this.repository.metadata, filterBody));
         return { $and: where };
     }
     async doOnId(response, id, what) {
@@ -232,21 +258,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 updateManyThroughPutRequest(response, request, body) {
+        const action = request?.get('__action');
+        if (action == 'emptyId') {
+            return this.put(response, '', body);
         }
+        return this.updateManyImplementation(response, request, {
+            where: undefined,
+            set: body,
+        });
     }
-    async updateMany(response, request, body) {
+    async updateManyImplementation(response, request, body) {
         try {
+            let where = await this.buildWhere(request, body);
+            Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
             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,
                     include: this.includeNone(),
                 })) {
                     await this.actualUpdate(x, body.set);
@@ -256,7 +297,7 @@ export class DataApi {
             });
         }
         catch (err) {
-            response.error(err);
+            response.error(err, this.repository.metadata);
         }
     }
     async actualUpdate(row, body) {
@@ -311,9 +352,9 @@ export class DataApi {
         }
         catch (err) {
             if (err.isForbiddenError)
-                response.forbidden();
+                response.forbidden(err.message);
             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

@@ -6,14 +6,16 @@ import { getRepository } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
+import { isOfType } from '../isOfType.js';
 // @dynamic
 export class SqlDatabase {
     sql;
-    static getDb(remult) {
-        const r = (remult || defaultRemult).dataProvider;
-        if (!r.createCommand)
-            throw 'the data provider is not an SqlDatabase';
-        return r;
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
+        if (isOfType(r, 'createCommand'))
+            return r;
+        else
+            throw 'the data provider is not an SqlCommandFactory';
     }
     createCommand() {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
@@ -74,6 +76,7 @@ export class SqlDatabase {
                     transaction: (z) => x.transaction(z),
                     supportsJsonColumnType: this.sql.supportsJsonColumnType,
                     wrapIdentifier: this.wrapIdentifier,
+                    end: this.end,
                 }));
             }
             finally {
@@ -81,6 +84,16 @@ export class SqlDatabase {
             }
         });
     }
+    /**
+     * Creates a raw filter for entity filtering.
+     * @param {CustomSqlFilterBuilderFunction} build - The custom SQL filter builder function.
+     * @returns {EntityFilter<any>} - The entity filter with a custom SQL filter.
+     * @example
+     * SqlDatabase.rawFilter(({param}) =>
+          `"customerId" in (select id from customers where city = ${param(customerCity)})`
+        )
+     * @see [Leveraging Database Capabilities with Raw SQL in Custom Filters](https://remult.dev/docs/custom-filter.html#leveraging-database-capabilities-with-raw-sql-in-custom-filters)
+     */
     static rawFilter(build) {
         return {
             [customDatabaseFilterToken]: {
@@ -88,12 +101,12 @@ export class SqlDatabase {
             },
         };
     }
-    static async filterToRaw(repo, condition, sqlCommand, dbNames) {
+    static async filterToRaw(repo, condition, sqlCommand, dbNames, wrapIdentifier = (x) => x) {
         if (!sqlCommand) {
             sqlCommand = new myDummySQLCommand();
         }
         const r = getRepository(repo);
-        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, dbNames || (await dbNamesOf(r.metadata)));
+        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, dbNames || (await dbNamesOf(r.metadata, wrapIdentifier)));
         b._addWhere = false;
         await (await getRepositoryInternals(r)._translateWhereToFilter(condition)).__applyToConsumer(b);
         return await b.resolveWhere();
@@ -116,8 +129,15 @@ export class SqlDatabase {
         this.sql = sql;
         if (sql.wrapIdentifier)
             this.wrapIdentifier = (x) => sql.wrapIdentifier(x);
+        if (isOfType(sql, 'provideMigrationBuilder')) {
+            this.provideMigrationBuilder = (x) => sql.provideMigrationBuilder(x);
+        }
+        if (isOfType(sql, 'end'))
+            this.end = () => sql.end();
     }
+    provideMigrationBuilder;
     createdEntities = [];
+    end;
 }
 const icons = new Map([
     // CRUD
@@ -336,6 +356,11 @@ class ActualSQLServerDataProvider {
         statement += ' returning ' + select;
         return r.execute(statement).then((sqlResult) => {
             this.sql._getSourceSql().afterMutation?.();
+            if (sqlResult.rows.length != 1)
+                throw new Error('Failed to update row with id ' +
+                    id +
+                    ', rows updated: ' +
+                    sqlResult.rows.length);
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }

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

@@ -13,15 +13,7 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
-    // return instance of websql.Database class - see @types/websql
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
-        if (!me.db) {
-            throw 'the data provider is not a WebSqlDataProvider';
-        }
-        return me.db;
-    }
+    async end() { }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }

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

@@ -126,34 +126,55 @@ export class FilterConsumerBridgeToSqlRequest {
     databaseCustom(databaseCustom) {
         this.promises.push((async () => {
             if (databaseCustom?.buildSql) {
-                let item = new CustomSqlFilterBuilder(this.r);
-                await databaseCustom.buildSql(item);
-                if (item.sql) {
-                    this.addToWhere('(' + item.sql + ')');
+                let item = new CustomSqlFilterBuilder(this.r, this.nameProvider.wrapIdentifier);
+                let sql = await databaseCustom.buildSql(item);
+                if (typeof sql !== 'string')
+                    sql = item.sql;
+                if (sql) {
+                    this.addToWhere('(' + sql + ')');
                 }
             }
         })());
     }
 }
+/**
+ * Represents a custom SQL filter builder.
+ */
 export class CustomSqlFilterBuilder {
     r;
-    constructor(r) {
+    wrapIdentifier;
+    constructor(r, wrapIdentifier) {
         this.r = r;
+        this.wrapIdentifier = wrapIdentifier;
+        this.param.bind(this);
+        this.filterToRaw.bind(this);
     }
     sql = '';
-    /** @deprecated @deprecated use `param` instead*/
+    /** @deprecated  use `param` instead*/
     addParameterAndReturnSqlToken(val) {
         return this.param(val);
     }
-    param(val, field) {
+    /**
+     * Adds a parameter value.
+     * @param {valueType} val - The value to add as a parameter.
+     * @param {FieldMetadata<valueType>} [field] - The field metadata.
+     * @returns {string} - The SQL token.
+     */
+    param = (val, field) => {
         if (typeof field === 'object' && field.valueConverter.toDb) {
             val = field.valueConverter.toDb(val);
         }
         return this.r.param(val);
-    }
-    async filterToRaw(repo, condition) {
-        return SqlDatabase.filterToRaw(repo, condition, this);
-    }
+    };
+    /**
+     * Converts an entity filter into a raw SQL condition - and appends to it any `backendPrefilter` and `backendPreprocessFilter`
+     * @param {RepositoryOverloads<entityType>} repo - The repository.
+     * @param {EntityFilter<entityType>} condition - The entity filter.
+     * @returns {Promise<string>} - The raw SQL.
+     */
+    filterToRaw = async (repo, condition) => {
+        return SqlDatabase.filterToRaw(repo, condition, this, undefined, this.wrapIdentifier);
+    };
 }
 export function isDbReadonly(field, dbNames) {
     return (field.dbReadOnly ||
@@ -164,6 +185,10 @@ export function shouldNotCreateField(field, dbNames) {
     return (field.isServerExpression ||
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
+export function shouldCreateEntity(entity, e) {
+    return (!entity.options.sqlExpression &&
+        e.$entityName.toLowerCase().indexOf('from ') < 0);
+}
 export async function dbNamesOf(repo, wrapIdentifierOrOptions) {
     let options = typeof wrapIdentifierOrOptions === 'function'
         ? { wrapIdentifier: wrapIdentifierOrOptions }
@@ -185,6 +210,7 @@ export async function dbNamesOf(repo, wrapIdentifierOrOptions) {
                 key = field.key;
             return result[key];
         },
+        wrapIdentifier: options.wrapIdentifier,
     };
     for (const field of meta.fields) {
         let r = await fieldDbName(field, meta, options.wrapIdentifier);