@appweaver/core 1.0.0

package/resource/resource-service.js

@@ -0,0 +1,772 @@
+"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 security_1 = require("../security");
+const cache_1 = require("../cache");
+const errors_1 = require("../errors");
+class ResourceService {
+    modelName;
+    /** @internal */
+    _db = (0, context_1.inject)(common_1.Database);
+    /** @internal */
+    _events = (0, context_1.inject)(common_1.Events);
+    /** @internal */
+    _cacheService = (0, context_1.inject)(cache_1.CacheService);
+    /** @internal */
+    _client;
+    constructor(modelName) {
+        this.modelName = modelName;
+        this._client = this._db.client()[(0, common_1.uncapitalize)(modelName)];
+        if (!this._client) {
+            throw new Error(`ResourceService initialized with invalid model name: ${modelName}`);
+        }
+    }
+    get client() {
+        return this._client;
+    }
+    async find(id) {
+        const restrictions = await this.readRestrictions('find', id);
+        const includeRelations = this.mapRelationInclusions('find');
+        let resource;
+        try {
+            resource = await this._client.findFirst({
+                where: { id, ...restrictions },
+                include: includeRelations
+            });
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`${this._client.name} find error`, 500, e);
+        }
+        if (!resource || resource.id !== id) {
+            throw new errors_1.HttpError(`${this._client.name} data not found`, 404);
+        }
+        const access = await this.checkAccess('find', resource);
+        if (!access) {
+            throw new errors_1.HttpError(`${this._client.name} data access is forbidden`, 403);
+        }
+        this._events.emitResourceEvent(this._client.name, 'find', {
+            current: resource
+        });
+        return this.projectResource(resource);
+    }
+    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 query = { AND: [mappedFilter, textSearch, restrictions] };
+        const includeRelations = this.mapRelationInclusions('query');
+        const orderBy = this.mapSortValues(sort);
+        let resources;
+        let totalCount;
+        try {
+            [resources, totalCount] = await this._db.client().$transaction([
+                this._client.findMany({
+                    where: { ...query },
+                    include: includeRelations,
+                    skip: (page - 1) * size,
+                    take: size,
+                    orderBy
+                }),
+                this._client.count({
+                    where: { ...query }
+                })
+            ]);
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`${this._client.name} query error`, 500, e);
+        }
+        this._events.emitResourceEvent(this._client.name, 'query', {
+            current: resources
+        });
+        return {
+            resultCount: resources.length,
+            totalCount,
+            items: resources.map((resource) => this.projectResource(resource))
+        };
+    }
+    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 restrictions = await this.readRestrictions('aggregate', filter);
+        const textSearch = this.extractTextSearchQuery(filter);
+        const mappedFilter = this.mapQueryFilter(filter);
+        const query = { AND: [mappedFilter, textSearch, restrictions] };
+        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
+                                }
+                            }
+                        ]
+                    }
+                });
+                // 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
+                                }
+                            }
+                        ]
+                    }
+                })));
+                return [overall, ranges];
+            });
+        }
+        catch (e) {
+            throw new errors_1.HttpError('Error on results aggregation', 500, e);
+        }
+        return {
+            total: this.mapAggregationValues(total, true),
+            items: items.map((item, index) => ({
+                date: dateRanges[index].median,
+                result: this.mapAggregationValues(item, true)
+            }))
+        };
+    }
+    async create(data) {
+        const createdBy = this.createdByConnect();
+        const restrictions = await this.writeRestrictions('create', data);
+        const createData = (0, common_1.removeUndefined)({
+            ...data,
+            ...restrictions
+        });
+        const access = await this.checkAccess('create', createData);
+        if (!access) {
+            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');
+        let resource;
+        try {
+            resource = await this._client.create({
+                data: {
+                    ...sanitizedData,
+                    ...connectRelations,
+                    createdBy
+                },
+                include: includeRelations
+            });
+        }
+        catch (e) {
+            throw new errors_1.HttpError(`${this._client.name} create error`, 500, e);
+        }
+        await this._cacheService.invalidateCache(this._client.name, 'create');
+        this._events.emitResourceEvent(this._client.name, 'create', {
+            current: resource
+        });
+        return this.projectResource(resource);
+    }
+    async update(id, data) {
+        const readRestrictions = await this.readRestrictions('update', {
+            id,
+            ...data
+        });
+        const writeRestrictions = await this.writeRestrictions('update', {
+            id,
+            ...data
+        });
+        const updateData = (0, common_1.removeUndefined)({
+            ...data,
+            ...writeRestrictions
+        });
+        const sanitizedData = this.sanitizeData('update', updateData);
+        const includeRelations = this.mapRelationInclusions('update');
+        let updateResource;
+        let resource;
+        try {
+            [updateResource, resource] = await this._db
+                .client()
+                .$transaction(async (tx) => {
+                const txModel = tx[this._client.name];
+                const current = await txModel.findFirst({
+                    where: { id, ...readRestrictions },
+                    include: includeRelations
+                });
+                if (!current || current.id !== id) {
+                    throw new errors_1.HttpError(`${this._client.name} data not found`, 404);
+                }
+                const access = await this.checkAccess('update', current);
+                if (!access) {
+                    throw new errors_1.HttpError(`${this._client.name} update action is forbidden`, 403);
+                }
+                const setRelations = this.mapRelationActions('update', sanitizedData, current);
+                const updated = await txModel.update({
+                    where: { id },
+                    include: includeRelations,
+                    data: { ...sanitizedData, ...setRelations }
+                });
+                return [current, updated];
+            });
+        }
+        catch (e) {
+            if (e instanceof errors_1.HttpError) {
+                throw e;
+            }
+            throw new errors_1.HttpError(`${this._client.name} update error`, 500, e);
+        }
+        await this._cacheService.invalidateCache(this._client.name, 'update');
+        this._events.emitResourceEvent(this._client.name, 'update', {
+            previous: updateResource,
+            current: resource
+        });
+        return this.projectResource(resource);
+    }
+    async delete(id) {
+        const restrictions = await this.readRestrictions('delete', id);
+        let resource;
+        try {
+            resource = await this._db.client().$transaction(async (tx) => {
+                const txModel = tx[this._client.name];
+                const current = await txModel.findFirst({
+                    where: { id, ...restrictions }
+                });
+                if (!current || current.id !== id) {
+                    throw new errors_1.HttpError(`${this._client.name} data not found`, 404);
+                }
+                const access = await this.checkAccess('delete', current);
+                if (!access) {
+                    throw new errors_1.HttpError(`${this._client.name} delete action is forbidden`, 403);
+                }
+                const includeRelations = this.mapRelationInclusions('delete');
+                return await txModel.delete({
+                    where: { id },
+                    include: includeRelations
+                });
+            });
+        }
+        catch (e) {
+            if (e instanceof errors_1.HttpError) {
+                throw e;
+            }
+            throw new errors_1.HttpError(`${this._client.name} delete error`, 500, e);
+        }
+        await this._cacheService.invalidateCache(this._client.name, 'delete');
+        this._events.emitResourceEvent(this._client.name, 'delete', {
+            current: resource
+        });
+        return this.projectResource(resource);
+    }
+    /**
+     * This method should be overridden with custom logic for restricting read
+     * 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.
+     *
+     * @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:
+     *
+     * - 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.
+     */
+    async readRestrictions(action, data) {
+        return {};
+    }
+    /**
+     * This method should be overridden with custom logic for restricting write
+     * operations on specific data for currently logged-in users and other
+     * authorization rules. The returned object will be applied as a filter on
+     * all actions (create and update) to ensure that users can only modify
+     * data they are authorized to access. This method can also cancel the
+     * 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
+     * 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.
+     */
+    async writeRestrictions(action, data) {
+        return {};
+    }
+    /**
+     * This method should provide logic for checking the access permissions for
+     * the provided resource object. If the resource should not be accessible by
+     *  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.
+     */
+    async checkAccess(action, resource) {
+        return true;
+    }
+    /**
+     * Constructs a query object for performing a text search on resources in the
+     * database based on the provided search text. This method will transform the
+     * 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.
+     */
+    textSearchQuery(searchText) {
+        return {};
+    }
+    extractTextSearchQuery(filter) {
+        if (filter.searchText) {
+            const searchQuery = this.textSearchQuery(filter.searchText);
+            delete filter.searchText;
+            return searchQuery;
+        }
+        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
+        };
+    }
+    projectResource(resource) {
+        const projectedResource = this.projectVirtualFields(resource);
+        if (!(0, common_1.isObject)(projectedResource['_count'])) {
+            return projectedResource;
+        }
+        // Create new relation count properties on the resource object
+        for (const [key, count] of Object.entries(projectedResource['_count'])) {
+            projectedResource[(0, common_1.countFieldName)(key)] = count;
+        }
+        delete projectedResource['_count'];
+        return projectedResource;
+    }
+    projectVirtualFields(resource, resourceName) {
+        if (!resource) {
+            return resource;
+        }
+        const projectedVirtual = { ...resource };
+        const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name, false);
+        const relationsModel = resourceModel?.relationsModel;
+        const filesModel = resourceModel?.filesModel;
+        // Set output or default value for virtual fields
+        for (const [fieldName, virtual] of Object.entries(resourceModel?.config?.virtual ?? {})) {
+            const outputValue = virtual.output?.value;
+            if ((0, common_1.isFunction)(outputValue)) {
+                projectedVirtual[fieldName] = outputValue(projectedVirtual);
+            }
+            else if (outputValue) {
+                projectedVirtual[fieldName] = outputValue;
+            }
+            else if (virtual.required !== false) {
+                projectedVirtual[fieldName] =
+                    virtual.default ?? (0, common_1.defaultScalarValue)(virtual);
+            }
+        }
+        // Recursively project virtual fields for nested relational objects
+        for (const key in projectedVirtual) {
+            const value = projectedVirtual[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]))) {
+                const resourceName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
+                if (resourceName) {
+                    projectedVirtual[key] = (0, common_1.isArray)(value)
+                        ? value.map((item) => this.projectVirtualFields(item, resourceName))
+                        : this.projectVirtualFields(value, resourceName);
+                }
+            }
+        }
+        return projectedVirtual;
+    }
+    sanitizeData(action, data, resourceName) {
+        const sanitizedData = { ...data };
+        const resourceModel = (0, context_1.injectModel)(resourceName ?? this._client.name, false);
+        const relationsModel = resourceModel?.relationsModel;
+        const filesModel = resourceModel?.filesModel;
+        // Delete virtual fields from data object to avoid database errors
+        for (const fieldName of Object.keys(resourceModel?.config?.virtual ?? {})) {
+            delete sanitizedData[fieldName];
+        }
+        // Map default values for hidden scalars if a property is required without
+        // a provided default value, and scalar values are not set yet, this is only
+        // required for create actions
+        for (const [fieldName, scalar] of Object.entries(resourceModel?.config?.scalars ?? {})) {
+            if (action === 'create' &&
+                scalar.hidden &&
+                scalar.required !== false &&
+                scalar.default === undefined &&
+                sanitizedData[fieldName] === undefined) {
+                sanitizedData[fieldName] = (0, common_1.defaultScalarValue)(scalar);
+            }
+        }
+        // Recursively sanitize nested objects and arrays of objects
+        for (const key in sanitizedData) {
+            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]))) {
+                const resourceName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
+                if (resourceName) {
+                    sanitizedData[key] = (0, common_1.isArray)(value)
+                        ? value.map((item) => this.sanitizeData(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
+            if ((0, common_1.isObject)(value) || (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.
+            // Also, do not create a disconnect action if the currentValue is already
+            // null.
+            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;