@zenstackhq/runtime 2.0.0-beta.1 → 2.0.0-beta.10

package/enhancements/policy/handler.js

@@ -32,10 +32,10 @@ const zod_validation_error_1 = require("zod-validation-error");
 const constants_1 = require("../../constants");
 const cross_1 = require("../../cross");
 const logger_1 = require("../logger");
+const promise_1 = require("../promise");
 const query_utils_1 = require("../query-utils");
 const utils_1 = require("../utils");
 const policy_utils_1 = require("./policy-utils");
-const promise_1 = require("./promise");
 /**
  * Prisma proxy handler for injecting access policy check.
  */
@@ -62,7 +62,7 @@ class PolicyProxyHandler {
         if (!args.where) {
             throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
         }
-        return this.findWithFluentCallStubs(args, 'findUnique', false, () => null);
+        return this.findWithFluent('findUnique', args, () => null);
     }
     findUniqueOrThrow(args) {
         if (!args) {
@@ -71,110 +71,55 @@ class PolicyProxyHandler {
         if (!args.where) {
             throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
         }
-        return this.findWithFluentCallStubs(args, 'findUniqueOrThrow', true, () => {
+        return this.findWithFluent('findUniqueOrThrow', args, () => {
             throw this.policyUtils.notFound(this.model);
         });
     }
     findFirst(args) {
-        return this.findWithFluentCallStubs(args, 'findFirst', false, () => null);
+        return this.findWithFluent('findFirst', args, () => null);
     }
     findFirstOrThrow(args) {
-        return this.findWithFluentCallStubs(args, 'findFirstOrThrow', true, () => {
+        return this.findWithFluent('findFirstOrThrow', args, () => {
             throw this.policyUtils.notFound(this.model);
         });
     }
     findMany(args) {
         return (0, promise_1.createDeferredPromise)(() => this.doFind(args, 'findMany', () => []));
     }
-    // returns a promise for the given find operation, together with function stubs for fluent API calls
-    findWithFluentCallStubs(args, actionName, resolveRoot, handleRejection) {
-        // create a deferred promise so it's only evaluated when awaited or .then() is called
-        const result = (0, promise_1.createDeferredPromise)(() => this.doFind(args, actionName, handleRejection));
-        this.addFluentFunctions(result, this.model, args === null || args === void 0 ? void 0 : args.where, resolveRoot ? result : undefined);
-        return result;
+    // make a find query promise with fluent API call stubs installed
+    findWithFluent(method, args, handleRejection) {
+        args = this.policyUtils.clone(args);
+        return (0, promise_1.createFluentPromise)(() => this.doFind(args, method, handleRejection), args, this.options.modelMeta, this.model);
     }
     doFind(args, actionName, handleRejection) {
-        const origArgs = args;
-        const _args = this.policyUtils.clone(args);
-        if (!this.policyUtils.injectForRead(this.prisma, this.model, _args)) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const origArgs = args;
+            const _args = this.policyUtils.clone(args);
+            if (!this.policyUtils.injectForRead(this.prisma, this.model, _args)) {
+                if (this.shouldLogQuery) {
+                    this.logger.info(`[policy] \`${actionName}\` ${this.model}: unconditionally denied`);
+                }
+                return handleRejection();
+            }
+            this.policyUtils.injectReadCheckSelect(this.model, _args);
             if (this.shouldLogQuery) {
-                this.logger.info(`[policy] \`${actionName}\` ${this.model}: unconditionally denied`);
+                this.logger.info(`[policy] \`${actionName}\` ${this.model}:\n${(0, utils_1.formatObject)(_args)}`);
             }
-            return handleRejection();
-        }
-        this.policyUtils.injectReadCheckSelect(this.model, _args);
-        if (this.shouldLogQuery) {
-            this.logger.info(`[policy] \`${actionName}\` ${this.model}:\n${(0, utils_1.formatObject)(_args)}`);
-        }
-        return new Promise((resolve, reject) => {
-            this.modelClient[actionName](_args).then((value) => {
-                this.policyUtils.postProcessForRead(value, this.model, origArgs);
-                resolve(value);
-            }, (err) => reject(err));
+            const result = yield this.modelClient[actionName](_args);
+            this.policyUtils.postProcessForRead(result, this.model, origArgs);
+            return result;
         });
     }
-    // returns a fluent API call function
-    fluentCall(filter, fieldInfo, rootPromise) {
-        return (args) => {
-            args = this.policyUtils.clone(args);
-            // combine the parent filter with the current one
-            const backLinkField = this.requireBackLink(fieldInfo);
-            const condition = backLinkField.isArray
-                ? { [backLinkField.name]: { some: filter } }
-                : { [backLinkField.name]: { is: filter } };
-            args.where = this.policyUtils.and(args.where, condition);
-            const promise = (0, promise_1.createDeferredPromise)(() => {
-                // Promise for fetching
-                const fetchFluent = (resolve, reject) => {
-                    const handler = this.makeHandler(fieldInfo.type);
-                    if (fieldInfo.isArray) {
-                        // fluent call stops here
-                        handler.findMany(args).then((value) => resolve(value), (err) => reject(err));
-                    }
-                    else {
-                        handler.findFirst(args).then((value) => resolve(value), (err) => reject(err));
-                    }
-                };
-                return new Promise((resolve, reject) => {
-                    if (rootPromise) {
-                        // if a root promise exists, resolve it before fluent API call,
-                        // so that fluent calls start with `findUniqueOrThrow` and `findFirstOrThrow`
-                        // can throw error properly if the root promise is rejected
-                        rootPromise.then(() => fetchFluent(resolve, reject), (err) => reject(err));
-                    }
-                    else {
-                        fetchFluent(resolve, reject);
-                    }
-                });
-            });
-            if (!fieldInfo.isArray) {
-                // prepare for a chained fluent API call
-                this.addFluentFunctions(promise, fieldInfo.type, args.where, rootPromise);
-            }
-            return promise;
-        };
-    }
-    // add fluent API functions to the given promise
-    addFluentFunctions(promise, model, filter, rootPromise) {
-        const fields = this.policyUtils.getModelFields(model);
-        if (fields) {
-            for (const [field, fieldInfo] of Object.entries(fields)) {
-                if (fieldInfo.isDataModel) {
-                    promise[field] = this.fluentCall(filter, fieldInfo, rootPromise);
-                }
-            }
-        }
-    }
     //#endregion
     //#region Create
     create(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.data) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.data) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => __awaiter(this, void 0, void 0, function* () {
             this.policyUtils.tryReject(this.prisma, this.model, 'create');
             const origArgs = args;
             args = this.policyUtils.clone(args);
@@ -217,7 +162,7 @@ class PolicyProxyHandler {
             else {
                 return result;
             }
-        });
+        }));
     }
     // create with nested write
     doCreate(model, args, db) {
@@ -337,7 +282,8 @@ class PolicyProxyHandler {
                 const key = getEntityKey(model, scalarData);
                 // only check if entity is created, not connected
                 if (!connectedEntities.has(key) && !postCreateChecks.has(key)) {
-                    postCreateChecks.set(key, { model, operation: 'create', uniqueFilter: scalarData });
+                    const idFields = this.policyUtils.getIdFieldValues(model, scalarData);
+                    postCreateChecks.set(key, { model, operation: 'create', uniqueFilter: idFields });
                 }
             });
             // return only the ids of the top-level entity
@@ -399,13 +345,13 @@ class PolicyProxyHandler {
         }
     }
     createMany(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.data) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.data) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => __awaiter(this, void 0, void 0, function* () {
             this.policyUtils.tryReject(this.prisma, this.model, 'create');
             args = this.policyUtils.clone(args);
             // go through create items, statically check input to determine if post-create
@@ -441,7 +387,7 @@ class PolicyProxyHandler {
                     return result;
                 }));
             }
