improve(extension/schema-errors): move req runtime to ext (#1184)

Author: jasonkuhrt

src/layers/5_request/core.ts

@@ -41,7 +41,7 @@ export const graffleMappedToRequest = (
     : Object.values(operationsVariables)[0]
 
   const operation_ = getOperationDefinition({ query: document, operationName })
-  if (!operation_) throw new Error(`Impossible.`)
+  if (!operation_) throw new Error(`Unknown operation named "${String(operationName)}".`)
 
   return {
     rootType: operationTypeToRootType[operation_.operation],

src/layers/6_client/gql/gql.ts

@@ -78,7 +78,7 @@ export const gqlProperties = defineTerminus((state) => {
             extensions: state.extensions.filter(_ => _.onRequest !== undefined).map(_ => _.onRequest!) as any,
           })
 
-          return handleOutput(state, analyzedRequest.rootType, result)
+          return handleOutput(state, result)
         },
       } as any
     },

src/layers/6_client/handleOutput.ts

@@ -1,9 +1,7 @@
 import type { ExecutionResult, GraphQLError } from 'graphql'
-import { SchemaDrivenDataMap } from '../../layers/7_extensions/CustomScalars/schemaDrivenDataMap/types.js'
 import { Errors } from '../../lib/errors/__.js'
-import type { Grafaid } from '../../lib/grafaid/__.js'
 import type { GraphQLExecutionResultError } from '../../lib/grafaid/graphql.js'
-import { isRecordLikeObject, isString, type Values } from '../../lib/prelude.js'
+import { type Values } from '../../lib/prelude.js'
 import type { SchemaIndex } from '../4_generator/generators/SchemaIndex.js'
 import type { TransportHttp } from '../5_request/types.js'
 import type { State } from './fluent.js'
