@danielhritcu/zenstack-orm 3.5.16 → 3.5.17

package/dist/index.js

@@ -5327,6 +5327,27 @@ var FindOperationHandler = class extends BaseOperationHandler {
   static {
     __name(this, "FindOperationHandler");
   }
+  buildBatchQuery(operation, args, validateArgs = true) {
+    const normalizedArgs = this.normalizeArgs(args);
+    const findOne = operation === "findFirst" || operation === "findUnique";
+    let parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, normalizedArgs, operation) : normalizedArgs;
+    if (findOne) {
+      parsedArgs = parsedArgs ?? {};
+      parsedArgs.take = 1;
+    }
+    const defaultWhereArgs = this.applyDefaultWhere(this.model, parsedArgs);
+    const defaultedArgs = this.applySchemaPluginDefaults(this.model, defaultWhereArgs);
+    const searchExpandedArgs = this.applySearchExpansion(this.model, defaultedArgs);
+    const { args: rewrittenArgs, plan } = this.rewriteVirtualRelations(this.model, searchExpandedArgs);
+    return {
+      query: this.buildReadQuery(this.model, rewrittenArgs),
+      args: parsedArgs,
+      plan
+    };
+  }
+  applyBatchVirtualRelationPlan(data, plan) {
+    return plan ? this.applyVirtualRelationPlan(data, plan) : data;
+  }
   buildQuery(operation, args, validateArgs = true) {
     const normalizedArgs = this.normalizeArgs(args);
     const findOne = operation === "findFirst" || operation === "findUnique";
@@ -10066,20 +10087,26 @@ var ClientImpl = class _ClientImpl {
         return {};
       }
       const { jsonArrayFrom, jsonObjectFrom } = await import("kysely/helpers/postgres");
+      const postProcessors = /* @__PURE__ */ new Map();
       const selections = await Promise.all(flat.map(async ([name, value]) => {
-        const query = await value[ZENSTACK_QUERY_SYMBOL](this);
+        const built = await value[ZENSTACK_QUERY_SYMBOL](this);
+        const query = built && typeof built === "object" && "query" in built ? built.query : built;
+        if (built && typeof built === "object" && "postProcess" in built && typeof built.postProcess === "function") {
+          postProcessors.set(name, built.postProcess);
+        }
         const kind = value[ZENSTACK_QUERY_KIND_SYMBOL];
         return kind === "many" ? jsonArrayFrom(query).as(name) : jsonObjectFrom(query).as(name);
       }));
       const row = await this.$qb.selectNoFrom(selections).executeTakeFirstOrThrow();
       const result = {};
       for (const [name, value] of Object.entries(row)) {
+        const processedValue = postProcessors.get(name)?.(value) ?? value;
         const path = name.split("__");
         let current = result;
         for (const key of path.slice(0, -1)) {
           current = current[key] ??= {};
         }
-        current[path[path.length - 1]] = value;
+        current[path[path.length - 1]] = processedValue;
       }
       return result;
     });