-        });
+        }));
     }
     doCreateMany(model, args, db) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -449,7 +395,7 @@ class PolicyProxyHandler {
             // for post-create checks. Instead, do a "create" for each item and collect the results.
             let createResult = yield Promise.all((0, cross_1.enumerate)(args.data).map((item) => __awaiter(this, void 0, void 0, function* () {
                 if (args.skipDuplicates) {
-                    if (yield this.hasDuplicatedUniqueConstraint(model, item, db)) {
+                    if (yield this.hasDuplicatedUniqueConstraint(model, item, undefined, db)) {
                         if (this.shouldLogQuery) {
                             this.logger.info(`[policy] \`createMany\` skipping duplicate ${(0, utils_1.formatObject)(item)}`);
                         }
@@ -473,17 +419,59 @@ class PolicyProxyHandler {
             };
         });
     }
-    hasDuplicatedUniqueConstraint(model, createData, db) {
+    hasDuplicatedUniqueConstraint(model, createData, upstreamQuery, db) {
         return __awaiter(this, void 0, void 0, function* () {
             // check unique constraint conflicts
             // we can't rely on try/catch/ignore constraint violation error: https://github.com/prisma/prisma/issues/20496
             // TODO: for simple cases we should be able to translate it to an `upsert` with empty `update` payload
+            var _a;
             // for each unique constraint, check if the input item has all fields set, and if so, check if
             // an entity already exists, and ignore accordingly
             const uniqueConstraints = this.policyUtils.getUniqueConstraints(model);
             for (const constraint of Object.values(uniqueConstraints)) {
-                if (constraint.fields.every((f) => createData[f] !== undefined)) {
-                    const uniqueFilter = constraint.fields.reduce((acc, f) => (Object.assign(Object.assign({}, acc), { [f]: createData[f] })), {});
+                // the unique filter used to check existence
+                const uniqueFilter = {};
+                // unique constraint fields not covered yet
+                const remainingConstraintFields = new Set(constraint.fields);
+                // collect constraint fields from the create data
+                for (const [k, v] of Object.entries(createData)) {
+                    if (v === undefined) {
+                        continue;
+                    }
+                    if (remainingConstraintFields.has(k)) {
+                        uniqueFilter[k] = v;
+                        remainingConstraintFields.delete(k);
+                    }
+                }
+                // collect constraint fields from the upstream query
+                if (upstreamQuery) {
+                    for (const [k, v] of Object.entries(upstreamQuery)) {
+                        if (v === undefined) {
+                            continue;
+                        }
+                        if (remainingConstraintFields.has(k)) {
+                            uniqueFilter[k] = v;
+                            remainingConstraintFields.delete(k);
+                            continue;
+                        }
+                        // check if the upstream query contains a relation field which covers
+                        // a foreign key field constraint
+                        const fieldInfo = (0, cross_1.requireField)(this.modelMeta, model, k);
+                        if (!fieldInfo.isDataModel) {
+                            // only care about relation fields
+                            continue;
+                        }
+                        // merge the upstream query into the unique filter
+                        uniqueFilter[k] = v;
+                        // mark the corresponding foreign key fields as covered
+                        const fkMapping = (_a = fieldInfo.foreignKeyMapping) !== null && _a !== void 0 ? _a : {};
+                        for (const fk of Object.values(fkMapping)) {
+                            remainingConstraintFields.delete(fk);
+                        }
+                    }
+                }
+                if (remainingConstraintFields.size === 0) {
+                    // all constraint fields set, check existence
                     const existing = yield this.policyUtils.checkExistence(db, model, uniqueFilter);
                     if (existing) {
                         return true;
@@ -501,16 +489,16 @@ class PolicyProxyHandler {
     // "updateMany" works against a set of entities, entities not passing policy check are silently
     // ignored
     update(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.where) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
-            }
-            if (!args.data) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.where) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
+        }
+        if (!args.data) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => __awaiter(this, void 0, void 0, function* () {
             args = this.policyUtils.clone(args);
             const { result, error } = yield this.queryUtils.transaction(this.prisma, (tx) => __awaiter(this, void 0, void 0, function* () {
                 // proceed with nested writes and collect post-write checks
@@ -526,23 +514,28 @@ class PolicyProxyHandler {
             else {
                 return result;
             }
-        });
+        }));
     }
     doUpdate(args, db) {
         return __awaiter(this, void 0, void 0, function* () {
             // collected post-update checks
             const postWriteChecks = [];
             // registers a post-update check task
-            const _registerPostUpdateCheck = (model, uniqueFilter) => __awaiter(this, void 0, void 0, function* () {
+            const _registerPostUpdateCheck = (model, preUpdateLookupFilter, postUpdateLookupFilter) => __awaiter(this, void 0, void 0, function* () {
                 // both "post-update" rules and Zod schemas require a post-update check
                 if (this.policyUtils.hasAuthGuard(model, 'postUpdate') || this.policyUtils.getZodSchema(model)) {
                     // select pre-update field values
                     let preValue;
                     const preValueSelect = this.policyUtils.getPreValueSelect(model);
                     if (preValueSelect && Object.keys(preValueSelect).length > 0) {
-                        preValue = yield db[model].findFirst({ where: uniqueFilter, select: preValueSelect });
+                        preValue = yield db[model].findFirst({ where: preUpdateLookupFilter, select: preValueSelect });
                     }
-                    postWriteChecks.push({ model, operation: 'postUpdate', uniqueFilter, preValue });
+                    postWriteChecks.push({
+                        model,
+                        operation: 'postUpdate',
+                        uniqueFilter: postUpdateLookupFilter,
+                        preValue,
+                    });
                 }
             });
             // We can't let the native "update" to handle nested "create" because we can't get back what
@@ -594,7 +587,7 @@ class PolicyProxyHandler {
                                 select: this.policyUtils.makeIdSelection(backLinkField.type),
                             };
                             // fetch the upstream entity
-                            if (this.logger.enabled('info')) {
+                            if (this.shouldLogQuery) {
                                 this.logger.info(`[policy] \`findUniqueOrThrow\` ${model}: looking up upstream entity of ${backLinkField.type}, ${(0, utils_1.formatObject)(upstreamQuery)}`);
                             }
                             const upstreamEntity = yield this.prisma[backLinkField.type].findUniqueOrThrow(upstreamQuery);
@@ -615,7 +608,10 @@ class PolicyProxyHandler {
             const _createMany = (model, args, context) => __awaiter(this, void 0, void 0, function* () {
                 for (const item of (0, cross_1.enumerate)(args.data)) {
                     if (args.skipDuplicates) {
-                        if (yield this.hasDuplicatedUniqueConstraint(model, item, db)) {
+                        // get a reversed query to include fields inherited from upstream mutation,
+                        // it'll be merged with the create payload for unique constraint checking
+                        const upstreamQuery = this.policyUtils.buildReversedQuery(context);
+                        if (yield this.hasDuplicatedUniqueConstraint(model, item, upstreamQuery, db)) {
                             if (this.shouldLogQuery) {
                                 this.logger.info(`[policy] \`createMany\` skipping duplicate ${(0, utils_1.formatObject)(item)}`);
                             }
@@ -643,7 +639,7 @@ class PolicyProxyHandler {
                         }
                         yield this.policyUtils.checkPolicyForUnique(model, args, 'update', db, checkArgs);
                         // register post-update check
-                        yield _registerPostUpdateCheck(model, args);
+                        yield _registerPostUpdateCheck(model, args, args);
                     }
                 }
             });
@@ -684,17 +680,17 @@ class PolicyProxyHandler {
                         // check pre-update guard
                         yield this.policyUtils.checkPolicyForUnique(model, uniqueFilter, 'update', db, args);
                         // handles the case where id fields are updated
-                        const ids = this.policyUtils.clone(existing);
+                        const postUpdateIds = this.policyUtils.clone(existing);
                         for (const key of Object.keys(existing)) {
                             const updateValue = args.data ? args.data[key] : args[key];
                             if (typeof updateValue === 'string' ||
                                 typeof updateValue === 'number' ||
                                 typeof updateValue === 'bigint') {
-                                ids[key] = updateValue;
+                                postUpdateIds[key] = updateValue;
                             }
                         }
                         // register post-update check
-                        yield _registerPostUpdateCheck(model, ids);
+                        yield _registerPostUpdateCheck(model, existing, postUpdateIds);
                     }
                 }),
                 updateMany: (model, args, context) => __awaiter(this, void 0, void 0, function* () {
@@ -766,7 +762,7 @@ class PolicyProxyHandler {
                         // check pre-update guard
                         yield this.policyUtils.checkPolicyForUnique(model, uniqueFilter, 'update', db, args);
                         // register post-update check
-                        yield _registerPostUpdateCheck(model, uniqueFilter);
+                        yield _registerPostUpdateCheck(model, uniqueFilter, uniqueFilter);
                         // convert upsert to update
                         const convertedUpdate = {
                             where: args.where,
@@ -877,13 +873,17 @@ class PolicyProxyHandler {
         }
     }
     updateMany(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.data) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.data) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'data field is required in query argument');
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.options, 'query argument is required');
+        }
+        if (!args.data) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.options, 'data field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => {
             this.policyUtils.tryReject(this.prisma, this.model, 'update');
             args = this.policyUtils.clone(args);
             this.policyUtils.injectAuthGuardAsWhere(this.prisma, args, this.model, 'update');
@@ -927,19 +927,19 @@ class PolicyProxyHandler {
         });
     }
     upsert(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.where) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
-            }
-            if (!args.create) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'create field is required in query argument');
-            }
-            if (!args.update) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'update field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.where) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
+        }
+        if (!args.create) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'create field is required in query argument');
+        }
+        if (!args.update) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'update field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => __awaiter(this, void 0, void 0, function* () {
             this.policyUtils.tryReject(this.prisma, this.model, 'create');
             this.policyUtils.tryReject(this.prisma, this.model, 'update');
             args = this.policyUtils.clone(args);
@@ -967,20 +967,20 @@ class PolicyProxyHandler {
             else {
                 return result;
             }
-        });
+        }));
     }
     //#endregion
     //#region Delete
     // "delete" works against a single entity, and is rejected if the entity fails policy check.
     // "deleteMany" works against a set of entities, entities that fail policy check are filtered out.
     delete(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
-            if (!args.where) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        if (!args.where) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'where field is required in query argument');
+        }
+        return (0, promise_1.createDeferredPromise)(() => __awaiter(this, void 0, void 0, function* () {
             this.policyUtils.tryReject(this.prisma, this.model, 'delete');
             const { result, error } = yield this.queryUtils.transaction(this.prisma, (tx) => __awaiter(this, void 0, void 0, function* () {
                 // do a read-back before delete
@@ -1004,10 +1004,10 @@ class PolicyProxyHandler {
             else {
                 return result;
             }
-        });
+        }));
     }
     deleteMany(args) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return (0, promise_1.createDeferredPromise)(() => {
             this.policyUtils.tryReject(this.prisma, this.model, 'delete');
             // inject policy conditions
             args = args !== null && args !== void 0 ? args : {};
@@ -1022,10 +1022,10 @@ class PolicyProxyHandler {
     //#endregion
     //#region Aggregation
     aggregate(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        return (0, promise_1.createDeferredPromise)(() => {
             args = this.policyUtils.clone(args);
             // inject policy conditions
             this.policyUtils.injectAuthGuardAsWhere(this.prisma, args, this.model, 'read');
@@ -1036,10 +1036,10 @@ class PolicyProxyHandler {
         });
     }
     groupBy(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args) {
-                throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
-            }
+        if (!args) {
+            throw (0, utils_1.prismaClientValidationError)(this.prisma, this.prismaModule, 'query argument is required');
+        }
+        return (0, promise_1.createDeferredPromise)(() => {
             args = this.policyUtils.clone(args);
             // inject policy conditions
             this.policyUtils.injectAuthGuardAsWhere(this.prisma, args, this.model, 'read');
@@ -1050,7 +1050,7 @@ class PolicyProxyHandler {
         });
     }
     count(args) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return (0, promise_1.createDeferredPromise)(() => {
             // inject policy conditions
             args = args ? this.policyUtils.clone(args) : {};
             this.policyUtils.injectAuthGuardAsWhere(this.prisma, args, this.model, 'read');
@@ -1063,7 +1063,7 @@ class PolicyProxyHandler {
     //#endregion
     //#region Subscribe (Prisma Pulse)
     subscribe(args) {
-        return __awaiter(this, void 0, void 0, function* () {
+        return (0, promise_1.createDeferredPromise)(() => {
             const readGuard = this.policyUtils.getAuthGuard(this.prisma, this.model, 'read');
             if (this.policyUtils.isTrue(readGuard)) {
                 // no need to inject
@@ -1112,12 +1112,9 @@ class PolicyProxyHandler {
     }
     runPostWriteChecks(postWriteChecks, db) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(postWriteChecks.map(({ model, operation, uniqueFilter, preValue }) => __awaiter(this, void 0, void 0, function* () { return this.policyUtils.checkPolicyForUnique(model, uniqueFilter, operation, db, undefined, preValue); })));
+            yield Promise.all(postWriteChecks.map((_a) => __awaiter(this, [_a], void 0, function* ({ model, operation, uniqueFilter, preValue }) { return this.policyUtils.checkPolicyForUnique(model, uniqueFilter, operation, db, undefined, preValue); })));
         });
     }
-    makeHandler(model) {
-        return new PolicyProxyHandler(this.prisma, model, this.options, this.context);
-    }
     requireBackLink(fieldInfo) {
         (0, tiny_invariant_1.default)(fieldInfo.backLink, `back link not found for field ${fieldInfo.name}`);
         return (0, cross_1.requireField)(this.modelMeta, fieldInfo.type, fieldInfo.backLink);