WIP: Reduce the number of SQL queries

src/graphql/schema/collection/createCollectionGqlType.ts

@@ -37,6 +37,7 @@ export default function createCollectionGqlType<TValue> (
         primaryKey && [options.nodeIdFieldName, {
           description: 'A globally unique identifier. Can be used in various places throughout the system to identify this single value.',
           type: new GraphQLNonNull(GraphQLID),
+          externalFieldNameDependencies: primaryKey._keyTypeFields.map(([fieldName, field]) => field.externalFieldName),
           resolve: (value: TValue) => idSerde.serialize(collection, value),
         }],
       ],
@@ -50,6 +51,7 @@ export default function createCollectionGqlType<TValue> (
             value: {
               description: field.description,
               type: gqlType,
+              externalFieldName: field.externalFieldName,
               resolve: (value: TValue): mixed => intoGqlOutput(field.getValue(value)),
             },
           }
@@ -93,11 +95,13 @@ export default function createCollectionGqlType<TValue> (
               ],
               // We use the config when creating a connection field to inject
               // a condition that limits what we select from the paginator.
-              getPaginatorInput: (headValue: TValue, args: { condition?: { [key: string]: mixed } }) =>
+              getPaginatorInput: (aliasIdentifier: mixed, args: { condition?: { [key: string]: mixed } }) =>
                 conditionHelpers.and(
-                  relation.getTailConditionFromHeadValue!(headValue),
+                  relation.getTailConditionFromHeadAlias!(aliasIdentifier),
                   conditionFromGqlInput(args.condition),
                 ),
+              subquery: true,
+              relation,
             }),
           ]
         }),

src/graphql/schema/collection/createCollectionQueryFieldEntries.ts

@@ -93,11 +93,11 @@ function createCollectionPrimaryKeyField <TValue, TKey>(
       },
     },
 
