@danielhritcu/zenstack-orm 3.5.15 → 3.5.17

package/dist/index.js

@@ -3203,6 +3203,7 @@ var BaseOperationHandler = class {
         const sourceField = vr.relation;
         const isSelfReferencing = field === sourceField;
         const { value: rewrittenValue, plan: nestedPlan } = this.rewriteNestedVirtualRelationArgs(vr.targetModel, value, virtualRelations);
+        const discriminatorTarget = vr.where ? this.resolveFilteredRelationDiscriminatorTarget(model, vr.targetModel, vr.where) : void 0;
         if (isSelfReferencing) {
           plans.push({
             kind: "filtered",
@@ -3211,6 +3212,7 @@ var BaseOperationHandler = class {
             sourceModel: vr.targetModel,
             single: vr.single,
             discriminatorWhere: vr.where,
+            discriminatorTarget,
             introducedSourceField: false,
             nestedPlan
           });
@@ -3238,6 +3240,7 @@ var BaseOperationHandler = class {
             sourceModel: vr.targetModel,
             single: vr.single,
             introducedSourceField: selection[sourceField] === void 0,
+            discriminatorTarget,
             nestedPlan
           });
         }
@@ -3335,6 +3338,24 @@ var BaseOperationHandler = class {
       plan: combinedPlan
     };
   }
+  resolveFilteredRelationDiscriminatorTarget(parentModel, relationModel, where) {
+    const keys = Object.keys(where);
+    const parentMatches = keys.every((key) => {
+      const field = getField(this.schema, parentModel, key);
+      return !!field && !field.relation;
+    });
+    if (parentMatches) {
+      return "parent";
+    }
+    const relationMatches = keys.every((key) => {
+      const field = getField(this.schema, relationModel, key);
+      return !!field && !field.relation;
+    });
+    if (relationMatches) {
+      return "relation";
+    }
+    return "parent";
+  }
   applyVirtualRelationPlan(data, plan) {
     if (!plan || data == null) return data;
     if (Array.isArray(data)) return data.map((item) => this.applyVirtualRelationPlan(item, plan));
@@ -3347,11 +3368,17 @@ var BaseOperationHandler = class {
       if (sel.kind === "actual") {
         result[sel.field] = sel.nestedPlan ? this.applyVirtualRelationPlan(sourceValue, sel.nestedPlan) : sourceValue;
       } else if (sel.kind === "filtered") {
-        let value = sel.single ? Array.isArray(sourceValue) ? sourceValue[0] ?? null : sourceValue ?? null : sourceValue;
+        let value = sourceValue;
         if (sel.discriminatorWhere && value != null) {
-          const matches = Object.entries(sel.discriminatorWhere).every(([key, val]) => result[key] === val);
-          if (!matches) value = null;
+          if (sel.discriminatorTarget === "relation") {
+            const matchesRelation = /* @__PURE__ */ __name((item) => item != null && typeof item === "object" && Object.entries(sel.discriminatorWhere).every(([key, expected]) => item[key] === expected), "matchesRelation");
+            value = Array.isArray(value) ? value.filter(matchesRelation) : matchesRelation(value) ? value : null;
+          } else {
+            const matches = Object.entries(sel.discriminatorWhere).every(([key, val]) => result[key] === val);
+            if (!matches) value = null;
+          }
         }
+        value = sel.single ? Array.isArray(value) ? value[0] ?? null : value ?? null : value;
         if (sel.nestedPlan) {
           value = this.applyVirtualRelationPlan(value, sel.nestedPlan);
         }
@@ -5300,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";
@@ -10039,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;
     });
@@ -10178,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"),