Experiment with easier context binding

Author: emmatown

examples/extend-graphql-schema-graphql-ts/schema.ts

@@ -1,7 +1,14 @@
-import { g, list } from '@keystone-6/core'
+import { initG, list } from '@keystone-6/core'
 import { allowAll } from '@keystone-6/core/access'
 import { select, relationship, text, timestamp } from '@keystone-6/core/fields'
-import { type Context, type Lists } from '.keystone/types'
+import type { TypeInfo, Lists } from '.keystone/types'
+
+const g = initG<TypeInfo>()
+type g<
+  K extends initG.Key,
+  FirstArg extends initG.Arg[K],
+  SecondArg extends initG.OtherArg[K] = initG.OtherArgDefaults<FirstArg>[K],
+> = initG<TypeInfo, K, FirstArg, SecondArg>
 
 export const lists = {
   Post: list({
@@ -37,23 +44,23 @@ export const extendGraphqlSchema = g.extend(base => {
     fields: {
       draft: g.field({
         type: g.Int,
-        resolve({ authorId }, args, context: Context) {
+        resolve({ authorId }, args, context) {
           return context.query.Post.count({
             where: { author: { id: { equals: authorId } }, status: { equals: 'draft' } },
           })
         },
       }),
       published: g.field({
         type: g.Int,
-        resolve({ authorId }, args, context: Context) {
+        resolve({ authorId }, args, context) {
           return context.query.Post.count({
             where: { author: { id: { equals: authorId } }, status: { equals: 'published' } },
           })
         },
       }),
       latest: g.field({
         type: base.object('Post'),
-        async resolve({ authorId }, args, context: Context) {
+        async resolve({ authorId }, args, context) {
           const [post] = await context.db.Post.findMany({
             take: 1,
             orderBy: { publishDate: 'desc' },
@@ -72,7 +79,7 @@ export const extendGraphqlSchema = g.extend(base => {
         // with the name provided or throw if it doesn't exist
         type: base.object('Post'),
         args: { id: g.arg({ type: g.nonNull(g.ID) }) },
-        resolve(source, { id }, context: Context) {
+        resolve(source, { id }, context) {
           // Note we use `context.db.Post` here as we have a return type
           // of Post, and this API provides results in the correct format.
           // If you accidentally use `context.query.Post` here you can expect problems
@@ -90,7 +97,7 @@ export const extendGraphqlSchema = g.extend(base => {
             banPost: g.field({
               type: base.object('Post'),
               args: { id: g.arg({ type: g.nonNull(g.ID) }) },
-              resolve(source, { id }, context: Context) {
+              resolve(source, { id }, context) {
                 return context.db.Post.updateOne({
                   where: { id },
                   data: { status: 'banned' },
@@ -107,7 +114,7 @@ export const extendGraphqlSchema = g.extend(base => {
           id: g.arg({ type: g.nonNull(g.ID) }),
           seconds: g.arg({ type: g.nonNull(g.Int), defaultValue: 600 }),
         },
-        resolve(source, { id, seconds }, context: Context) {
+        resolve(source, { id, seconds }, context) {
           const cutoff = new Date(Date.now() - seconds * 1000)
 
           // Note we use `context.db.Post` here as we have a return type

examples/graphql-codegen/schema.ts

@@ -1,10 +1,17 @@
 /* eslint-disable @typescript-eslint/consistent-type-imports */
-import { list, g } from '@keystone-6/core'
+import { list, initG } from '@keystone-6/core'
 import { relationship, text, timestamp, virtual } from '@keystone-6/core/fields'
 import { allowAll } from '@keystone-6/core/access'
 import { graphql } from './gql'
 
-import type { Lists } from '.keystone/types'
+import type { Lists, TypeInfo } from '.keystone/types'
+
+const g = initG<TypeInfo>()
+type g<
+  K extends initG.Key,
+  FirstArg extends initG.Arg[K],
+  SecondArg extends initG.OtherArg[K] = initG.OtherArgDefaults<FirstArg>[K],
+> = initG<TypeInfo, K, FirstArg, SecondArg>
 
 const LatestPostQuery = graphql(/* GraphQL */ `
   query LastestPostQuery($id: ID!) {

examples/virtual-field/schema.ts

@@ -1,8 +1,15 @@
-import { list, g } from '@keystone-6/core'
+import { list, initG } from '@keystone-6/core'
 import { text, checkbox, virtual } from '@keystone-6/core/fields'
 import { allowAll } from '@keystone-6/core/access'
 
-import type { Lists } from '.keystone/types'
+import type { Lists, TypeInfo } from '.keystone/types'
+
+const g = initG<TypeInfo>()
+type g<
+  K extends initG.Key,
+  FirstArg extends initG.Arg[K],
+  SecondArg extends initG.OtherArg[K] = initG.OtherArgDefaults<FirstArg>[K],
+> = initG<TypeInfo, K, FirstArg, SecondArg>
 
 export const lists = {
   Post: list({

packages/core/package.json

@@ -235,8 +235,8 @@
     "@aws-sdk/lib-storage": "^3.83.0",
     "@aws-sdk/s3-request-presigner": "^3.83.0",
     "@babel/runtime": "^7.24.7",
-    "@graphql-ts/extend": "https://pkg.pr.new/Thinkmill/graphql-ts/@graphql-ts/extend@6e84a1c",
-    "@graphql-ts/schema": "https://pkg.pr.new/Thinkmill/graphql-ts/@graphql-ts/schema@6e84a1c",
+    "@graphql-ts/extend": "https://pkg.pr.new/Thinkmill/graphql-ts/@graphql-ts/extend@f4bafbe",
+    "@graphql-ts/schema": "https://pkg.pr.new/Thinkmill/graphql-ts/@graphql-ts/schema@f4bafbe",
     "@graphql-typed-document-node/core": "^3.1.2",
     "@hapi/iron": "^7.0.0",
     "@internationalized/date": "^3.5.5",

packages/core/src/index.ts

@@ -7,3 +7,5 @@ export type { ListConfig, BaseFields } from './types'
 // if this was an explicit list, it would change the re-export here
 // rather than the usage in their project
 export * from './types/schema'
+
+export { initG } from './types/schema/graphql-ts-schema'

packages/core/src/types/schema/graphql-ts-schema.ts

@@ -2,12 +2,10 @@ import type { ReadStream } from 'node:fs'
 import * as graphqlTsSchema from '@graphql-ts/schema'
 // @ts-expect-error
 import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import type { GraphQLFieldExtensions, GraphQLResolveInfo } from 'graphql'
 import { GraphQLError, GraphQLScalarType } from 'graphql'
 import { Decimal as DecimalValue } from 'decimal.js'
 import type { KeystoneContext } from '../context'
 import type { JSONValue } from '../utils'
-import { field as fieldd } from './schema-api-with-context'
 
 export {
   Boolean,
@@ -37,79 +35,58 @@ export type {
   NullableInputType,
   ScalarType,
 } from '@graphql-ts/schema/api-without-context'
-export { bindGraphQLSchemaAPIToContext } from '@graphql-ts/schema'
 export type { BaseSchemaMeta, Extension } from '@graphql-ts/extend'
 export { extend } from '@graphql-ts/extend'
-export { fields, interface, interfaceField, object, union } from './schema-api-with-context'
+export { fields, interface, interfaceField, object, union, field } from './schema-api-with-context'
+import { initG as baseInitG } from '@graphql-ts/schema'
+import type { BaseKeystoneTypeInfo } from '../type-info'
+import type { BaseSchemaMeta, Extension } from '@graphql-ts/extend'
+import { extend } from '@graphql-ts/extend'
 
-// TODO: remove when we use { graphql } from '.keystone'
-type SomeTypeThatIsntARecordOfArgs = string
+export function initG<TypeInfo extends BaseKeystoneTypeInfo>() {
+  return {
+    extend,
+    ...baseInitG<KeystoneContext<TypeInfo>>(),
+  }
+}
 
-type ImpliedResolver<
-  Args extends { [Key in keyof Args]: graphqlTsSchema.Arg<graphqlTsSchema.InputType> },
-  Type extends OutputType<Context>,
-  Context extends KeystoneContext<any>,
-> =
-  | graphqlTsSchema.InferValueFromOutputType<Type>
-  | ((
-      args: graphqlTsSchema.InferValueFromArgs<Args>,
-      context: Context,
-      info: GraphQLResolveInfo
-    ) => graphqlTsSchema.InferValueFromOutputType<Type>)
+export declare namespace initG {
+  export type Arg = {
+    baseSchemaMeta: never
+    extension: never
+  } & baseInitG.Arg
 
-export const field: <
-  Source,
-  Type extends OutputType<Context>,
-  Resolve extends
-    | undefined
-    | ((
-        source: Source,
-        args: graphqlTsSchema.InferValueFromArgs<
-          SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args
-        >,
-        context: Context,
-        info: GraphQLResolveInfo
-      ) => graphqlTsSchema.InferValueFromOutputType<Type>),
-  Context extends KeystoneContext<any>,
-  Args extends { [Key in keyof Args]: graphqlTsSchema.Arg<graphqlTsSchema.InputType> } = {},
->(
-  field: {
-    args?: Args
-    type: Type
-    deprecationReason?: string
-    description?: string
-    extensions?: Readonly<GraphQLFieldExtensions<Source, unknown>>
-  } & (Resolve extends {}
+  // the definition of ArgDefaults may change in the future so you should use `ArgDefaults` as the default
+  // not `Arg`
+  export type ArgDefaults = Arg
+
+  export type OtherArg = {
+    baseSchemaMeta: never
+    extension: never
+  } & baseInitG.OtherArg
+
+  export type OtherArgDefaults<FirstArg> = {
+    baseSchemaMeta: never
+    extension: never
+  } & baseInitG.OtherArgDefaults<FirstArg>
+
+  export type Key = keyof Arg
+  export {}
+}
+
+export type initG<
+  TypeInfo extends BaseKeystoneTypeInfo,
+  K extends initG.Key,
+  FirstArg extends initG.Arg[K],
+  SecondArg extends initG.OtherArg[K] = initG.OtherArgDefaults<FirstArg>[K],
+> = K extends baseInitG.Key
+  ? baseInitG<KeystoneContext<TypeInfo>, K, FirstArg, SecondArg>
+  : K extends 'baseSchemaMeta' | 'extension'
     ? {
-        resolve: ((
-          source: Source,
-          args: graphqlTsSchema.InferValueFromArgs<
-            SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args
-          >,
-          context: Context,
-          info: GraphQLResolveInfo
-        ) => graphqlTsSchema.InferValueFromOutputType<Type>) &
-          Resolve
-      }
-    : {
-        resolve?: ((
-          source: Source,
-          args: graphqlTsSchema.InferValueFromArgs<
-            SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args
-          >,
-          context: Context,
-          info: GraphQLResolveInfo
-        ) => graphqlTsSchema.InferValueFromOutputType<Type>) &
-          Resolve
-      })
-) => Field<
-  Source,
-  Args,
-  Type,
-  undefined extends Resolve ? ImpliedResolver<Args, Type, Context> : unknown,
-  Context
-> = fieldd as any
-// TODO: remove when we use { graphql } from '.keystone'
+        baseSchemaMeta: BaseSchemaMeta
+        extension: Extension
+      }[K]
+    : never
 
 export const JSON = graphqlTsSchema.g.scalar<JSONValue>(
   new GraphQLScalarType({

packages/core/src/types/schema/index.ts

@@ -1,2 +1,10 @@
+import type { BaseKeystoneTypeInfo } from '../type-info'
+import type { initG } from './graphql-ts-schema'
+
 export * as g from './graphql-ts-schema'
+export type g<
+  K extends initG.Key,
+  FirstArg extends initG.Arg[K],
+  SecondArg extends initG.OtherArg[K] = initG.OtherArgDefaults<FirstArg>[K],
+> = initG<BaseKeystoneTypeInfo, K, FirstArg, SecondArg>
 export * from './legacy-alias'

packages/core/src/types/schema/schema-api-with-context.d.ts

@@ -1,5 +1,5 @@
-import { type GraphQLSchemaAPIWithContext } from '@graphql-ts/schema'
+import type { GWithContext } from '@graphql-ts/schema'
 
-declare const __graphql: GraphQLSchemaAPIWithContext<any>
+declare const __graphql: GWithContext<any>
 
 export = __graphql