From ce9b19cdcf23ec2651a1455321d7535c4ef86534 Mon Sep 17 00:00:00 2001
From: Mike Roelens <mikeroelens@gmail.com>
Date: Wed, 29 May 2024 11:23:11 -0400
Subject: [PATCH] feat: make fields configurable for determining whether or not
 to fetch edges (#614)

* docs: fix link to types file

* feat: make fields configurable for determining whether or not to fetch edges

* Add changeset
---
 .changeset/moody-apricots-wonder.md           |  5 +++
 .../createConnectionLoaderClass.test.ts       | 34 ++++++++++++++++++-
 .../factories/createConnectionLoaderClass.ts  | 13 ++++---
 3 files changed, 47 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/moody-apricots-wonder.md

diff --git a/.changeset/moody-apricots-wonder.md b/.changeset/moody-apricots-wonder.md
new file mode 100644
index 00000000..28e42cf4
--- /dev/null
+++ b/.changeset/moody-apricots-wonder.md
@@ -0,0 +1,5 @@
+---
+"@slonik/dataloaders": minor
+---
+
+feat: make fields configurable for determining whether or not to fetch edges
diff --git a/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.test.ts b/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.test.ts
index 48ee187f..85ed8074 100644
--- a/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.test.ts
+++ b/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.test.ts
@@ -456,7 +456,7 @@ describe('createConnectionLoaderClass', () => {
     expect(results[1].count).toEqual(2);
   });
 
-  it('gets the edges without fetching edges', async () => {
+  it('gets the edges without fetching count', async () => {
     const loader = new PersonConnectionLoader(pool);
     const results = await Promise.all([
       loader.load({
@@ -474,6 +474,38 @@ describe('createConnectionLoaderClass', () => {
     expect(results[1].count).toEqual(0);
     expect(results[1].edges.length).toEqual(2);
   });
+
+  it('fetches edges for fields provided in resolverFieldsThatRequireFetchingEdges config variable', async () => {
+    const loaderClass = createConnectionLoaderClass({
+      query: sql.type(
+        z
+          .object({
+            id: z.number(),
+            name: z.string(),
+            uid: z.string(),
+          })
+          .strict(),
+      )`
+        SELECT
+          id,
+          uid,
+          name
+        FROM person
+      `,
+      resolverFieldsThatRequireFetchingEdges: ['data'],
+    });
+
+    const loader = new loaderClass(pool);
+    const result = await loader.load({
+      info: getInfo(['data']),
+    });
+
+    expect(countTaggedQueries('@count-query')).toEqual(0);
+    expect(countTaggedQueries('@edges-query')).toEqual(1);
+
+    expect(result.count).toEqual(0);
+    expect(result.edges.length).toEqual(10);
+  });
 });
 
 describe('createConnectionLoaderClass (with validation)', () => {
diff --git a/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.ts b/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.ts
index ab1cc89f..233b6f38 100644
--- a/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.ts
+++ b/packages/slonik-dataloaders/src/factories/createConnectionLoaderClass.ts
@@ -37,9 +37,13 @@ const TABLE_ALIAS = 't1';
 export const createConnectionLoaderClass = <T extends ZodTypeAny>(config: {
   columnNameTransformer?: (column: string) => string;
   query: QuerySqlToken<T>;
+  resolverFieldsThatRequireFetchingEdges?: string[];
 }) => {
   const { columnNameTransformer = snakeCase, query } = config;
 
+  const fieldsThatRequireFetchingEdges =
+    config.resolverFieldsThatRequireFetchingEdges ?? ['pageInfo', 'edges'];
+
   const columnIdentifiers = getColumnIdentifiers<z.infer<T>>(
     TABLE_ALIAS,
     columnNameTransformer,
@@ -105,10 +109,11 @@ export const createConnectionLoaderClass = <T extends ZodTypeAny>(config: {
               countQueries.push(null);
             }
 
-            if (
-              requestedFields.has('pageInfo') ||
-              requestedFields.has('edges')
-            ) {
+            const shouldFetchEdges = fieldsThatRequireFetchingEdges.some(
+              (field) => requestedFields.has(field),
+            );
+
+            if (shouldFetchEdges) {
               const orderByExpressions: Array<[SqlToken, OrderDirection]> =
                 orderBy ? orderBy(columnIdentifiers) : [];