-    async resolve (_source, args, context): Promise<mixed> {
+    async resolve (_source, args, context, resolveInfo): Promise<mixed> {
       const result = idSerde.deserialize(inventory, args[options.nodeIdFieldName] as string)
       if (result.collection !== collection) throw new Error(`The provided id is for collection '${result.collection.name}', not the expected collection '${collection.name}'.`)
       if (!keyType.isTypeOf(result.keyValue)) throw new Error(`The provided id is not of the correct type.`)
-      const value = await collectionKey.read!(context, result.keyValue)
+      const value = await collectionKey.read!(context, result.keyValue, resolveInfo, collectionGqlType)
       if (value == null) return
       return intoGqlOutput(value)
     },
@@ -123,9 +123,9 @@ function createCollectionKeyField <TValue, TKey>(
   return {
     type: collectionGqlType,
     args: buildObject(inputHelpers.fieldEntries),
-    async resolve (_source, args, context): Promise<mixed> {
+    async resolve (_source, args, context, resolveInfo): Promise<mixed> {
       const key = inputHelpers.getKeyFromInput(args)
-      const value = await collectionKey.read!(context, key)
+      const value = await collectionKey.read!(context, key, resolveInfo, collectionGqlType)
       if (value == null) return
       return intoGqlOutput(value)
     },

src/graphql/schema/collection/createCollectionRelationTailGqlFieldEntries.ts

@@ -46,11 +46,12 @@ export default function createCollectionRelationTailGqlFieldEntries <TSource, TV
             : formatName.field(`${headCollection.type.name}-by-${relation.name}`),
           {
             description: `Reads a single ${scrib.type(headCollectionGqlType)} that is related to this ${scrib.type(collectionGqlType)}.`,
+            externalFieldNameDependencies: relation._tailFieldNames, // 🔥 Needs to account for classicIds
             type: headCollectionGqlType,
-            async resolve (source: TSource, _args: {}, context: mixed): Promise<mixed> {
+            async resolve (source: TSource, _args: {}, context: mixed, resolveInfo: mixed): Promise<mixed> {
               const value = options.getCollectionValue(source)
               const key = relation.getHeadKeyFromTailValue(value)
-              const headValue = await headCollectionKey.read!(context, key)
+              const headValue = await headCollectionKey.read!(context, key, resolveInfo, headCollectionGqlType)
 
               if (headValue == null)
                 return

src/graphql/schema/collection/mutations/createCreateCollectionMutationFieldEntry.ts

@@ -27,6 +27,7 @@ export default function createCreateCollectionMutationFieldEntry <TValue>(
 
   return [formatName.field(name), createMutationGqlField<TValue>(buildToken, {
     name,
+    relatedGqlType: collectionGqlType,
     description: `Creates a single ${scrib.type(collectionGqlType)}.`,
 
     inputFields: [
@@ -74,7 +75,7 @@ export default function createCreateCollectionMutationFieldEntry <TValue>(
     // When we execute we just create a value in the collection after
     // transforming the correct input field.
     // TODO: test
-    execute: (context, input) =>
-      collection.create!(context, inputFromGqlInput(input[inputFieldName])),
+    execute: (context, input, resolveInfo) =>
+      collection.create!(context, inputFromGqlInput(input[inputFieldName]), resolveInfo, collectionGqlType),
   })]
 }

src/graphql/schema/collection/mutations/createDeleteCollectionKeyMutationFieldEntry.ts

@@ -5,6 +5,7 @@ import BuildToken from '../../BuildToken'
 import createMutationGqlField from '../../createMutationGqlField'
 import createCollectionKeyInputHelpers from '../createCollectionKeyInputHelpers'
 import { getDeleteCollectionPayloadGqlType } from './createDeleteCollectionMutationFieldEntry'
+import getGqlOutputType from '../../type/getGqlOutputType'
 
 /**
  * Creates a delete mutation which will delete a single value from a collection
@@ -22,13 +23,15 @@ export default function createDeleteCollectionKeyMutationFieldEntry <TValue, TKe
   const { collection } = collectionKey
   const name = `delete-${collection.type.name}-by-${collectionKey.name}`
   const inputHelpers = createCollectionKeyInputHelpers(buildToken, collectionKey)
+  const { gqlType } = getGqlOutputType(buildToken, collection.type)
 
   return [formatName.field(name), createMutationGqlField<TValue>(buildToken, {
     name,
     description: `Deletes a single \`${formatName.type(collection.type.name)}\` using a unique key.`,
+    relatedGqlType: gqlType,
     inputFields: inputHelpers.fieldEntries,
     payloadType: getDeleteCollectionPayloadGqlType(buildToken, collection),
-    execute: (context, input) =>
-      collectionKey.delete!(context, inputHelpers.getKeyFromInput(input)),
+    execute: (context, input, resolveInfo) =>
+      collectionKey.delete!(context, inputHelpers.getKeyFromInput(input), resolveInfo, gqlType),
   })]
 }

src/graphql/schema/collection/mutations/createDeleteCollectionMutationFieldEntry.ts

@@ -6,6 +6,7 @@ import createMutationGqlField from '../../createMutationGqlField'
 import createMutationPayloadGqlType from '../../createMutationPayloadGqlType'
 import getGqlOutputType from '../../type/getGqlOutputType'
 import createCollectionRelationTailGqlFieldEntries from '../createCollectionRelationTailGqlFieldEntries'
+import getGqlOutputType from '../../type/getGqlOutputType'
 
 /**
  * Creates a delete mutation that uses the primary key of a collection and an
@@ -26,9 +27,12 @@ export default function createDeleteCollectionMutationFieldEntry <TValue>(
   const { options, inventory } = buildToken
   const name = `delete-${collection.type.name}`
 
+  const { gqlType } = getGqlOutputType(buildToken, collection.type)
+
   return [formatName.field(name), createMutationGqlField<TValue>(buildToken, {
     name,
     description: `Deletes a single \`${formatName.type(collection.type.name)}\` using its globally unique id.`,
+    relatedGqlType: gqlType,
     inputFields: [
       // The only input field we want is the globally unique id which
       // corresponds to the primary key of this collection.
@@ -40,13 +44,15 @@ export default function createDeleteCollectionMutationFieldEntry <TValue>(
     payloadType: getDeleteCollectionPayloadGqlType(buildToken, collection),
     // Execute by deserializing the id into its component parts and delete a
     // value in the collection using that key.
-    execute: (context, input) => {
+    execute: (context, input, resolveInfo) => {
       const result = idSerde.deserialize(inventory, input[options.nodeIdFieldName] as string)
 
+      const { gqlType } = getGqlOutputType(buildToken, collection.type)
+
       if (result.collection !== collection)
         throw new Error(`The provided id is for collection '${result.collection.name}', not the expected collection '${collection.name}'.`)
 
-      return primaryKey.delete!(context, result.keyValue)
+      return primaryKey.delete!(context, result.keyValue, resolveInfo, gqlType)
     },
   })]
 }
@@ -64,6 +70,7 @@ function createDeleteCollectionPayloadGqlType <TValue>(
   const { gqlType, intoGqlOutput } = getGqlOutputType(buildToken, new NullableType(collection.type))
   return createMutationPayloadGqlType<TValue>(buildToken, {
     name: `delete-${collection.type.name}`,
+    relatedGqlType: gqlType,
     outputFields: [
       // Add the deleted value as an output field so the user can see the
       // object they just deleted.

src/graphql/schema/collection/mutations/createUpdateCollectionKeyMutationFieldEntry.ts

@@ -5,6 +5,7 @@ import BuildToken from '../../BuildToken'
 import createMutationGqlField from '../../createMutationGqlField'
 import createCollectionKeyInputHelpers from '../createCollectionKeyInputHelpers'
 import { getCollectionPatchType, getUpdateCollectionPayloadGqlType } from './createUpdateCollectionMutationFieldEntry'
+import getGqlOutputType from '../../type/getGqlOutputType'
 
 /**
  * Creates a update mutation which will update a single value from a collection
@@ -24,10 +25,12 @@ export default function createUpdateCollectionKeyMutationFieldEntry <TValue, TKe
   const inputHelpers = createCollectionKeyInputHelpers(buildToken, collectionKey)
   const patchFieldName = formatName.field(`${collection.type.name}-patch`)
   const { gqlType: patchGqlType, fromGqlInput: patchFromGqlInput } = getCollectionPatchType(buildToken, collection)
+  const { gqlType } = getGqlOutputType(buildToken, collection.type)
 
   return [formatName.field(name), createMutationGqlField<TValue>(buildToken, {
     name,
     description: `Updates a single \`${formatName.type(collection.type.name)}\` using a unique key and a patch.`,
+    relatedGqlType: gqlType,
     inputFields: [
       // Include all of the fields we need to construct the key value we will
       // use to find the single value to update.
@@ -42,7 +45,7 @@ export default function createUpdateCollectionKeyMutationFieldEntry <TValue, TKe
       }],
     ],
     payloadType: getUpdateCollectionPayloadGqlType(buildToken, collection),
-    execute: (context, input) =>
-      collectionKey.update!(context, inputHelpers.getKeyFromInput(input), patchFromGqlInput(input[patchFieldName] as {})),
+    execute: (context, input, resolveInfo) =>
+      collectionKey.update!(context, inputHelpers.getKeyFromInput(input), patchFromGqlInput(input[patchFieldName] as {}), resolveInfo, gqlType),
   })]
 }

src/graphql/schema/collection/mutations/createUpdateCollectionMutationFieldEntry.ts

@@ -35,10 +35,12 @@ export default function createUpdateCollectionMutationFieldEntry <TValue>(
   const name = `update-${collection.type.name}`
   const patchFieldName = formatName.field(`${collection.type.name}-patch`)
   const { gqlType: patchGqlType, fromGqlInput: patchFromGqlInput } = getCollectionPatchType(buildToken, collection)
+  const { gqlType } = getGqlOutputType(buildToken, collection.type)
 
   return [formatName.field(name), createMutationGqlField<TValue>(buildToken, {
     name,
     description: `Updates a single \`${formatName.type(collection.type.name)}\` using its globally unique id and a patch.`,
+    relatedGqlType: gqlType,
     inputFields: [
       // The only input field we want is the globally unique id which
       // corresponds to the primary key of this collection.
@@ -58,13 +60,15 @@ export default function createUpdateCollectionMutationFieldEntry <TValue>(
     payloadType: getUpdateCollectionPayloadGqlType(buildToken, collection),
     // Execute by deserializing the id into its component parts and update a
     // value in the collection using that key.
-    execute: (context, input) => {
+    execute: (context, input, resolveInfo) => {
       const result = idSerde.deserialize(inventory, input[options.nodeIdFieldName] as string)
 
+      const { gqlType } = getGqlOutputType(buildToken, collection.type)
+
       if (result.collection !== collection)
         throw new Error(`The provided id is for collection '${result.collection.name}', not the expected collection '${collection.name}'.`)
 
-      return primaryKey.update!(context, result.keyValue, patchFromGqlInput(input[patchFieldName] as {}))
+      return primaryKey.update!(context, result.keyValue, patchFromGqlInput(input[patchFieldName] as {}), resolveInfo, gqlType)
     },
   })]
 }
@@ -137,6 +141,7 @@ function createUpdateCollectionPayloadGqlType <TValue>(
   const { gqlType, intoGqlOutput } = getGqlOutputType(buildToken, new NullableType(collection.type))
   return createMutationPayloadGqlType<TValue>(buildToken, {
     name: `update-${collection.type.name}`,
+    relatedGqlType: gqlType,
     outputFields: [
       // Add the updated value as an output field so the user can see the
       // object they just updated.