@@ -44,7 +42,6 @@ export type GraffleExecutionResultVar<$Config extends Config = Config> =
 
 export const handleOutput = (
   state: State,
-  rootTypeName: Grafaid.Schema.RootTypeName,
   result: GraffleExecutionResultVar,
 ) => {
   if (isContextConfigTraditionalGraphQLOutput(state.config)) {
@@ -69,10 +66,6 @@ export const handleOutput = (
   const isReturnExecution = readConfigErrorCategoryOutputChannel(config, `execution`) === `return`
     && (!c.envelope.enabled || !c.envelope.errors.execution)
 
-  const isThrowSchema = readConfigErrorCategoryOutputChannel(config, `schema`) === `throw`
-
-  const isReturnSchema = readConfigErrorCategoryOutputChannel(config, `schema`) === `return`
-
   if (result instanceof Error) {
     if (isThrowOther) throw result
     if (isReturnOther) return result
@@ -91,50 +84,6 @@ export const handleOutput = (
     return isEnvelope ? { ...result, errors: [...result.errors ?? [], error] } : error
   }
 
-  if (state.input.schemaMap) {
-    if (c.errors.schema !== false) {
-      if (!isRecordLikeObject(result.data)) throw new Error(`Expected data to be an object.`)
-      const schemaErrors = Object.entries(result.data).map(([rootFieldName, rootFieldValue]) => {
-        // todo this check would be nice but it doesn't account for aliases right now. To achieve this we would
-        // need to have the selection set available to use and then do a costly analysis for all fields that were aliases.
-        // So costly that we would probably instead want to create an index of them on the initial encoding step and
-        // then make available down stream.
-        // const sddmNodeField = state.input.schemaMap?.roots[rootTypeName]?.f[rootFieldName]
-        // if (!sddmNodeField) return null
-        // if (!isPlainObject(rootFieldValue)) return new Error(`Expected result field to be an object.`)
-        if (!isRecordLikeObject(rootFieldValue)) return null
-
-        // If __typename is not selected we assume that this is not a result field.
-        // The extension makes sure that the __typename would have been selected if it were a result field.
-        const __typename = rootFieldValue[`__typename`]
-        if (!isString(__typename)) return null
-
-        const sddmNode = state.input.schemaMap?.types[__typename]
-        const isErrorObject = SchemaDrivenDataMap.isOutputObject(sddmNode) && Boolean(sddmNode.e)
-        if (!isErrorObject) return null
-        // todo extract message
-        // todo allow mapping error instances to schema errors
-        return new Error(`Failure on field ${rootFieldName}: ${__typename}`)
-      }).filter((_): _ is Error => _ !== null)
-
-      const error = (schemaErrors.length === 1)
-        ? schemaErrors[0]!
-        : schemaErrors.length > 0
-        ? new Errors.ContextualAggregateError(
-          `Two or more schema errors in the execution result.`,
-          {},
-          schemaErrors,
-        )
-        : null
-      if (error) {
-        if (isThrowSchema) throw error
-        if (isReturnSchema) {
-          return isEnvelope ? { ...result, errors: [...result.errors ?? [], error] } : error
-        }
-      }
-    }
-  }
-
   if (isEnvelope) {
     return result
   }

src/layers/6_client/requestMethods/document.test.ts

@@ -41,13 +41,13 @@ describe(`document with two queries`, () => {
     const { run } = withTwo
     // @ts-expect-error
     const error = await run().catch((e: unknown) => e) as Errors.ContextualAggregateError
-    expect(error.message).toEqual(`Must provide operation name if query contains multiple operations.`)
+    expect(error.errors[0]?.message).toEqual(`Must provide operation name if query contains multiple operations.`)
   })
   test(`error if wrong operation name is provided`, async () => {
     const { run } = withTwo
     // @ts-expect-error
     const error = await run(`boo`).catch((e: unknown) => e) as Errors.ContextualAggregateError
-    expect(error.message).toEqual(`Unknown operation named "boo".`)
+    expect(error.cause?.message).toEqual(`Unknown operation named "boo".`)
   })
   test(`error if no operations provided`, () => {
     expect(() => {

src/layers/6_client/requestMethods/requestMethods.ts

@@ -3,7 +3,6 @@ import type { Fluent } from '../../../lib/fluent/__.js'
 import type { Grafaid } from '../../../lib/grafaid/__.js'
 import { isSymbol } from '../../../lib/prelude.js'
 import { Select } from '../../2_Select/__.js'
-import { getOperationOrThrow } from '../../2_Select/document.js'
 import type { GlobalRegistry } from '../../4_generator/globalRegistry.js'
 import { RequestCore } from '../../5_request/__.js'
 import { type ClientContext, defineTerminus, type State } from '../fluent.js'
@@ -112,8 +111,6 @@ export const executeDocument = async (
   const url = state.config.transport.type === `http` ? state.config.transport.url : undefined
   const schema = state.config.transport.type === `http` ? undefined : state.config.transport.schema
 
-  const { rootType } = getOperationOrThrow(document, operationName)
-
   const initialInput = {
     state,
     interfaceType,
@@ -133,5 +130,5 @@ export const executeDocument = async (
     extensions: state.extensions.filter(_ => _.onRequest !== undefined).map(_ => _.onRequest!) as any,
   })
 
-  return handleOutput(state, rootType, result)
+  return handleOutput(state, result)
 }

src/layers/7_extensions/SchemaErrors/SchemaErrors.test.ts

@@ -6,41 +6,64 @@ import { Graffle } from '../../../../tests/_/schemas/kitchen-sink/graffle/__.js'
 import { schemaDrivenDataMap } from '../../../../tests/_/schemas/kitchen-sink/graffle/modules/SchemaDrivenDataMap.js'
 import type { Query } from '../../../../tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.js'
 import { schema } from '../../../../tests/_/schemas/kitchen-sink/schema.js'
+import type { Errors } from '../../../lib/errors/__.js'
 import { Select } from '../../2_Select/__.js'
 import { SelectionSetGraphqlMapper } from '../../3_SelectGraphQLMapper/__.js'
 import { graffleMappedToRequest } from '../../5_request/core.js'
 import { injectTypenameOnRootResultFields } from '../../5_request/schemaErrors.js'
-import { Throws } from '../Throws/Throws.js'
 
-const graffle = Graffle.create({ schema }).use(Throws())
+const graffle = Graffle
+  .create({ schema })
+  .with({
+    output: {
+      defaults: { errorChannel: `return` },
+      errors: { schema: `default` },
+    },
+  })
 
 describe(`document`, () => {
   describe(`query result field`, () => {
     test(`with __typename`, async () => {
-      const result = graffle.throws().document({
-        query: { x: { resultNonNull: { $: { $case: `ErrorOne` }, __typename: true } } },
-      })
-        .run()
-      await expect(result).rejects.toMatchInlineSnapshot(`[Error: Failure on field resultNonNull: ErrorOne]`)
+      const result = (await graffle
+        .document({ query: { x: { resultNonNull: { $: { $case: `ErrorOne` }, __typename: true } } } })
+        .run()) as Errors.ContextualAggregateError
+      expect(result.errors[0]).toMatchInlineSnapshot(`[Error: Failure on field resultNonNull: ErrorOne]`)
+    })
+    test(`__typename is dynamically added at runtime if missing`, async () => {
+      const result = (await graffle
+        .document({ query: { x: { resultNonNull: { $: { $case: `ErrorOne` } } } } })
+        .run()) as Errors.ContextualAggregateError
+      expect(result.errors[0]).toMatchInlineSnapshot(`[Error: Failure on field resultNonNull: ErrorOne]`)
     })
-    test(`without __typename still works, __typename is dynamically added at runtime`, async () => {
-      const result = graffle.throws().document({ query: { x: { resultNonNull: { $: { $case: `ErrorOne` } } } } }).run()
-      await expect(result).rejects.toMatchInlineSnapshot(
-        `[Error: Failure on field resultNonNull: ErrorOne]`,
+    test(`multiple errors`, async () => {
+      const result = (await graffle
+        .document({
+          query: {
+            x: {
+              result: { $: { $case: `ErrorOne` } },
+              resultNonNull: { $: { $case: `ErrorOne` } },
+            },
+          },
+        })
+        .run()) as Errors.ContextualAggregateError
+
+      expect(result.errors[0]).toMatchInlineSnapshot(
+        `[ContextualAggregateError: Two or more schema errors in the execution result.]`,
       )
     })
-    test(`multiple via alias`, async () => {
-      const result = graffle.throws().document({
-        query: {
-          x: {
-            resultNonNull: [
-              [`resultNonNull`, { $: { $case: `ErrorOne` } }],
-              [`x`, { $: { $case: `ErrorOne` } }],
-            ],
+    test(`multiple errors via alias`, async () => {
+      const result = (await graffle
+        .document({
+          query: {
+            x: {
+              resultNonNull: [[`resultNonNull`, { $: { $case: `ErrorOne` } }], [`x`, { $: { $case: `ErrorOne` } }]],
+            },
           },
-        },
-      }).run()
-      await expect(result).rejects.toMatchInlineSnapshot(
+        })
+        // todo rename to "send" to match gql
+        .run()) as Errors.ContextualAggregateError
+
+      expect(result.errors[0]).toMatchInlineSnapshot(
         `[ContextualAggregateError: Two or more schema errors in the execution result.]`,
       )
     })
@@ -49,12 +72,12 @@ describe(`document`, () => {
 
 describe(`query non-result field`, () => {
   test(`without error`, async () => {
-    await expect(graffle.throws().query.objectWithArgs({ $: { id: `x` }, id: true })).resolves.toEqual({
+    await expect(graffle.query.objectWithArgs({ $: { id: `x` }, id: true })).resolves.toEqual({
       id: `x`,
     })
   })
   test(`with error`, async () => {
-    await expect(graffle.throws().query.error()).rejects.toMatchObject(db.errorAggregate)
+    expect(await graffle.query.error()).toMatchObject(db.errorAggregate)
   })
 })
 
@@ -84,17 +107,20 @@ test.each<CasesQuery>([
 	expect(mappedResultWithTypename.document).toMatchObject(mappedResultWithoutTypename.document)
 })
 
-// dprint-ignore
 test(`gql string request`, async ({ kitchenSink }) => {
   // todo it would be nicer to move the extension use to the fixture but how would we get the static type for that?
   // This makes me think of a feature we need to have. Make it easy to get static types of the client in its various configured states.
-  const result = await kitchenSink.use(Throws()).throws().gql`query { resultNonNull (case: Object1) { ... on Object1 { id } } }`.send()
+  const result = await kitchenSink
+    .with({ output: { errors: { schema: `default` } } })
+    .gql`query { resultNonNull (case: Object1) { ... on Object1 { id } } }`
+    .send()
   expect(result).toMatchObject({ resultNonNull: { __typename: `Object1`, id: `abc` } })
 })
 
 test(`gql document request`, async ({ kitchenSink }) => {
-  const result = await kitchenSink.use(Throws()).throws().gql(
-    parse(`query { resultNonNull (case: Object1) { ... on Object1 { id } } }`),
-  ).send()
+  const result = await kitchenSink
+    .with({ output: { errors: { schema: `default` } } })
+    .gql(parse(`query { resultNonNull (case: Object1) { ... on Object1 { id } } }`))
+    .send()
   expect(result).toMatchObject({ resultNonNull: { __typename: `Object1`, id: `abc` } })
 })

src/layers/7_extensions/SchemaErrors/SchemaErrors.ts

@@ -1,6 +1,10 @@
+import { Errors } from '../../../lib/errors/__.js'
 import { normalizeRequestToNode } from '../../../lib/grafaid/request.js'
+import { isString } from '../../../lib/prelude.js'
+import { isRecordLikeObject } from '../../../lib/prelude.js'
 import { injectTypenameOnRootResultFields } from '../../5_request/schemaErrors.js'
 import { createExtension } from '../../6_client/extension/extension.js'
+import { SchemaDrivenDataMap } from '../CustomScalars/schemaDrivenDataMap/types.js'
 
 // todo?: augment config to include how schema errors should be handled in the output
 // todo: manipulate results: 1) schema errors should be thrown or returned (outside envelope) depending on config.
@@ -10,8 +14,11 @@ export const SchemaErrors = () => {
   return createExtension({
     name: `SchemaErrors`,
     onRequest: async ({ pack }) => {
-      const sddm = pack.input.state.config.schemaMap
-      if (!sddm) return pack()
+      const state = pack.input.state
+      const sddm = state.config.schemaMap
+      const config = state.config
+
+      if (!sddm || !config.output.errors.schema) return pack()
 
       const request = normalizeRequestToNode(pack.input.request)
 
@@ -20,7 +27,49 @@ export const SchemaErrors = () => {
 
       injectTypenameOnRootResultFields({ sddm, request })
 
-      return pack()
+      const { exchange } = await pack()
+      const { unpack } = await exchange()
+      const { decode } = await unpack()
+      const result = await decode()
+
+      if (result instanceof Error || !result.data) return result
+
+      const schemaErrors: Error[] = []
+      for (const [rootFieldName, rootFieldValue] of Object.entries(result.data)) {
+        // todo this check would be nice but it doesn't account for aliases right now. To achieve this we would
+        // need to have the selection set available to use and then do a costly analysis for all fields that were aliases.
+        // So costly that we would probably instead want to create an index of them on the initial encoding step and
+        // then make available down stream.
+        // const sddmNodeField = sddm.roots[rootTypeName]?.f[rootFieldName]
+        // if (!sddmNodeField) return null
+        // if (!isPlainObject(rootFieldValue)) return new Error(`Expected result field to be an object.`)
+        if (!isRecordLikeObject(rootFieldValue)) continue
+
+        // If __typename is not selected we assume that this is not a result field.
+        // The extension makes sure that the __typename would have been selected if it were a result field.
+        const __typename = rootFieldValue[`__typename`]
+        if (!isString(__typename)) continue
+
+        const sddmNode = sddm.types[__typename]
+        const isErrorObject = SchemaDrivenDataMap.isOutputObject(sddmNode) && Boolean(sddmNode.e)
+        if (!isErrorObject) continue
+
+        // todo extract message
+        // todo allow mapping error instances to schema errors
+        schemaErrors.push(new Error(`Failure on field ${rootFieldName}: ${__typename}`))
+      }
+
+      const error = (schemaErrors.length === 1)
+        ? schemaErrors[0]!
+        : schemaErrors.length > 0
+        ? new Errors.ContextualAggregateError(`Two or more schema errors in the execution result.`, {}, schemaErrors)
+        : null
+
+      if (error) {
+        result.errors = [...result.errors ?? [], error as any]
+      }
+
+      return result
     },
   })
 }