@@ -10205,35 +10232,127 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
     findUnique: /* @__PURE__ */ __name((args) => {
       const handler = new FindOperationHandler(client, model, inputValidator);
       return createPromise("findUnique", "findUnique", args, handler, true, false, {
-        [ZENSTACK_QUERY_SYMBOL]: () => handler.buildQuery("findUnique", args),
+        [ZENSTACK_QUERY_SYMBOL]: () => {
+          const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has("findUnique");
+          const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(args, model, schema, plugins) : args;
+          const batchHandler = handler;
+          const { query, args: batchArgs, plan } = batchHandler.buildBatchQuery("findUnique", processedArgs);
+          return {
+            query,
+            postProcess: /* @__PURE__ */ __name((value) => {
+              let result = value;
+              if (result) {
+                result = batchHandler.applyBatchVirtualRelationPlan(result, plan);
+                result = resultProcessor.processResult(result, model, batchArgs);
+              }
+              if (result && shouldApplyExtResult) {
+                result = applyExtResult(result, model, args, schema, plugins);
+              }
+              return result ?? null;
+            }, "postProcess")
+          };
+        },
         [ZENSTACK_QUERY_KIND_SYMBOL]: "maybeOne"
       });
     }, "findUnique"),
     findUniqueOrThrow: /* @__PURE__ */ __name((args) => {
       const handler = new FindOperationHandler(client, model, inputValidator);
       return createPromise("findUnique", "findUniqueOrThrow", args, handler, true, true, {
-        [ZENSTACK_QUERY_SYMBOL]: () => handler.buildQuery("findUnique", args),
+        [ZENSTACK_QUERY_SYMBOL]: () => {
+          const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has("findUnique");
+          const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(args, model, schema, plugins) : args;
+          const batchHandler = handler;
+          const { query, args: batchArgs, plan } = batchHandler.buildBatchQuery("findUnique", processedArgs);
+          return {
+            query,
+            postProcess: /* @__PURE__ */ __name((value) => {
+              if (!value) {
+                throw createNotFoundError(model);
+              }
+              let result = batchHandler.applyBatchVirtualRelationPlan(value, plan);
+              result = resultProcessor.processResult(result, model, batchArgs);
+              if (shouldApplyExtResult) {
+                result = applyExtResult(result, model, args, schema, plugins);
+              }
+              return result;
+            }, "postProcess")
+          };
+        },
         [ZENSTACK_QUERY_KIND_SYMBOL]: "one"
       });
     }, "findUniqueOrThrow"),
     findFirst: /* @__PURE__ */ __name((args) => {
       const handler = new FindOperationHandler(client, model, inputValidator);
       return createPromise("findFirst", "findFirst", args, handler, true, false, {
-        [ZENSTACK_QUERY_SYMBOL]: () => handler.buildQuery("findFirst", args),
+        [ZENSTACK_QUERY_SYMBOL]: () => {
+          const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has("findFirst");
+          const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(args, model, schema, plugins) : args;
+          const batchHandler = handler;
+          const { query, args: batchArgs, plan } = batchHandler.buildBatchQuery("findFirst", processedArgs);
+          return {
+            query,
+            postProcess: /* @__PURE__ */ __name((value) => {
+              let result = value;
+              if (result) {
+                result = batchHandler.applyBatchVirtualRelationPlan(result, plan);
+                result = resultProcessor.processResult(result, model, batchArgs);
+              }
+              if (result && shouldApplyExtResult) {
+                result = applyExtResult(result, model, args, schema, plugins);
+              }
+              return result ?? null;
+            }, "postProcess")
+          };
+        },
         [ZENSTACK_QUERY_KIND_SYMBOL]: "maybeOne"
       });
     }, "findFirst"),
     findFirstOrThrow: /* @__PURE__ */ __name((args) => {
       const handler = new FindOperationHandler(client, model, inputValidator);
       return createPromise("findFirst", "findFirstOrThrow", args, handler, true, true, {
-        [ZENSTACK_QUERY_SYMBOL]: () => handler.buildQuery("findFirst", args),
+        [ZENSTACK_QUERY_SYMBOL]: () => {
+          const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has("findFirst");
+          const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(args, model, schema, plugins) : args;
+          const batchHandler = handler;
+          const { query, args: batchArgs, plan } = batchHandler.buildBatchQuery("findFirst", processedArgs);
+          return {
+            query,
+            postProcess: /* @__PURE__ */ __name((value) => {
+              if (!value) {
+                throw createNotFoundError(model);
+              }
+              let result = batchHandler.applyBatchVirtualRelationPlan(value, plan);
+              result = resultProcessor.processResult(result, model, batchArgs);
+              if (shouldApplyExtResult) {
+                result = applyExtResult(result, model, args, schema, plugins);
+              }
+              return result;
+            }, "postProcess")
+          };
+        },
         [ZENSTACK_QUERY_KIND_SYMBOL]: "one"
       });
     }, "findFirstOrThrow"),
     findMany: /* @__PURE__ */ __name((args) => {
       const handler = new FindOperationHandler(client, model, inputValidator);
       return createPromise("findMany", "findMany", args, handler, true, false, {
-        [ZENSTACK_QUERY_SYMBOL]: () => handler.buildQuery("findMany", args),
+        [ZENSTACK_QUERY_SYMBOL]: () => {
+          const shouldApplyExtResult = hasAnyExtResult && EXT_RESULT_OPERATIONS.has("findMany");
+          const processedArgs = shouldApplyExtResult ? prepareArgsForExtResult(args, model, schema, plugins) : args;
+          const batchHandler = handler;
+          const { query, args: batchArgs, plan } = batchHandler.buildBatchQuery("findMany", processedArgs);
+          return {
+            query,
+            postProcess: /* @__PURE__ */ __name((value) => {
+              let result = batchHandler.applyBatchVirtualRelationPlan(value, plan);
+              result = resultProcessor.processResult(result, model, batchArgs);
+              if (shouldApplyExtResult) {
+                result = applyExtResult(result, model, args, schema, plugins);
+              }
+              return result;
+            }, "postProcess")
+          };
+        },
         [ZENSTACK_QUERY_KIND_SYMBOL]: "many"
       });
     }, "findMany"),