refactor: replaceAliases should not be implemented in beforeQueryHelperLean, so explicitly call it in Lean resolvers

Author: nodkz

src/resolvers/findByIdLean.ts

@@ -1,6 +1,6 @@
 import type { Resolver, ObjectTypeComposer } from 'graphql-compose';
 import type { Model, Document } from 'mongoose';
-import { projectionHelper, prepareAliases, prepareAliasesReverse } from './helpers';
+import { projectionHelper, prepareAliases, prepareAliasesReverse, replaceAliases } from './helpers';
 import type { ExtendedResolveParams } from './index';
 import { beforeQueryHelperLean } from './helpers/beforeQueryHelper';
 
@@ -29,14 +29,15 @@ export default function findByIdLean<TSource = Document, TContext = any>(
     args: {
       _id: 'MongoID!',
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: (async (resolveParams: ExtendedResolveParams) => {
       const args = resolveParams.args || {};
 
       if (args._id) {
         resolveParams.query = model.findById(args._id);
         resolveParams.model = model;
         projectionHelper(resolveParams, aliases);
-        return beforeQueryHelperLean(resolveParams, aliasesReverse);
+        const result = await beforeQueryHelperLean(resolveParams);
+        return result && aliasesReverse ? replaceAliases(result, aliasesReverse) : result;
       }
       return Promise.resolve(null);
     }) as any,

src/resolvers/findByIdsLean.ts

@@ -8,6 +8,7 @@ import {
   projectionHelper,
   prepareAliases,
   prepareAliasesReverse,
+  replaceAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelperLean } from './helpers/beforeQueryHelper';
@@ -44,7 +45,7 @@ export default function findByIdsLean<TSource = Document, TContext = any>(
         ...opts?.sort,
       }),
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: (async (resolveParams: ExtendedResolveParams) => {
       const args = resolveParams.args || {};
 
       if (!Array.isArray(args._ids) || args._ids.length === 0) {
@@ -60,7 +61,10 @@ export default function findByIdsLean<TSource = Document, TContext = any>(
       projectionHelper(resolveParams, aliases);
       limitHelper(resolveParams);
       sortHelper(resolveParams);
-      return beforeQueryHelperLean(resolveParams, aliasesReverse) || [];
+      const result = (await beforeQueryHelperLean(resolveParams)) || [];
+      return Array.isArray(result) && aliasesReverse
+        ? result.map((r) => replaceAliases(r, aliasesReverse))
+        : result;
     }) as any,
   }) as any;
 }

src/resolvers/findManyLean.ts

@@ -12,6 +12,7 @@ import {
   projectionHelper,
   prepareAliases,
   prepareAliasesReverse,
+  replaceAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelperLean } from './helpers/beforeQueryHelper';
@@ -53,15 +54,18 @@ export default function findManyLean<TSource = Document, TContext = any>(
         ...opts?.sort,
       }),
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: (async (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.find();
       resolveParams.model = model;
       filterHelper(resolveParams, aliases);
       skipHelper(resolveParams);
       limitHelper(resolveParams);
       sortHelper(resolveParams);
       projectionHelper(resolveParams, aliases);
-      return beforeQueryHelperLean(resolveParams, aliasesReverse) || [];
+      const result = (await beforeQueryHelperLean(resolveParams)) || [];
+      return Array.isArray(result) && aliasesReverse
+        ? result.map((r) => replaceAliases(r, aliasesReverse))
+        : result;
     }) as any,
   });
 }

src/resolvers/findOneLean.ts

@@ -10,6 +10,7 @@ import {
   projectionHelper,
   prepareAliases,
   prepareAliasesReverse,
+  replaceAliases,
 } from './helpers';
 import type { ExtendedResolveParams, GenResolverOpts } from './index';
 import { beforeQueryHelperLean } from './helpers/beforeQueryHelper';
@@ -48,14 +49,15 @@ export default function findOneLean<TSource = Document, TContext = any>(
         ...opts?.sort,
       }),
     },
-    resolve: ((resolveParams: ExtendedResolveParams) => {
+    resolve: (async (resolveParams: ExtendedResolveParams) => {
       resolveParams.query = model.findOne({});
       resolveParams.model = model;
       filterHelper(resolveParams, aliases);
       skipHelper(resolveParams);
       sortHelper(resolveParams);
       projectionHelper(resolveParams, aliases);
-      return beforeQueryHelperLean(resolveParams, aliasesReverse);
+      const result = await beforeQueryHelperLean(resolveParams);
+      return result && aliasesReverse ? replaceAliases(result, aliasesReverse) : result;
     }) as any,
   });
 }

src/resolvers/helpers/beforeQueryHelper.ts

@@ -1,5 +1,4 @@
 import type { ExtendedResolveParams } from '../index';
-import { AliasesMap, replaceAliases } from './aliases';
 
 export interface BeforeQueryHelperOpts {
   useLean?: boolean;
@@ -20,32 +19,18 @@ export async function beforeQueryHelper(resolveParams: ExtendedResolveParams): P
   return result;
 }
 
-export async function beforeQueryHelperLean(
-  resolveParams: ExtendedResolveParams,
-  reverseAliases: AliasesMap | false
-): Promise<any> {
+export async function beforeQueryHelperLean(resolveParams: ExtendedResolveParams): Promise<any> {
   if (!resolveParams.query || typeof resolveParams.query.lean !== 'function') {
     throw new Error('beforeQueryHelper: expected resolveParams.query to be instance of Query');
   }
 
-  let result;
   if (!resolveParams.beforeQuery) {
-    result = await resolveParams.query.lean();
-  } else {
-    result = resolveParams.beforeQuery(resolveParams.query, resolveParams);
-    if (result && typeof (result as any).lean === 'function') {
-      result = await (result as any).lean();
-    }
+    return resolveParams.query.lean();
   }
 
-  if (reverseAliases && result) {
-    // translate field aliases to match GraphQL field type
-    if (Array.isArray(result)) {
-      return result.map((d) => replaceAliases(d, reverseAliases));
-    } else {
-      return replaceAliases(result, reverseAliases);
-    }
-  } else {
-    return result;
+  const result = resolveParams.beforeQuery(resolveParams.query, resolveParams);
+  if (result && typeof (result as any).lean === 'function') {
+    return (result as any).lean();
   }
+  return result;
 }