@zenstackhq/server 2.2.4 → 2.3.0

package/api/rest/index.js

@@ -1,18 +1,12 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestApiHandler = void 0;
+exports.default = makeHandler;
+exports.RestApiHandler = makeHandler;
+exports.default = makeHandler;
+exports.RestApiHandler = makeHandler;
 const runtime_1 = require("@zenstackhq/runtime");
 const change_case_1 = require("change-case");
 const lower_case_first_1 = require("lower-case-first");
@@ -167,328 +161,316 @@ class RequestHandler extends base_1.APIHandlerBase {
             data: zod_1.default.array(zod_1.default.object({ type: zod_1.default.string(), id: zod_1.default.union([zod_1.default.string(), zod_1.default.number()]) })),
         });
     }
-    handleRequest(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ prisma, method, path, query, requestBody, logger, modelMeta, zodSchemas, }) {
-            modelMeta = modelMeta !== null && modelMeta !== void 0 ? modelMeta : this.defaultModelMeta;
-            if (!modelMeta) {
-                throw new Error('Model metadata is not provided or loaded from default location');
-            }
-            if (!this.serializers) {
-                this.buildSerializers(modelMeta);
-            }
-            if (!this.typeMap) {
-                this.buildTypeMap(logger, modelMeta);
-            }
-            method = method.toUpperCase();
-            if (!path.startsWith('/')) {
-                path = '/' + path;
-            }
-            try {
-                switch (method) {
-                    case 'GET': {
-                        let match = urlPatterns.single.match(path);
-                        if (match) {
-                            // single resource read
-                            return yield this.processSingleRead(prisma, match.type, match.id, query);
-                        }
-                        match = urlPatterns.fetchRelationship.match(path);
-                        if (match) {
-                            // fetch related resource(s)
-                            return yield this.processFetchRelated(prisma, match.type, match.id, match.relationship, query);
-                        }
-                        match = urlPatterns.relationship.match(path);
-                        if (match) {
-                            // read relationship
-                            return yield this.processReadRelationship(prisma, match.type, match.id, match.relationship, query, modelMeta);
-                        }
-                        match = urlPatterns.collection.match(path);
-                        if (match) {
-                            // collection read
-                            return yield this.processCollectionRead(prisma, match.type, query);
-                        }
-                        return this.makeError('invalidPath');
+    async handleRequest({ prisma, method, path, query, requestBody, logger, modelMeta, zodSchemas, }) {
+        modelMeta = modelMeta ?? this.defaultModelMeta;
+        if (!modelMeta) {
+            throw new Error('Model metadata is not provided or loaded from default location');
+        }
+        if (!this.serializers) {
+            this.buildSerializers(modelMeta);
+        }
+        if (!this.typeMap) {
+            this.buildTypeMap(logger, modelMeta);
+        }
+        method = method.toUpperCase();
+        if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        try {
+            switch (method) {
+                case 'GET': {
+                    let match = urlPatterns.single.match(path);
+                    if (match) {
+                        // single resource read
+                        return await this.processSingleRead(prisma, match.type, match.id, query);
                     }
-                    case 'POST': {
-                        if (!requestBody) {
-                            return this.makeError('invalidPayload');
-                        }
-                        let match = urlPatterns.collection.match(path);
-                        if (match) {
-                            // resource creation
-                            return yield this.processCreate(prisma, match.type, query, requestBody, zodSchemas);
-                        }
-                        match = urlPatterns.relationship.match(path);
-                        if (match) {
-                            // relationship creation (collection relationship only)
-                            return yield this.processRelationshipCRUD(prisma, 'create', match.type, match.id, match.relationship, query, requestBody);
-                        }
-                        return this.makeError('invalidPath');
+                    match = urlPatterns.fetchRelationship.match(path);
+                    if (match) {
+                        // fetch related resource(s)
+                        return await this.processFetchRelated(prisma, match.type, match.id, match.relationship, query);
                     }
-                    // TODO: PUT for full update
-                    case 'PUT':
-                    case 'PATCH': {
-                        if (!requestBody) {
-                            return this.makeError('invalidPayload');
-                        }
-                        let match = urlPatterns.single.match(path);
-                        if (match) {
-                            // resource update
-                            return yield this.processUpdate(prisma, match.type, match.id, query, requestBody, zodSchemas);
-                        }
-                        match = urlPatterns.relationship.match(path);
-                        if (match) {
-                            // relationship update
-                            return yield this.processRelationshipCRUD(prisma, 'update', match.type, match.id, match.relationship, query, requestBody);
-                        }
-                        return this.makeError('invalidPath');
+                    match = urlPatterns.relationship.match(path);
+                    if (match) {
+                        // read relationship
+                        return await this.processReadRelationship(prisma, match.type, match.id, match.relationship, query, modelMeta);
                     }
-                    case 'DELETE': {
-                        let match = urlPatterns.single.match(path);
-                        if (match) {
-                            // resource deletion
-                            return yield this.processDelete(prisma, match.type, match.id);
-                        }
-                        match = urlPatterns.relationship.match(path);
-                        if (match) {
-                            // relationship deletion (collection relationship only)
-                            return yield this.processRelationshipCRUD(prisma, 'delete', match.type, match.id, match.relationship, query, requestBody);
-                        }
-                        return this.makeError('invalidPath');
+                    match = urlPatterns.collection.match(path);
+                    if (match) {
+                        // collection read
+                        return await this.processCollectionRead(prisma, match.type, query);
                     }
-                    default:
-                        return this.makeError('invalidPath');
-                }
-            }
-            catch (err) {
-                if (err instanceof InvalidValueError) {
-                    return this.makeError('invalidValue', err.message);
+                    return this.makeError('invalidPath');
                 }
-                else {
-                    return this.handlePrismaError(err);
+                case 'POST': {
+                    if (!requestBody) {
+                        return this.makeError('invalidPayload');
+                    }
+                    let match = urlPatterns.collection.match(path);
+                    if (match) {
+                        // resource creation
+                        return await this.processCreate(prisma, match.type, query, requestBody, zodSchemas);
+                    }
+                    match = urlPatterns.relationship.match(path);
+                    if (match) {
+                        // relationship creation (collection relationship only)
+                        return await this.processRelationshipCRUD(prisma, 'create', match.type, match.id, match.relationship, query, requestBody);
+                    }
+                    return this.makeError('invalidPath');
                 }
-            }
-        });
-    }
-    processSingleRead(prisma, type, resourceId, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const args = { where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId) };
-            // include IDs of relation fields so that they can be serialized
-            this.includeRelationshipIds(type, args, 'include');
-            // handle "include" query parameter
-            let include;
-            if (query === null || query === void 0 ? void 0 : query.include) {
-                const { select, error, allIncludes } = this.buildRelationSelect(type, query.include);
-                if (error) {
-                    return error;
+                // TODO: PUT for full update
+                case 'PUT':
+                case 'PATCH': {
+                    if (!requestBody) {
+                        return this.makeError('invalidPayload');
+                    }
+                    let match = urlPatterns.single.match(path);
+                    if (match) {
+                        // resource update
+                        return await this.processUpdate(prisma, match.type, match.id, query, requestBody, zodSchemas);
+                    }
+                    match = urlPatterns.relationship.match(path);
+                    if (match) {
+                        // relationship update
+                        return await this.processRelationshipCRUD(prisma, 'update', match.type, match.id, match.relationship, query, requestBody);
+                    }
+                    return this.makeError('invalidPath');
                 }
-                if (select) {
-                    args.include = Object.assign(Object.assign({}, args.include), select);
+                case 'DELETE': {
+                    let match = urlPatterns.single.match(path);
+                    if (match) {
+                        // resource deletion
+                        return await this.processDelete(prisma, match.type, match.id);
+                    }
+                    match = urlPatterns.relationship.match(path);
+                    if (match) {
+                        // relationship deletion (collection relationship only)
+                        return await this.processRelationshipCRUD(prisma, 'delete', match.type, match.id, match.relationship, query, requestBody);
+                    }
+                    return this.makeError('invalidPath');
                 }
-                include = allIncludes;
+                default:
+                    return this.makeError('invalidPath');
             }
-            const entity = yield prisma[type].findUnique(args);
-            if (entity) {
-                return {
-                    status: 200,
-                    body: yield this.serializeItems(type, entity, { include }),
-                };
+        }
+        catch (err) {
+            if (err instanceof InvalidValueError) {
+                return this.makeError('invalidValue', err.message);
             }
             else {
-                return this.makeError('notFound');
+                return this.handlePrismaError(err);
             }
-        });
+        }
     }
-    processFetchRelated(prisma, type, resourceId, relationship, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const relationInfo = typeInfo.relationships[relationship];
-            if (!relationInfo) {
-                return this.makeUnsupportedRelationshipError(type, relationship, 404);
+    async processSingleRead(prisma, type, resourceId, query) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const args = { where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId) };
+        // include IDs of relation fields so that they can be serialized
+        this.includeRelationshipIds(type, args, 'include');
+        // handle "include" query parameter
+        let include;
+        if (query?.include) {
+            const { select, error, allIncludes } = this.buildRelationSelect(type, query.include);
+            if (error) {
+                return error;
             }
-            let select;
-            // handle "include" query parameter
-            let include;
-            if (query === null || query === void 0 ? void 0 : query.include) {
-                const { select: relationSelect, error, allIncludes } = this.buildRelationSelect(type, query.include);
-                if (error) {
-                    return error;
-                }
-                // trim the leading `$relationship.` from the include paths
-                include = allIncludes
-                    .filter((i) => i.startsWith(`${relationship}.`))
-                    .map((i) => i.substring(`${relationship}.`.length));
-                select = relationSelect;
+            if (select) {
+                args.include = { ...args.include, ...select };
             }
-            select = select !== null && select !== void 0 ? select : { [relationship]: true };
-            const args = {
-                where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
-                select,
+            include = allIncludes;
+        }
+        const entity = await prisma[type].findUnique(args);
+        if (entity) {
+            return {
+                status: 200,
+                body: await this.serializeItems(type, entity, { include }),
             };
-            if (relationInfo.isCollection) {
-                // if related data is a collection, it can be filtered, sorted, and paginated
-                const error = this.injectRelationQuery(relationInfo.type, select, relationship, query);
-                if (error) {
-                    return error;
-                }
-            }
-            const entity = yield prisma[type].findUnique(args);
-            let paginator;
-            if (((_a = entity === null || entity === void 0 ? void 0 : entity._count) === null || _a === void 0 ? void 0 : _a[relationship]) !== undefined) {
-                // build up paginator
-                const total = (_b = entity === null || entity === void 0 ? void 0 : entity._count) === null || _b === void 0 ? void 0 : _b[relationship];
-                const url = this.makeNormalizedUrl(`/${type}/${resourceId}/${relationship}`, query);
-                const { offset, limit } = this.getPagination(query);
-                paginator = this.makePaginator(url, offset, limit, total);
-            }
-            if (entity === null || entity === void 0 ? void 0 : entity[relationship]) {
-                return {
-                    status: 200,
-                    body: yield this.serializeItems(relationInfo.type, entity[relationship], {
-                        linkers: {
-                            document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/${relationship}`)),
-                            paginator,
-                        },
-                        include,
-                    }),
-                };
-            }
-            else {
-                return this.makeError('notFound');
-            }
-        });
+        }
+        else {
+            return this.makeError('notFound');
+        }
     }
-    processReadRelationship(prisma, type, resourceId, relationship, query, modelMeta) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const relationInfo = typeInfo.relationships[relationship];
-            if (!relationInfo) {
-                return this.makeUnsupportedRelationshipError(type, relationship, 404);
-            }
-            const args = {
-                where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
-                select: this.makeIdSelect(type, modelMeta),
-            };
-            // include IDs of relation fields so that they can be serialized
-            // this.includeRelationshipIds(type, args, 'select');
-            args.select = Object.assign(Object.assign({}, args.select), { [relationship]: { select: this.makeIdSelect(relationInfo.type, modelMeta) } });
-            let paginator;
-            if (relationInfo.isCollection) {
-                // if related data is a collection, it can be filtered, sorted, and paginated
-                const error = this.injectRelationQuery(relationInfo.type, args.select, relationship, query);
-                if (error) {
-                    return error;
-                }
+    async processFetchRelated(prisma, type, resourceId, relationship, query) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const relationInfo = typeInfo.relationships[relationship];
+        if (!relationInfo) {
+            return this.makeUnsupportedRelationshipError(type, relationship, 404);
+        }
+        let select;
+        // handle "include" query parameter
+        let include;
+        if (query?.include) {
+            const { select: relationSelect, error, allIncludes } = this.buildRelationSelect(type, query.include);
+            if (error) {
+                return error;
             }
-            const entity = yield prisma[type].findUnique(args);
-            if (((_a = entity === null || entity === void 0 ? void 0 : entity._count) === null || _a === void 0 ? void 0 : _a[relationship]) !== undefined) {
-                // build up paginator
-                const total = (_b = entity === null || entity === void 0 ? void 0 : entity._count) === null || _b === void 0 ? void 0 : _b[relationship];
-                const url = this.makeNormalizedUrl(`/${type}/${resourceId}/relationships/${relationship}`, query);
-                const { offset, limit } = this.getPagination(query);
-                paginator = this.makePaginator(url, offset, limit, total);
+            // trim the leading `$relationship.` from the include paths
+            include = allIncludes
+                .filter((i) => i.startsWith(`${relationship}.`))
+                .map((i) => i.substring(`${relationship}.`.length));
+            select = relationSelect;
+        }
+        select = select ?? { [relationship]: true };
+        const args = {
+            where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
+            select,
+        };
+        if (relationInfo.isCollection) {
+            // if related data is a collection, it can be filtered, sorted, and paginated
+            const error = this.injectRelationQuery(relationInfo.type, select, relationship, query);
+            if (error) {
+                return error;
             }
-            if (entity === null || entity === void 0 ? void 0 : entity[relationship]) {
-                const serialized = yield this.serializeItems(relationInfo.type, entity[relationship], {
+        }
+        const entity = await prisma[type].findUnique(args);
+        let paginator;
+        if (entity?._count?.[relationship] !== undefined) {
+            // build up paginator
+            const total = entity?._count?.[relationship];
+            const url = this.makeNormalizedUrl(`/${type}/${resourceId}/${relationship}`, query);
+            const { offset, limit } = this.getPagination(query);
+            paginator = this.makePaginator(url, offset, limit, total);
+        }
+        if (entity?.[relationship]) {
+            return {
+                status: 200,
+                body: await this.serializeItems(relationInfo.type, entity[relationship], {
                     linkers: {
-                        document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/relationships/${relationship}`)),
+                        document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/${relationship}`)),
                         paginator,
                     },
-                    onlyIdentifier: true,
-                });
-                return {
-                    status: 200,
-                    body: serialized,
-                };
-            }
-            else {
-                return this.makeError('notFound');
-            }
-        });
+                    include,
+                }),
+            };
+        }
+        else {
+            return this.makeError('notFound');
+        }
     }
-    processCollectionRead(prisma, type, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const args = {};
-            // add filter
-            const { filter, error: filterError } = this.buildFilter(type, query);
-            if (filterError) {
-                return filterError;
-            }
-            if (filter) {
-                args.where = filter;
-            }
-            const { sort, error: sortError } = this.buildSort(type, query);
-            if (sortError) {
-                return sortError;
-            }
-            if (sort) {
-                args.orderBy = sort;
-            }
-            // include IDs of relation fields so that they can be serialized
-            this.includeRelationshipIds(type, args, 'include');
-            // handle "include" query parameter
-            let include;
-            if (query === null || query === void 0 ? void 0 : query.include) {
-                const { select, error, allIncludes } = this.buildRelationSelect(type, query.include);
-                if (error) {
-                    return error;
-                }
-                if (select) {
-                    args.include = Object.assign(Object.assign({}, args.include), select);
-                }
-                include = allIncludes;
+    async processReadRelationship(prisma, type, resourceId, relationship, query, modelMeta) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const relationInfo = typeInfo.relationships[relationship];
+        if (!relationInfo) {
+            return this.makeUnsupportedRelationshipError(type, relationship, 404);
+        }
+        const args = {
+            where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
+            select: this.makeIdSelect(type, modelMeta),
+        };
+        // include IDs of relation fields so that they can be serialized
+        // this.includeRelationshipIds(type, args, 'select');
+        args.select = { ...args.select, [relationship]: { select: this.makeIdSelect(relationInfo.type, modelMeta) } };
+        let paginator;
+        if (relationInfo.isCollection) {
+            // if related data is a collection, it can be filtered, sorted, and paginated
+            const error = this.injectRelationQuery(relationInfo.type, args.select, relationship, query);
+            if (error) {
+                return error;
             }
+        }
+        const entity = await prisma[type].findUnique(args);
+        if (entity?._count?.[relationship] !== undefined) {
+            // build up paginator
+            const total = entity?._count?.[relationship];
+            const url = this.makeNormalizedUrl(`/${type}/${resourceId}/relationships/${relationship}`, query);
             const { offset, limit } = this.getPagination(query);
-            if (offset > 0) {
-                args.skip = offset;
-            }
-            if (limit === Infinity) {
-                const entities = yield prisma[type].findMany(args);
-                const body = yield this.serializeItems(type, entities, { include });
-                const total = entities.length;
-                body.meta = this.addTotalCountToMeta(body.meta, total);
-                return {
-                    status: 200,
-                    body: body,
-                };
+            paginator = this.makePaginator(url, offset, limit, total);
+        }
+        if (entity?.[relationship]) {
+            const serialized = await this.serializeItems(relationInfo.type, entity[relationship], {
+                linkers: {
+                    document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/relationships/${relationship}`)),
+                    paginator,
+                },
+                onlyIdentifier: true,
+            });
+            return {
+                status: 200,
+                body: serialized,
+            };
+        }
+        else {
+            return this.makeError('notFound');
+        }
+    }
+    async processCollectionRead(prisma, type, query) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const args = {};
+        // add filter
+        const { filter, error: filterError } = this.buildFilter(type, query);
+        if (filterError) {
+            return filterError;
+        }
+        if (filter) {
+            args.where = filter;
+        }
+        const { sort, error: sortError } = this.buildSort(type, query);
+        if (sortError) {
+            return sortError;
+        }
+        if (sort) {
+            args.orderBy = sort;
+        }
+        // include IDs of relation fields so that they can be serialized
+        this.includeRelationshipIds(type, args, 'include');
+        // handle "include" query parameter
+        let include;
+        if (query?.include) {
+            const { select, error, allIncludes } = this.buildRelationSelect(type, query.include);
+            if (error) {
+                return error;
             }
-            else {
-                args.take = limit;
-                const [entities, count] = yield Promise.all([
-                    prisma[type].findMany(args),
-                    prisma[type].count({ where: args.where }),
-                ]);
-                const total = count;
-                const url = this.makeNormalizedUrl(`/${type}`, query);
-                const options = {
-                    include,
-                    linkers: {
-                        paginator: this.makePaginator(url, offset, limit, total),
-                    },
-                };
-                const body = yield this.serializeItems(type, entities, options);
-                body.meta = this.addTotalCountToMeta(body.meta, total);
-                return {
-                    status: 200,
-                    body: body,
-                };
+            if (select) {
+                args.include = { ...args.include, ...select };
             }
-        });
+            include = allIncludes;
+        }
+        const { offset, limit } = this.getPagination(query);
+        if (offset > 0) {
+            args.skip = offset;
+        }
+        if (limit === Infinity) {
+            const entities = await prisma[type].findMany(args);
+            const body = await this.serializeItems(type, entities, { include });
+            const total = entities.length;
+            body.meta = this.addTotalCountToMeta(body.meta, total);
+            return {
+                status: 200,
+                body: body,
+            };
+        }
+        else {
+            args.take = limit;
+            const [entities, count] = await Promise.all([
+                prisma[type].findMany(args),
+                prisma[type].count({ where: args.where }),
+            ]);
+            const total = count;
+            const url = this.makeNormalizedUrl(`/${type}`, query);
+            const options = {
+                include,
+                linkers: {
+                    paginator: this.makePaginator(url, offset, limit, total),
+                },
+            };
+            const body = await this.serializeItems(type, entities, options);
+            body.meta = this.addTotalCountToMeta(body.meta, total);
+            return {
+                status: 200,
+                body: body,
+            };
+        }
     }
     addTotalCountToMeta(meta, total) {
         return meta ? Object.assign(meta, { total }) : Object.assign({}, { total });
@@ -518,9 +500,8 @@ class RequestHandler extends base_1.APIHandlerBase {
         }));
     }
     processRequestBody(type, requestBody, zodSchemas, mode) {
-        var _a, _b;
         let body = requestBody;
-        if ((_a = body.meta) === null || _a === void 0 ? void 0 : _a.serialization) {
+        if (body.meta?.serialization) {
             // superjson deserialize body if a serialization meta is provided
             body = superjson_1.default.deserialize({ json: body, meta: body.meta.serialization });
         }
@@ -529,7 +510,7 @@ class RequestHandler extends base_1.APIHandlerBase {
         if (attributes) {
             const schemaName = `${(0, upper_case_first_1.upperCaseFirst)(type)}${(0, upper_case_first_1.upperCaseFirst)(mode)}Schema`;
             // zod-parse attributes if a schema is provided
-            const payloadSchema = (_b = zodSchemas === null || zodSchemas === void 0 ? void 0 : zodSchemas.models) === null || _b === void 0 ? void 0 : _b[schemaName];
+            const payloadSchema = zodSchemas?.models?.[schemaName];
             if (payloadSchema) {
                 const parsed = payloadSchema.safeParse(attributes);
                 if (!parsed.success) {
@@ -541,191 +522,189 @@ class RequestHandler extends base_1.APIHandlerBase {
         }
         return { attributes, relationships: parsed.data.relationships };
     }
-    processCreate(prisma, type, _query, requestBody, zodSchemas) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const { error, attributes, relationships } = this.processRequestBody(type, requestBody, zodSchemas, 'create');
-            if (error) {
-                return error;
-            }
-            const createPayload = { data: Object.assign({}, attributes) };
-            // turn relationship payload into Prisma connect objects
-            if (relationships) {
-                for (const [key, data] of Object.entries(relationships)) {
-                    if (!(data === null || data === void 0 ? void 0 : data.data)) {
-                        return this.makeError('invalidRelationData');
-                    }
-                    const relationInfo = typeInfo.relationships[key];
-                    if (!relationInfo) {
-                        return this.makeUnsupportedRelationshipError(type, key, 400);
-                    }
-                    if (relationInfo.isCollection) {
-                        createPayload.data[key] = {
-                            connect: (0, runtime_1.enumerate)(data.data).map((item) => ({
-                                [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
-                            })),
-                        };
-                    }
-                    else {
-                        if (typeof data.data !== 'object') {
-                            return this.makeError('invalidRelationData');
-                        }
-                        createPayload.data[key] = {
-                            connect: { [relationInfo.idField]: this.coerce(relationInfo.idFieldType, data.data.id) },
-                        };
-                    }
-                    // make sure ID fields are included for result serialization
-                    createPayload.include = Object.assign(Object.assign({}, createPayload.include), { [key]: { select: { [relationInfo.idField]: true } } });
+    async processCreate(prisma, type, _query, requestBody, zodSchemas) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const { error, attributes, relationships } = this.processRequestBody(type, requestBody, zodSchemas, 'create');
+        if (error) {
+            return error;
+        }
+        const createPayload = { data: { ...attributes } };
+        // turn relationship payload into Prisma connect objects
+        if (relationships) {
+            for (const [key, data] of Object.entries(relationships)) {
+                if (!data?.data) {
+                    return this.makeError('invalidRelationData');
                 }
-            }
-            const entity = yield prisma[type].create(createPayload);
-            return {
-                status: 201,
-                body: yield this.serializeItems(type, entity),
-            };
-        });
-    }
-    processRelationshipCRUD(prisma, mode, type, resourceId, relationship, query, requestBody) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const relationInfo = typeInfo.relationships[relationship];
-            if (!relationInfo) {
-                return this.makeUnsupportedRelationshipError(type, relationship, 404);
-            }
-            if (!relationInfo.isCollection && mode !== 'update') {
-                // to-one relation can only be updated
-                return this.makeError('invalidVerb');
-            }
-            const updateArgs = {
-                where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
-                select: { [typeInfo.idField]: true, [relationship]: { select: { [relationInfo.idField]: true } } },
-            };
-            if (!relationInfo.isCollection) {
-                // zod-parse payload
-                const parsed = this.updateSingleRelationSchema.safeParse(requestBody);
-                if (!parsed.success) {
-                    return this.makeError('invalidPayload', (0, zod_validation_error_1.fromZodError)(parsed.error).message, undefined, runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION, parsed.error);
+                const relationInfo = typeInfo.relationships[key];
+                if (!relationInfo) {
+                    return this.makeUnsupportedRelationshipError(type, key, 400);
                 }
-                if (parsed.data.data === null) {
-                    if (!relationInfo.isOptional) {
-                        // cannot disconnect a required relation
-                        return this.makeError('invalidPayload');
-                    }
-                    // set null -> disconnect
-                    updateArgs.data = {
-                        [relationship]: {
-                            disconnect: true,
-                        },
+                if (relationInfo.isCollection) {
+                    createPayload.data[key] = {
+                        connect: (0, runtime_1.enumerate)(data.data).map((item) => ({
+                            [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
+                        })),
                     };
                 }
                 else {
-                    updateArgs.data = {
-                        [relationship]: {
-                            connect: {
-                                [relationInfo.idField]: this.coerce(relationInfo.idFieldType, parsed.data.data.id),
-                            },
-                        },
+                    if (typeof data.data !== 'object') {
+                        return this.makeError('invalidRelationData');
+                    }
+                    createPayload.data[key] = {
+                        connect: { [relationInfo.idField]: this.coerce(relationInfo.idFieldType, data.data.id) },
                     };
                 }
+                // make sure ID fields are included for result serialization
+                createPayload.include = {
+                    ...createPayload.include,
+                    [key]: { select: { [relationInfo.idField]: true } },
+                };
             }
-            else {
-                // zod-parse payload
-                const parsed = this.updateCollectionRelationSchema.safeParse(requestBody);
-                if (!parsed.success) {
-                    return this.makeError('invalidPayload', (0, zod_validation_error_1.fromZodError)(parsed.error).message, undefined, runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION, parsed.error);
+        }
+        const entity = await prisma[type].create(createPayload);
+        return {
+            status: 201,
+            body: await this.serializeItems(type, entity),
+        };
+    }
+    async processRelationshipCRUD(prisma, mode, type, resourceId, relationship, query, requestBody) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const relationInfo = typeInfo.relationships[relationship];
+        if (!relationInfo) {
+            return this.makeUnsupportedRelationshipError(type, relationship, 404);
+        }
+        if (!relationInfo.isCollection && mode !== 'update') {
+            // to-one relation can only be updated
+            return this.makeError('invalidVerb');
+        }
+        const updateArgs = {
+            where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
+            select: { [typeInfo.idField]: true, [relationship]: { select: { [relationInfo.idField]: true } } },
+        };
+        if (!relationInfo.isCollection) {
+            // zod-parse payload
+            const parsed = this.updateSingleRelationSchema.safeParse(requestBody);
+            if (!parsed.success) {
+                return this.makeError('invalidPayload', (0, zod_validation_error_1.fromZodError)(parsed.error).message, undefined, runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION, parsed.error);
+            }
+            if (parsed.data.data === null) {
+                if (!relationInfo.isOptional) {
+                    // cannot disconnect a required relation
+                    return this.makeError('invalidPayload');
                 }
-                // create -> connect, delete -> disconnect, update -> set
-                const relationVerb = mode === 'create' ? 'connect' : mode === 'delete' ? 'disconnect' : 'set';
+                // set null -> disconnect
                 updateArgs.data = {
                     [relationship]: {
-                        [relationVerb]: (0, runtime_1.enumerate)(parsed.data.data).map((item) => ({
-                            [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
-                        })),
+                        disconnect: true,
                     },
                 };
             }
-            const entity = yield prisma[type].update(updateArgs);
-            const serialized = yield this.serializeItems(relationInfo.type, entity[relationship], {
-                linkers: {
-                    document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/relationships/${relationship}`)),
+            else {
+                updateArgs.data = {
+                    [relationship]: {
+                        connect: {
+                            [relationInfo.idField]: this.coerce(relationInfo.idFieldType, parsed.data.data.id),
+                        },
+                    },
+                };
+            }
+        }
+        else {
+            // zod-parse payload
+            const parsed = this.updateCollectionRelationSchema.safeParse(requestBody);
+            if (!parsed.success) {
+                return this.makeError('invalidPayload', (0, zod_validation_error_1.fromZodError)(parsed.error).message, undefined, runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION, parsed.error);
+            }
+            // create -> connect, delete -> disconnect, update -> set
+            const relationVerb = mode === 'create' ? 'connect' : mode === 'delete' ? 'disconnect' : 'set';
+            updateArgs.data = {
+                [relationship]: {
+                    [relationVerb]: (0, runtime_1.enumerate)(parsed.data.data).map((item) => ({
+                        [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
+                    })),
                 },
-                onlyIdentifier: true,
-            });
-            return {
-                status: 200,
-                body: serialized,
             };
+        }
+        const entity = await prisma[type].update(updateArgs);
+        const serialized = await this.serializeItems(relationInfo.type, entity[relationship], {
+            linkers: {
+                document: new ts_japi_1.Linker(() => this.makeLinkUrl(`/${type}/${resourceId}/relationships/${relationship}`)),
+            },
+            onlyIdentifier: true,
         });
+        return {
+            status: 200,
+            body: serialized,
+        };
     }
-    processUpdate(prisma, type, resourceId, _query, requestBody, zodSchemas) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            const { error, attributes, relationships } = this.processRequestBody(type, requestBody, zodSchemas, 'update');
-            if (error) {
-                return error;
-            }
-            const updatePayload = {
-                where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
-                data: Object.assign({}, attributes),
-            };
-            // turn relationships into prisma payload
-            if (relationships) {
-                for (const [key, data] of Object.entries(relationships)) {
-                    if (!(data === null || data === void 0 ? void 0 : data.data)) {
+    async processUpdate(prisma, type, resourceId, _query, requestBody, zodSchemas) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        const { error, attributes, relationships } = this.processRequestBody(type, requestBody, zodSchemas, 'update');
+        if (error) {
+            return error;
+        }
+        const updatePayload = {
+            where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
+            data: { ...attributes },
+        };
+        // turn relationships into prisma payload
+        if (relationships) {
+            for (const [key, data] of Object.entries(relationships)) {
+                if (!data?.data) {
+                    return this.makeError('invalidRelationData');
+                }
+                const relationInfo = typeInfo.relationships[key];
+                if (!relationInfo) {
+                    return this.makeUnsupportedRelationshipError(type, key, 400);
+                }
+                if (relationInfo.isCollection) {
+                    updatePayload.data[key] = {
+                        set: (0, runtime_1.enumerate)(data.data).map((item) => ({
+                            [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
+                        })),
+                    };
+                }
+                else {
+                    if (typeof data.data !== 'object') {
                         return this.makeError('invalidRelationData');
                     }
-                    const relationInfo = typeInfo.relationships[key];
-                    if (!relationInfo) {
-                        return this.makeUnsupportedRelationshipError(type, key, 400);
-                    }
-                    if (relationInfo.isCollection) {
-                        updatePayload.data[key] = {
-                            set: (0, runtime_1.enumerate)(data.data).map((item) => ({
-                                [relationInfo.idField]: this.coerce(relationInfo.idFieldType, item.id),
-                            })),
-                        };
-                    }
-                    else {
-                        if (typeof data.data !== 'object') {
-                            return this.makeError('invalidRelationData');
-                        }
-                        updatePayload.data[key] = {
-                            set: { [relationInfo.idField]: this.coerce(relationInfo.idFieldType, data.data.id) },
-                        };
-                    }
-                    updatePayload.include = Object.assign(Object.assign({}, updatePayload.include), { [key]: { select: { [relationInfo.idField]: true } } });
+                    updatePayload.data[key] = {
+                        set: { [relationInfo.idField]: this.coerce(relationInfo.idFieldType, data.data.id) },
+                    };
                 }
+                updatePayload.include = {
+                    ...updatePayload.include,
+                    [key]: { select: { [relationInfo.idField]: true } },
+                };
             }
-            const entity = yield prisma[type].update(updatePayload);
-            return {
-                status: 200,
-                body: yield this.serializeItems(type, entity),
-            };
-        });
+        }
+        const entity = await prisma[type].update(updatePayload);
+        return {
+            status: 200,
+            body: await this.serializeItems(type, entity),
+        };
     }
-    processDelete(prisma, type, resourceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const typeInfo = this.typeMap[type];
-            if (!typeInfo) {
-                return this.makeUnsupportedModelError(type);
-            }
-            yield prisma[type].delete({
-                where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
-            });
-            return {
-                status: 204,
-                body: undefined,
-            };
+    async processDelete(prisma, type, resourceId) {
+        const typeInfo = this.typeMap[type];
+        if (!typeInfo) {
+            return this.makeUnsupportedModelError(type);
+        }
+        await prisma[type].delete({
+            where: this.makeIdFilter(typeInfo.idField, typeInfo.idFieldType, resourceId),
         });
+        return {
+            status: 204,
+            body: undefined,
+        };
     }
     //#region utilities
     buildTypeMap(logger, modelMeta) {
@@ -821,9 +800,9 @@ class RequestHandler extends base_1.APIHandlerBase {
                 }
                 const fieldIds = (0, runtime_1.getIdFields)(modelMeta, fieldMeta.type);
                 if (fieldIds.length === 1) {
-                    const relator = new ts_japi_1.Relator((data) => __awaiter(this, void 0, void 0, function* () {
+                    const relator = new ts_japi_1.Relator(async (data) => {
                         return data[field];
-                    }), fieldSerializer, {
+                    }, fieldSerializer, {
                         relatedName: field,
                         linkers: {
                             related: new ts_japi_1.Linker((primary) => this.makeLinkUrl(`/${(0, lower_case_first_1.lowerCaseFirst)(model)}/${this.getId(model, primary, modelMeta)}/${field}`)),
@@ -848,25 +827,23 @@ class RequestHandler extends base_1.APIHandlerBase {
             return undefined;
         }
     }
-    serializeItems(model, items, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            model = (0, lower_case_first_1.lowerCaseFirst)(model);
-            const serializer = this.serializers.get(model);
-            if (!serializer) {
-                throw new Error(`serializer not found for model ${model}`);
-            }
-            // serialize to JSON:API structure
-            const serialized = yield serializer.serialize(items, options);
-            // convert the serialization result to plain object otherwise SuperJSON won't work
-            const plainResult = this.toPlainObject(serialized);
-            // superjson serialize the result
-            const { json, meta } = superjson_1.default.serialize(plainResult);
-            const result = json;
-            if (meta) {
-                result.meta = Object.assign(Object.assign({}, result.meta), { serialization: meta });
-            }
-            return result;
-        });
+    async serializeItems(model, items, options) {
+        model = (0, lower_case_first_1.lowerCaseFirst)(model);
+        const serializer = this.serializers.get(model);
+        if (!serializer) {
+            throw new Error(`serializer not found for model ${model}`);
+        }
+        // serialize to JSON:API structure
+        const serialized = await serializer.serialize(items, options);
+        // convert the serialization result to plain object otherwise SuperJSON won't work
+        const plainResult = this.toPlainObject(serialized);
+        // superjson serialize the result
+        const { json, meta } = superjson_1.default.serialize(plainResult);
+        const result = json;
+        if (meta) {
+            result.meta = { ...result.meta, serialization: meta };
+        }
+        return result;
     }
     toPlainObject(data) {
         if (data === undefined || data === null) {
@@ -924,7 +901,7 @@ class RequestHandler extends base_1.APIHandlerBase {
             return;
         }
         for (const [relation, relationInfo] of Object.entries(typeInfo.relationships)) {
-            args[mode] = Object.assign(Object.assign({}, args[mode]), { [relation]: { select: { [relationInfo.idField]: true } } });
+            args[mode] = { ...args[mode], [relation]: { select: { [relationInfo.idField]: true } } };
         }
     }
     coerce(type, value) {
@@ -959,7 +936,7 @@ class RequestHandler extends base_1.APIHandlerBase {
     }
     makeNormalizedUrl(path, query) {
         const url = new URL(this.makeLinkUrl(path));
-        for (const [key, value] of Object.entries(query !== null && query !== void 0 ? query : {})) {
+        for (const [key, value] of Object.entries(query ?? {})) {
             if (key.startsWith('filter[') ||
                 key.startsWith('sort[') ||
                 key.startsWith('include[') ||
@@ -972,9 +949,8 @@ class RequestHandler extends base_1.APIHandlerBase {
         return url.toString();
     }
     getPagination(query) {
-        var _a, _b;
         if (!query) {
-            return { offset: 0, limit: (_a = this.options.pageSize) !== null && _a !== void 0 ? _a : DEFAULT_PAGE_SIZE };
+            return { offset: 0, limit: this.options.pageSize ?? DEFAULT_PAGE_SIZE };
         }
         let offset = 0;
         if (query['page[offset]']) {
@@ -985,7 +961,7 @@ class RequestHandler extends base_1.APIHandlerBase {
                 offset = 0;
             }
         }
-        let pageSizeOption = (_b = this.options.pageSize) !== null && _b !== void 0 ? _b : DEFAULT_PAGE_SIZE;
+        let pageSizeOption = this.options.pageSize ?? DEFAULT_PAGE_SIZE;
         if (pageSizeOption <= 0) {
             pageSizeOption = DEFAULT_PAGE_SIZE;
         }
@@ -1091,7 +1067,7 @@ class RequestHandler extends base_1.APIHandlerBase {
         }
     }
     buildSort(type, query) {
-        if (!(query === null || query === void 0 ? void 0 : query['sort'])) {
+        if (!query?.['sort']) {
             return { sort: undefined, error: undefined };
         }
         const typeInfo = this.typeMap[(0, lower_case_first_1.lowerCaseFirst)(type)];
@@ -1153,7 +1129,6 @@ class RequestHandler extends base_1.APIHandlerBase {
         return { sort: result, error: undefined };
     }
     buildRelationSelect(type, include) {
-        var _a;
         const typeInfo = this.typeMap[(0, lower_case_first_1.lowerCaseFirst)(type)];
         if (!typeInfo) {
             return { select: undefined, error: this.makeUnsupportedModelError(type) };
@@ -1178,7 +1153,7 @@ class RequestHandler extends base_1.APIHandlerBase {
                         return { select: undefined, error: this.makeUnsupportedModelError(relationInfo.type) };
                     }
                     if (i !== parts.length - 1) {
-                        currPayload[relation] = { include: Object.assign({}, (_a = currPayload[relation]) === null || _a === void 0 ? void 0 : _a.include) };
+                        currPayload[relation] = { include: { ...currPayload[relation]?.include } };
                         currPayload = currPayload[relation].include;
                     }
                     else {
@@ -1234,38 +1209,37 @@ class RequestHandler extends base_1.APIHandlerBase {
             return filterError;
         }
         if (filter) {
-            injectTarget[injectKey] = Object.assign(Object.assign({}, injectTarget[injectKey]), { where: filter });
+            injectTarget[injectKey] = { ...injectTarget[injectKey], where: filter };
         }
         const { sort, error: sortError } = this.buildSort(type, query);
         if (sortError) {
             return sortError;
         }
         if (sort) {
-            injectTarget[injectKey] = Object.assign(Object.assign({}, injectTarget[injectKey]), { orderBy: sort });
+            injectTarget[injectKey] = { ...injectTarget[injectKey], orderBy: sort };
         }
         const pagination = this.getPagination(query);
         const offset = pagination.offset;
         if (offset > 0) {
             // inject skip
-            injectTarget[injectKey] = Object.assign(Object.assign({}, injectTarget[injectKey]), { skip: offset });
+            injectTarget[injectKey] = { ...injectTarget[injectKey], skip: offset };
         }
         const limit = pagination.limit;
         if (limit !== Infinity) {
             // inject take
-            injectTarget[injectKey] = Object.assign(Object.assign({}, injectTarget[injectKey]), { take: limit });
+            injectTarget[injectKey] = { ...injectTarget[injectKey], take: limit };
             // include a count query  for the relationship
             injectTarget._count = { select: { [injectKey]: true } };
         }
     }
     handlePrismaError(err) {
-        var _a, _b, _c, _d;
         if ((0, runtime_1.isPrismaClientKnownRequestError)(err)) {
             if (err.code === runtime_1.PrismaErrorCode.CONSTRAINED_FAILED) {
-                if (((_a = err.meta) === null || _a === void 0 ? void 0 : _a.reason) === runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION) {
-                    return this.makeError('validationError', undefined, 422, (_b = err.meta) === null || _b === void 0 ? void 0 : _b.reason, (_c = err.meta) === null || _c === void 0 ? void 0 : _c.zodErrors);
+                if (err.meta?.reason === runtime_1.CrudFailureReason.DATA_VALIDATION_VIOLATION) {
+                    return this.makeError('validationError', undefined, 422, err.meta?.reason, err.meta?.zodErrors);
                 }
                 else {
-                    return this.makeError('forbidden', undefined, 403, (_d = err.meta) === null || _d === void 0 ? void 0 : _d.reason);
+                    return this.makeError('forbidden', undefined, 403, err.meta?.reason);
                 }
             }
             else if (err.code === 'P2025' || err.code === 'P2018') {
@@ -1295,7 +1269,7 @@ class RequestHandler extends base_1.APIHandlerBase {
     }
     makeError(code, detail, status, reason, zodErrors) {
         const error = {
-            status: status !== null && status !== void 0 ? status : this.errors[code].status,
+            status: status ?? this.errors[code].status,
             code: (0, change_case_1.paramCase)(code),
             title: this.errors[code].title,
         };
@@ -1309,7 +1283,7 @@ class RequestHandler extends base_1.APIHandlerBase {
             error.zodErrors = zodErrors;
         }
         return {
-            status: status !== null && status !== void 0 ? status : this.errors[code].status,
+            status: status ?? this.errors[code].status,
             body: {
                 errors: [error],
             },
@@ -1326,6 +1300,4 @@ function makeHandler(options) {
     const handler = new RequestHandler(options);
     return handler.handleRequest.bind(handler);
 }
-exports.default = makeHandler;
-exports.RestApiHandler = makeHandler;
 //# sourceMappingURL=index.js.map