@appweaver/core 1.1.6 → 1.2.0

package/resource/resource-service.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceService = void 0;
-const date_fns_1 = require("date-fns");
 const common_1 = require("@appweaver/common");
 const context_1 = require("../context");
 const utils_1 = require("../utils");
-const security_1 = require("../security");
 const cache_1 = require("../cache");
 const errors_1 = require("../errors");
+const utils_2 = require("./utils");
 class ResourceService {
     modelName;
     /** @internal */
@@ -18,6 +17,14 @@ class ResourceService {
     _cacheService = (0, context_1.inject)(cache_1.CacheService);
     /** @internal */
     _client;
+    /**
+     * Creates the service for the given resource model and resolves its database
+     * client from the Prisma client instance.
+     *
+     * @param {string} modelName The resource model name this service operates on,
+     * as defined by its model file (i.e. `User`, `Post`).
+     * @throws An error if no database client exists for the provided model name.
+     */
     constructor(modelName) {
         this.modelName = modelName;
         this._client = this._db.client()[(0, common_1.uncapitalize)(modelName)];
@@ -25,12 +32,32 @@ class ResourceService {
             throw new Error(`ResourceService initialized with invalid model name: ${modelName}`);
         }
     }
+    /**
+     * The underlying Prisma model delegate for this resource, useful for
+     * executing custom database operations that the service methods do not cover.
+     *
+     * @returns {ResourceClient} The resource client of the model this service was
+     * created for.
+     */
     get client() {
         return this._client;
     }
+    /**
+     * Finds a single resource by its id, applying the read restrictions and the
+     * access check of this service, and including all relation and file fields
+     * configured for output on the find action. A resource event is emitted after
+     * a successful lookup.
+     *
+     * @param {number} id The id of the resource to find.
+     * @returns {Promise<Object>} The found resource with its virtual fields and
+     * relation counts projected.
+     * @throws {@link HttpError} 404 if the resource does not exist or is filtered
+     * out by the read restrictions, 403 if the access check denies it, and 500 on
+     * a database error.
+     */
     async find(id) {
         const restrictions = await this.readRestrictions('find', id);
-        const includeRelations = this.mapRelationInclusions('find');
+        const includeRelations = (0, utils_2.mapRelationInclusions)(this._client.name, 'find');
         let resource;
         try {
             resource = await this._client.findFirst({
@@ -53,13 +80,42 @@ class ResourceService {
         });
         return this.projectResource(resource);
     }
+    /**
+     * Queries a page of resources matching the provided filter. The filter is
+     * mapped to a database query, combined with the optional `searchText` full
+     * text search query and the read restrictions of this service, and executed
+     * together with the total count in a single transaction. A resource event is
+     * emitted after a successful query.
+     *
+     * @param {Object} [filter] The query filter object, supporting the logical
+     * (`_and`, `_or`, `_not`, `_nor`), comparison (`_eq`, `_ne`, `_gt`, `_gte`,
+     * `_lt`, `_lte`, `_in`, `_nin`, `_between`, `_like`, `_ilike`, `_starts`,
+     * `_ends`, `_contains`, `_exists`), list (`_has`, `_hasSome`, `_hasEvery`,
+     * `_isEmpty`), and relation (`_some`, `_every`, `_none`) operators, as well
+     * as plain field values. Its `searchText` property, if present, is passed to
+     * {@link ResourceService.textSearchQuery} instead of being matched as a
+     * field.
+     * @param {number} [page] The one-based page number of results to return.
+     * @param {number} [size] The maximum number of results per page.
+     * @param {QuerySort} [sort] The fields to sort by, either as a comma-separated
+     * list where a field prefixed with `-` is sorted in descending order
+     * (i.e. `-createdAt,id`), or as an object of field directions
+     * (i.e. `{ createdAt: 'desc', id: 'asc' }`). Both forms support the fields of
+     * the included to-one relations, given with a dot notation (`author.createdAt`)
+     * or as a nested object (`{ author: { createdAt: 'desc' } }`).
+     * @returns {Promise<QueryResponse<Object>>} The paged query response containing
+     * the returned resources, the count of the returned items and the total count
+     * of matching resources.
+     * @throws {@link HttpError} 400 if the sort input names a field that cannot be
+     * sorted by, and 500 on a database error.
+     */
     async query(filter = {}, page = 1, size = 50, sort = '-createdAt,id') {
         const restrictions = await this.readRestrictions('query', filter);
         const textSearch = this.extractTextSearchQuery(filter);
-        const mappedFilter = this.mapQueryFilter(filter);
+        const mappedFilter = (0, utils_2.mapQueryFilter)(filter, this._client.name);
         const query = { AND: [mappedFilter, textSearch, restrictions] };
-        const includeRelations = this.mapRelationInclusions('query');
-        const orderBy = this.mapSortValues(sort);
+        const includeRelations = (0, utils_2.mapRelationInclusions)(this._client.name, 'query');
+        const orderBy = (0, utils_2.mapSortValues)(sort, this._client.name, 'query');
         let resources;
         let totalCount;
         try {
@@ -88,60 +144,72 @@ class ResourceService {
             items: resources.map((resource) => this.projectResource(resource))
         };
     }
+    /**
+     * Aggregates resources matching the provided filter over a date range, both
+     * as a single overall result and as a series of results for the equally sized
+     * periods the range is split into. All aggregations are executed in a single
+     * transaction.
+     *
+     * @param {Object} [filter] The query filter object, mapped the same way as in
+     * {@link ResourceService.query}.
+     * @param {AggregateSelect<Object>} select The aggregation operations to perform
+     * per field (i.e. `{ views: { count: true, sum: true } }`). Only the numeric
+     * fields of the model accept every operator, while its date fields accept
+     * `count`, `min`, `max`, `first` and `last`. The `first` and `last` operators
+     * take the value the earliest and the latest record of a period holds, which
+     * costs one additional query per period and boundary, skipped for the periods
+     * holding no record.
+     * @param {string} [dateField] The date field the range is applied on.
+     * @param {string} [from] The ISO date string of the range start. Defaults to
+     * seven days before the range end.
+     * @param {string} [to] The ISO date string of the range end. Defaults to the
+     * current date and time.
+     * @param {number} [step] The size of a single period in units of the
+     * automatically selected time unit. If not provided, one unit is used and the
+     * unit is derived from the range length (seconds up to a minute, minutes up to
+     * an hour, hours up to a day, days up to a month, months up to a year, and
+     * years beyond that).
+     * @param {boolean} [safeIncrement] Whether the period increments use the
+     * derived time unit and stay consistent across daylight saving time changes.
+     * When false, the step is interpreted in seconds.
+     * @returns {Promise<AggregateResponse<Object>>} The aggregation response with
+     * the overall total and one result per period, each labeled with the median
+     * date of its period.
+     * @throws {@link HttpError} 400 if the selection is empty or names a field or
+     * operator that cannot be aggregated, and 500 on a database error.
+     */
     async aggregate(filter = {}, select, dateField = 'createdAt', from, to, step, safeIncrement = true) {
-        const toDate = (0, date_fns_1.parseISO)(to ?? new Date().toISOString());
-        const fromDate = from ? (0, date_fns_1.parseISO)(from) : (0, date_fns_1.subDays)(toDate, 7);
-        const iterator = this.makeAggregationIterator(fromDate, toDate, step, safeIncrement);
-        const dateRanges = [];
-        let currentDate = (0, date_fns_1.parseISO)(fromDate.toISOString());
-        while (currentDate < toDate) {
-            const date = currentDate;
-            const median = iterator.addPeriod(date, (iterator.step - 1) / 2);
-            currentDate = iterator.addPeriod(currentDate, iterator.step);
-            dateRanges.push({ from: date, to: currentDate, median });
-        }
-        const aggregateOperations = this.mapAggregationValues(select);
+        const { fromDate, toDate, ranges: dateRanges } = (0, utils_2.buildAggregationPeriods)(from, to, step, safeIncrement);
+        const operations = (0, utils_2.mapAggregationSelect)(select, this._client.name);
+        (0, utils_2.checkAggregationDateField)(dateField, this._client.name);
         const restrictions = await this.readRestrictions('aggregate', filter);
         const textSearch = this.extractTextSearchQuery(filter);
-        const mappedFilter = this.mapQueryFilter(filter);
+        const mappedFilter = (0, utils_2.mapQueryFilter)(filter, this._client.name);
         const query = { AND: [mappedFilter, textSearch, restrictions] };
+        const rangeQuery = (rangeFrom, rangeTo) => ({
+            AND: [query, { [dateField]: { gte: rangeFrom, lt: rangeTo } }]
+        });
+        // Aggregates a single range and reads the boundary records it holds the
+        // first and last values of which the database cannot aggregate
+        const aggregateRange = async (txModel, where) => {
+            const result = await txModel.aggregate({
+                ...operations.aggregate,
+                where
+            });
+            const boundaries = await (0, utils_2.readAggregationBoundaries)(txModel, where, dateField, operations, (0, utils_2.aggregationRecordCount)(result));
+            return { ...result, ...boundaries };
+        };
         let total = {};
         let items = [];
         try {
             [total, items] = await this._db.client().$transaction(async (tx) => {
                 const txModel = tx[this._client.name];
-                const overall = await txModel.aggregate({
-                    ...aggregateOperations,
-                    where: {
-                        AND: [
-                            query,
-                            {
-                                [dateField]: {
-                                    gte: fromDate,
-                                    lt: toDate
-                                }
-                            }
-                        ]
-                    }
-                });
+                const overall = await aggregateRange(txModel, rangeQuery(fromDate, toDate));
                 // Skip executing the same query if only one range value is generated
                 if (dateRanges.length === 1) {
                     return [overall, [overall]];
                 }
-                const ranges = await Promise.all(dateRanges.map((dateRange) => txModel.aggregate({
-                    ...aggregateOperations,
-                    where: {
-                        AND: [
-                            query,
-                            {
-                                [dateField]: {
-                                    gte: dateRange.from,
-                                    lt: dateRange.to
-                                }
-                            }
-                        ]
-                    }
-                })));
+                const ranges = await Promise.all(dateRanges.map((dateRange) => aggregateRange(txModel, rangeQuery(dateRange.from, dateRange.to))));
                 return [overall, ranges];
             });
         }
@@ -149,15 +217,32 @@ class ResourceService {
             throw new errors_1.HttpError('Error on results aggregation', 500, e);
         }
         return {
-            total: this.mapAggregationValues(total, true),
+            total: (0, utils_2.mapAggregationResult)(total),
             items: items.map((item, index) => ({
                 date: dateRanges[index].median,
-                result: this.mapAggregationValues(item, true)
+                result: (0, utils_2.mapAggregationResult)(item)
             }))
         };
     }
+    /**
+     * Creates a new resource. The provided data is merged with the write
+     * restrictions, checked for access, sanitized against the model configuration
+     * and mapped to the relation write actions (connect, create, or
+     * connect-or-create) before the record is created. The `createdBy` audit
+     * relation is connected to the currently authenticated user when configured.
+     * The resource cache is invalidated and a resource event is emitted after a
+     * successful create.
+     *
+     * @param {Object} data The data of the resource to create, including any inline
+     * relation and file payloads.
+     * @returns {Promise<Object>} The created resource with its virtual fields and
+     * relation counts projected.
+     * @throws {@link HttpError} 403 if the access check denies the action, 400 if
+     * an inline relation payload is missing required fields or the relation does
+     * not accept new records, and 500 on a database error.
+     */
     async create(data) {
-        const createdBy = this.createdByConnect();
+        const createdBy = (0, utils_2.createdByConnect)(this._client.name);
         const restrictions = await this.writeRestrictions('create', data);
         const createData = (0, common_1.removeUndefined)({
             ...data,
@@ -168,8 +253,8 @@ class ResourceService {
             throw new errors_1.HttpError(`${this._client.name} create action is forbidden`, 403);
         }
         const sanitizedData = this.sanitizeData('create', createData);
-        const connectRelations = this.mapRelationActions('create', sanitizedData);
-        const includeRelations = this.mapRelationInclusions('create');
+        const connectRelations = (0, utils_2.mapRelationActions)(this._client.name, 'create', sanitizedData);
+        const includeRelations = (0, utils_2.mapRelationInclusions)(this._client.name, 'create');
         let resource;
         try {
             resource = await this._client.create({
@@ -190,6 +275,25 @@ class ResourceService {
         });
         return this.projectResource(resource);
     }
+    /**
+     * Updates an existing resource by its id. The current record is loaded with
+     * the read restrictions applied and checked for access, then updated with the
+     * data merged with the write restrictions inside a single transaction.
+     * Relations missing from the new value are disconnected, or deleted when
+     * `orphanRemoval` is configured for them. The resource cache is invalidated
+     * and a resource event carrying both the previous and the current state is
+     * emitted after a successful update.
+     *
+     * @param {number} id The id of the resource to update.
+     * @param {Object} data The partial data to update the resource with, including
+     * any inline relation and file payloads.
+     * @returns {Promise<Object>} The updated resource with its virtual fields and
+     * relation counts projected.
+     * @throws {@link HttpError} 404 if the resource does not exist or is filtered
+     * out by the read restrictions, 403 if the access check denies the action, 400
+     * if an inline relation payload is missing required fields or the relation
+     * does not accept new records, and 500 on a database error.
+     */
     async update(id, data) {
         const readRestrictions = await this.readRestrictions('update', {
             id,
@@ -204,7 +308,7 @@ class ResourceService {
             ...writeRestrictions
         });
         const sanitizedData = this.sanitizeData('update', updateData);
-        const includeRelations = this.mapRelationInclusions('update');
+        const includeRelations = (0, utils_2.mapRelationInclusions)(this._client.name, 'update');
         let updateResource;
         let resource;
         try {
@@ -223,7 +327,7 @@ class ResourceService {
                 if (!access) {
                     throw new errors_1.HttpError(`${this._client.name} update action is forbidden`, 403);
                 }
-                const setRelations = this.mapRelationActions('update', sanitizedData, current);
+                const setRelations = (0, utils_2.mapRelationActions)(this._client.name, 'update', sanitizedData, current);
                 const updated = await txModel.update({
                     where: { id },
                     include: includeRelations,
@@ -245,6 +349,19 @@ class ResourceService {
         });
         return this.projectResource(resource);
     }
+    /**
+     * Deletes an existing resource by its id. The current record is loaded with
+     * the read restrictions applied and checked for access before it is deleted
+     * inside a single transaction. The resource cache is invalidated and a
+     * resource event is emitted after a successful delete.
+     *
+     * @param {number} id The id of the resource to delete.
+     * @returns {Promise<Object>} The deleted resource with its virtual fields and
+     * relation counts projected.
+     * @throws {@link HttpError} 404 if the resource does not exist or is filtered
+     * out by the read restrictions, 403 if the access check denies the action, and
+     * 500 on a database error.
+     */
     async delete(id) {
         const restrictions = await this.readRestrictions('delete', id);
         let resource;
@@ -261,7 +378,7 @@ class ResourceService {
                 if (!access) {
                     throw new errors_1.HttpError(`${this._client.name} delete action is forbidden`, 403);
                 }
-                const includeRelations = this.mapRelationInclusions('delete');
+                const includeRelations = (0, utils_2.mapRelationInclusions)(this._client.name, 'delete');
                 return await txModel.delete({
                     where: { id },
                     include: includeRelations
@@ -285,21 +402,24 @@ class ResourceService {
      * operations on specific data for currently logged-in user and other
      * authorization rules. The returned object will be applied as a filter on
      * all actions (except create action) which will prevent unwanted data access
-     * and modifications. This method can also cancel current action by throwing
-     * an error, recommended is {@link HttpError } with appropriate HTTP error
-     * code.
+     * and modifications. This method can also cancel the current action by
+     * throwing an error, recommended is {@link HttpError } with appropriate HTTP
+     * error code.
      *
-     * @param action The called action method on this service (find, query,
-     * aggregate, update, or delete)
-     * @param data The passed data to the called function, can be number or
-     * object. If the data is a type of number, then it represents the resource
-     * id, otherwise it depends on the action and can be one of the following:
+     * @param {ActionType} action The called action method on this service (find,
+     * query, aggregate, update, or delete)
+     * @param {Object|number} data The passed data to the called function can be
+     * number or object. If the data is a type of number, then it represents the
+     * resource id, otherwise it depends on the action and can be one of the
+     * following:
      *
      * - query and aggregate -> filter object
      * - update -> combined id and the data object (i.e. { id, ...data })
      *
      * For other actions (find and delete) it represents the resource id.
-     * @return The filter containing additional query restrictions.
+     * @return {Promise<Object>} The database-level `where` conditions containing
+     * additional query restrictions. The returned object is applied directly to
+     * the database query, so it uses the native Prisma filter syntax.
      */
     async readRestrictions(action, data) {
         return {};
@@ -313,13 +433,15 @@ class ResourceService {
      * current action by throwing an error, with the recommended type being
      * {@link HttpError} with the appropriate HTTP error code.
      *
-     * @param action The called action method on this service (create or update)
-     * @param data The passed data to the called function, which should be an
-     * object representing the resource data to be created or updated. For
+     * @param {'create'|'update'} action The called action method on this service
+     * (create or update)
+     * @param {Object} data The passed data to the called function, which should be
+     * an object representing the resource data to be created or updated. For
      * update operations, this object will also include the resource ID.
      *
-     * @return A partial object containing additional data restrictions to be
-     * applied, or an empty object if no restrictions are necessary.
+     * @return {Promise<Object>} A partial object containing additional data
+     * restrictions to be applied, or an empty object if no restrictions are
+     * necessary.
      */
     async writeRestrictions(action, data) {
         return {};
@@ -330,10 +452,11 @@ class ResourceService {
      *  a currently authenticated user or other logic, this method should return
      * false. Otherwise, it returns true and continues with the request execution.
      *
-     * @param action The called action method on this service (find, query,
-     * aggregate, create, update, or delete)
-     * @param resource The resource object that is being check for access.
-     * @returns True if the access for resource is granted, false otherwise.
+     * @param {ActionType} action The called action method on this service (find,
+     * query, aggregate, create, update, or delete)
+     * @param {Object} resource The resource object that is being checked for access.
+     * @returns {Promise<boolean>} True if the access for resource is granted, false
+     * otherwise.
      */
     async checkAccess(action, resource) {
         return true;
@@ -344,14 +467,25 @@ class ResourceService {
      * search text into a format suitable for text search functionality, returning
      * a query object that can be used to filter results.
      *
-     * @param searchText The text string used for searching resources.
-     * @returns A query object that represents the conditions for the text
-     * search operation. This will be used by the database query methods to
-     * retrieve matching resources.
+     * @param {string} searchText The text string used for searching resources.
+     * @returns {Object} A query object that represents the conditions for the text
+     * search operation, using the native Prisma filter syntax. This will be used
+     * by the database query methods to retrieve matching resources.
      */
     textSearchQuery(searchText) {
         return {};
     }
+    /**
+     * Removes the `searchText` property from the provided filter and converts it
+     * into a text search query using
+     * {@link ResourceService.textSearchQuery}. The filter object is mutated so the
+     * search text is not matched as a regular resource field.
+     *
+     * @param {Object} filter The request filter object, possibly containing a
+     * `searchText` property. The property is deleted from this object when present.
+     * @returns {Object} The text search query for the extracted search text, or an
+     * empty object if the filter contains no search text.
+     */
     extractTextSearchQuery(filter) {
         if (filter.searchText) {
             const searchQuery = this.textSearchQuery(filter.searchText);
@@ -360,92 +494,20 @@ class ResourceService {
         }
         return {};
     }
-    mapSortValues(sort) {
-        const sortMap = {};
-        const resourceModel = (0, context_1.injectModel)(this._client.name);
-        const parts = sort.split(',');
-        for (const part of parts) {
-            let path = part.trim();
-            const order = path.startsWith('-') ? 'desc' : 'asc';
-            path = path.replace(/[-+]/g, '');
-            // Skip the default sort by createdAt field if not configured
-            if (resourceModel.config.audit?.createdAt === false &&
-                path === 'createdAt') {
-                continue;
-            }
-            // Map relations count field sort order.
-            if ((0, common_1.isCountField)(path)) {
-                path = path.replace('Count', '._count');
-            }
-            (0, common_1.setValue)(sortMap, path, order);
-        }
-        return Object.entries(sortMap).map(([key, value]) => ({ [key]: value }));
-    }
-    mapAggregationValues(select, isOutput = false) {
-        const aggregationMap = {};
-        for (const field in select) {
-            const operators = select[field];
-            for (const operator in operators) {
-                const value = operators[operator];
-                const path = isOutput
-                    ? `${operator}.${field.substring(1)}`
-                    : `_${operator}.${field}`;
-                (0, common_1.setValue)(aggregationMap, path, value);
-            }
-        }
-        return aggregationMap;
-    }
-    makeAggregationIterator(fromDate, toDate, step, safeIncrement = true) {
-        let stepAmount = step;
-        let incrementFn = date_fns_1.addSeconds;
-        if (!stepAmount) {
-            const diffInSeconds = (0, date_fns_1.differenceInSeconds)(toDate, fromDate);
-            const diffInMonths = (0, date_fns_1.differenceInMonths)(toDate, fromDate);
-            const diffInYears = (0, date_fns_1.differenceInYears)(toDate, fromDate);
-            stepAmount = 1;
-            // 1-second step if the difference is less than or equal to 1 minute
-            if (diffInSeconds <= 60) {
-                incrementFn = date_fns_1.addSeconds;
-            }
-            // 1-minute step if the difference is less than or equal to 1 hour
-            else if (diffInSeconds <= 3600) {
-                incrementFn = date_fns_1.addMinutes;
-            }
-            // 1-hour step if the difference is less than or equal to 1 day
-            else if (diffInSeconds <= 86400) {
-                incrementFn = date_fns_1.addHours;
-            }
-            // 1-day step if the difference is less than or equal to 1 month
-            else if (diffInMonths <= 1) {
-                incrementFn = date_fns_1.addDays;
-            }
-            // 1-month step if the difference is less than or equal to 1 year
-            else if (diffInYears <= 1) {
-                incrementFn = date_fns_1.addMonths;
-            }
-            // 1-year step if the difference is equal to 1 year or more
-            else {
-                incrementFn = date_fns_1.addYears;
-            }
-        }
-        // A higher-order function that adjusts date increments to account for
-        // changes in daylight saving time (DST). When incrementing dates in time
-        // zones that observe DST, this function ensures that the resulting date
-        // remains consistent with the original date's time zone offset.
-        const dstAgnosticFn = (fn) => {
-            return (date, amount) => {
-                const endDate = fn(date, amount);
-                return (0, date_fns_1.addMinutes)(endDate, date.getTimezoneOffset() - endDate.getTimezoneOffset());
-            };
-        };
-        return {
-            addPeriod: dstAgnosticFn(safeIncrement ? incrementFn : date_fns_1.addSeconds),
-            step: stepAmount
-        };
-    }
+    /**
+     * Prepares a resource for the response by resolving the virtual fields of its
+     * model and flattening the Prisma `_count` aggregation into the individual
+     * relation count fields (i.e. `_count.posts` becomes `postsCount`).
+     *
+     * @param {Object} resource The resource object as returned by the database
+     * client.
+     * @returns {Object} The same resource with the virtual fields resolved and, if a
+     * `_count` selection was present, with a count property per counted relation
+     * and the `_count` property removed.
+     */
     projectResource(resource) {
         const projectedResource = (0, utils_1.projectVirtualFields)(resource, this._client.name);
-        if (!(0, common_1.isObject)(projectedResource['_count'])) {
+        if (!(0, common_1.isPlainObject)(projectedResource['_count'])) {
             return projectedResource;
         }
         // Create new relation count properties on the resource object
@@ -455,6 +517,25 @@ class ResourceService {
         delete projectedResource['_count'];
         return projectedResource;
     }
+    /**
+     * Prepares a write payload for the database by removing the virtual fields
+     * that have no column, filling in default values for the hidden required
+     * scalars of a create action, and recursively applying the same rules to the
+     * nested relation and file payloads. Unique key values, arrays of them and null
+     * values are left untouched, so the relation actions can still map them to the
+     * connect and disconnect operations.
+     *
+     * @param {'create'|'update'} action The write action the payload is sanitized
+     * for. Default values for the hidden required scalars are only applied on a
+     * create action.
+     * @param {Object} data The write payload to sanitize.
+     * @param {string} [resourceName] The name of the model the payload belongs to.
+     * Defaults to the model of this service and is set to the related model name
+     * when recursing into a nested relation or file payload.
+     * @returns {Object} A shallow copy of the payload without the virtual fields,
+     * with the missing hidden required scalars defaulted, and with the nested
+     * payloads sanitized against their own models.
+     */
     sanitizeData(action, data, resourceName) {
         const sanitizedData = { ...data };
         const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name, false);
@@ -481,257 +562,19 @@ class ResourceService {
             const value = sanitizedData[key];
             const relationSchema = (0, common_1.extractSchemaProperties)(relationsModel, key);
             const fileSchema = (0, common_1.extractSchemaProperties)(filesModel, key);
-            if ((0, common_1.isObject)(value) || ((0, common_1.isArray)(value) && (0, common_1.isObject)(value[0]))) {
+            // Only nested resource payloads are sanitized. Unique key values, arrays
+            // of them and null values are left untouched, so the relation actions can
+            // still map them to connect and disconnect operations.
+            if ((0, common_1.isPlainObject)(value) || ((0, common_1.isArray)(value) && (0, common_1.isPlainObject)(value[0]))) {
                 const resourceName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
                 if (resourceName) {
                     sanitizedData[key] = (0, common_1.isArray)(value)
-                        ? value.map((item) => this.sanitizeData(item, resourceName))
+                        ? value.map((item) => this.sanitizeData(action, item, resourceName))
                         : this.sanitizeData(action, value, resourceName);
                 }
             }
         }
         return sanitizedData;
     }
-    mapQueryFilter(filter, resourceName) {
-        const queryFilter = {};
-        const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name, false);
-        const readModel = resourceModel?.readModel;
-        const relationsModel = resourceModel?.relationsModel;
-        const filesModel = resourceModel?.filesModel;
-        for (const key in filter) {
-            const value = filter[key];
-            const readSchema = (0, common_1.extractSchemaProperties)(readModel, key);
-            const relationSchema = (0, common_1.extractSchemaProperties)(relationsModel, key);
-            const fileSchema = (0, common_1.extractSchemaProperties)(filesModel, key);
-            const isArrayType = readSchema?.type === 'array' ||
-                relationSchema?.type === 'array' ||
-                fileSchema?.type === 'array';
-            const isArrayValue = (0, common_1.isArray)(value);
-            // Recursively map nested objects and handle arrays of objects. Arrays of
-            // plain values are mapped below as inclusion, range or relation filters.
-            if (((0, common_1.isObject)(value) && !isArrayValue) ||
-                (isArrayValue && (0, common_1.isObject)(value[0]))) {
-                const resourceName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
-                if (resourceName) {
-                    queryFilter[key] = isArrayValue
-                        ? value.map((item) => this.mapQueryFilter(item, resourceName))
-                        : this.mapQueryFilter(value, resourceName);
-                }
-            }
-            // Map ID values for both single and array types of relationships
-            else if (relationSchema || fileSchema) {
-                const queryId = { id: isArrayValue ? { in: value } : value };
-                queryFilter[key] = isArrayType ? { some: queryId } : queryId;
-            }
-            // Map fields without relationships, supporting array types
-            else if (readSchema) {
-                if (isArrayType) {
-                    queryFilter[key] = isArrayValue ? { hasSome: value } : { has: value };
-                }
-                else if (isArrayValue) {
-                    // For date and numeric types, apply range filtering with inclusive
-                    // intervals
-                    if (value.length > 0 &&
-                        value.length <= 2 &&
-                        (['number', 'integer'].includes(readSchema.type) ||
-                            ['date', 'date-time'].includes(readSchema.format))) {
-                        queryFilter[key] = {
-                            gte: value[0],
-                            lte: value[1]
-                        };
-                    }
-                    // Map array values for inclusion checks
-                    else {
-                        queryFilter[key] = { in: value };
-                    }
-                }
-            }
-            // If no query filter was defined, assign the original value
-            if (queryFilter[key] === undefined) {
-                queryFilter[key] = value;
-            }
-        }
-        return queryFilter;
-    }
-    mapRelationInclusions(action, resourceName) {
-        const inclusion = {};
-        const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name);
-        const relationConfig = resourceModel.config.relations;
-        const fileConfig = resourceModel.config.files;
-        const relationModelProps = (0, common_1.extractSchemaProperties)(resourceModel.relationsModel);
-        const fileModelProps = (0, common_1.extractSchemaProperties)(resourceModel.filesModel);
-        // Add relation and file fields to the inclusion map if the include type is
-        // satisfied or the requested action is not specified. Also, add the count
-        // aggregation actions for relations if configured.
-        for (const key of Object.keys({
-            ...relationModelProps,
-            ...fileModelProps
-        })) {
-            const relationField = relationConfig?.[key] || fileConfig?.[key];
-            if (relationField?.output?.count) {
-                inclusion._count = inclusion._count ?? { select: {} };
-                inclusion._count.select[key] = true;
-            }
-            // Check if the relation should be included based on the output type
-            if (this.shouldIncludeRelation(relationField?.output?.type, action)) {
-                inclusion[key] = this.buildNestedInclusion(relationField, action);
-            }
-        }
-        return inclusion;
-    }
-    buildNestedInclusion(relationField, action) {
-        const nestedIncludeConfig = relationField?.output?.include;
-        if (!nestedIncludeConfig || Object.keys(nestedIncludeConfig).length === 0) {
-            return true;
-        }
-        const nestedInclusion = {};
-        for (const [nestedKey, nestedOutput] of Object.entries(nestedIncludeConfig)) {
-            // Check if the nested relation should be included
-            if (this.shouldIncludeRelation(nestedOutput?.type, action)) {
-                // Recursively build nested inclusions
-                nestedInclusion[nestedKey] = this.buildNestedInclusion({ output: nestedOutput }, action);
-            }
-        }
-        return Object.keys(nestedInclusion).length > 0
-            ? { include: nestedInclusion }
-            : true;
-    }
-    shouldIncludeRelation(outputType, action) {
-        if (outputType === 'none') {
-            return false;
-        }
-        if (outputType === 'single' && action === 'query') {
-            return false;
-        }
-        return !(outputType === 'multiple' && action && action !== 'query');
-    }
-    mapRelationActions(action, data, currentData) {
-        const relations = {};
-        const resourceModel = (0, context_1.injectModel)(this._client.name);
-        const readModel = resourceModel.readModel;
-        const relationsModel = resourceModel.relationsModel;
-        const relationsConfig = resourceModel.config.relations;
-        for (const key in data) {
-            let value = data[key];
-            const relationSchema = (0, common_1.extractSchemaProperties)(relationsModel, key);
-            if (!relationSchema) {
-                // Set empty array or undefined value for null array type fields
-                if (value === null) {
-                    if ((0, common_1.extractSchemaProperties)(readModel, key)?.type === 'array') {
-                        relations[key] = action === 'update' ? [] : undefined;
-                    }
-                    else if (action === 'create') {
-                        relations[key] = undefined;
-                    }
-                }
-                // Skip mapping for non-relation fields
-                continue;
-            }
-            const config = relationsConfig?.[key];
-            const uniqueKey = config?.input?.uniqueKey || 'id';
-            const isArrayType = relationSchema.type === 'array';
-            // Normalize array values to single values if a value type is not an array
-            if (!isArrayType && (0, common_1.isArray)(value)) {
-                value = value[0];
-            }
-            // Set null values to undefined value for create actions. On update action
-            // they will be returned as disconnected relations.
-            if (action === 'create' && value === null) {
-                relations[key] = undefined;
-                continue;
-            }
-            // Normalize plain unique key values or arrays to object values
-            if (isArrayType) {
-                if ((0, common_1.isArray)(value) && !(0, common_1.isObject)([0])) {
-                    value = value.map((v) => ({
-                        [uniqueKey]: v
-                    }));
-                }
-            }
-            else {
-                if (!(0, common_1.isObject)(value)) {
-                    value = { [uniqueKey]: value };
-                }
-            }
-            // Map relation connections with an option to create a non-existing entity
-            if (config?.createIfNotExists && value) {
-                const createdBy = this.createdByConnect(config.model);
-                if (isArrayType) {
-                    relations[key] = {
-                        connectOrCreate: value.map((v) => ({
-                            where: v[uniqueKey] ? { [uniqueKey]: v[uniqueKey] } : { id: 0 },
-                            create: { ...v, createdBy, id: undefined }
-                        }))
-                    };
-                }
-                else {
-                    relations[key] = {
-                        connectOrCreate: {
-                            where: value[uniqueKey]
-                                ? { [uniqueKey]: value[uniqueKey] }
-                                : { id: 0 },
-                            create: { ...value, createdBy, id: undefined }
-                        }
-                    };
-                }
-            }
-            else if (value) {
-                if (isArrayType && (0, common_1.isArray)(value)) {
-                    relations[key] = {
-                        connect: value.map((v) => ({ [uniqueKey]: v[uniqueKey] }))
-                    };
-                }
-                else {
-                    relations[key] = { connect: { [uniqueKey]: value[uniqueKey] } };
-                }
-            }
-            // Map relation disconnects if unique keys are no longer present or the
-            // new value is null. Delete relations if orphanRemoval is set to true.
-            // Relations that are not set on the current resource are left untouched,
-            // so no relation action is applied for them.
-            if (action === 'update') {
-                const currentValue = currentData[key];
-                const removalMethod = config?.orphanRemoval ? 'delete' : 'disconnect';
-                if (currentValue && isArrayType) {
-                    const newValueKeys = value?.map((v) => v[uniqueKey]) ?? [];
-                    const currentValueKeys = currentValue
-                        .filter((v) => newValueKeys.indexOf(v[uniqueKey]) === -1)
-                        .map((v) => ({
-                        [uniqueKey]: v[uniqueKey]
-                    }));
-                    if (currentValueKeys.length > 0) {
-                        relations[key] = {
-                            [removalMethod]: currentValueKeys,
-                            ...(relations[key] ?? {})
-                        };
-                    }
-                }
-                else if (currentValue && value === null) {
-                    relations[key] = {
-                        [removalMethod]: { [uniqueKey]: currentValue[uniqueKey] },
-                        ...(relations[key] ?? {})
-                    };
-                }
-                else if (!currentValue) {
-                    relations[key] = undefined;
-                }
-            }
-        }
-        return relations;
-    }
-    createdByConnect(resourceName) {
-        const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name, false);
-        if (resourceModel?.config.audit?.createdById === false) {
-            return undefined;
-        }
-        const currentUser = (0, security_1.currentAuthUser)();
-        return currentUser
-            ? {
-                connect: {
-                    id: currentUser.id
-                }
-            }
-            : undefined;
-    }
 }
 exports.ResourceService = ResourceService;