more comments

Author: ymc9

packages/runtime/src/enhancements/node/delegate.ts

@@ -180,14 +180,28 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
             return;
         }
 
+        // there're two cases where we need to inject polymorphic base hierarchy for fields
+        // defined in base models
+        // 1. base fields mentioned in select/include clause
+        //     { select: { fieldFromBase: true } } => { select: { delegate_aux_[Base]: { fieldFromBase: true } } }
+        // 2. base fields mentioned in _count select/include clause
+        //     { select: { _count: { select: { fieldFromBase: true } } } } => { select: { delegate_aux_[Base]: { select: { _count: { select: { fieldFromBase: true } } } } } }
+        //
+        // Note that although structurally similar, we need to correctly deal with different injection location of the "delegate_aux" hierarchy
+
+        // selectors for the above two cases
         const selectors = [
+            // regular select: { select: { field: true } }
             (payload: any) => ({ data: payload.select, kind: 'select' as const, isCount: false }),
+            // regular include: { include: { field: true } }
             (payload: any) => ({ data: payload.include, kind: 'include' as const, isCount: false }),
+            // select _count: { select: { _count: { select: { field: true } } } }
             (payload: any) => ({
                 data: payload.select?._count?.select,
                 kind: 'select' as const,
                 isCount: true,
             }),
+            // include _count: { include: { _count: { select: { field: true } } } }
             (payload: any) => ({
                 data: payload.include?._count?.select,
                 kind: 'include' as const,
@@ -232,18 +246,24 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
 
                     let injected = false;
                     if (!isCount) {
+                        // regular select/include injection
                         injected = await this.injectBaseFieldSelect(model, field, fieldValue, args, kind);
                         if (injected) {
+                            // if injected, remove the field from the original payload
                             delete data[field];
                         }
                     } else {
+                        // _count select/include injection, inject into an empty payload and then merge to the proper location
                         const injectTarget = { [kind]: {} };
                         injected = await this.injectBaseFieldSelect(model, field, fieldValue, injectTarget, kind, true);
                         if (injected) {
+                            // if injected, remove the field from the original payload
                             delete data[field];
                             if (Object.keys(data).length === 0) {
+                                // if the original "_count" payload becomes empty, remove it
                                 delete args[kind]['_count'];
                             }
+                            // finally merge the injection into the original payload
                             const merged = deepmerge(args[kind], injectTarget[kind]);
                             args[kind] = merged;
                         }
@@ -308,7 +328,7 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
         value: any,
         selectInclude: any,
         context: 'select' | 'include',
-        forCount = false
+        forCount = false // if the injection is for a "{ _count: { select: { field: true } } }" payload
     ) {
         const fieldInfo = resolveField(this.options.modelMeta, model, field);
         if (!fieldInfo?.inheritedFrom) {
@@ -336,6 +356,7 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
                     thisLayer[baseRelationName] = { [context]: {} };
                 }
                 if (forCount) {
+                    // { _count: { select: { field: true } } } => { delegate_aux_[Base]: { select: { _count: { select: { field: true } } } } }
                     if (
                         !thisLayer[baseRelationName][context]['_count'] ||
                         typeof thisLayer[baseRelationName][context] !== 'object'
@@ -347,6 +368,7 @@ export class DelegateProxyHandler extends DefaultPrismaProxyHandler {
                         { select: { [field]: value } }
                     );
                 } else {
+                    // { select: { field: true } } => { delegate_aux_[Base]: { select: { field: true } } }
                     thisLayer[baseRelationName][context][field] = value;
                 }
                 break;