@model-ts/graphql 0.0.0-stage → 7.1.0

package/dist/internal/SubscriptionRule.js

@@ -0,0 +1,73 @@
+import { GraphQLError, Kind, isAbstractType, typeFromAST, } from "graphql";
+/**
+ * Replaces graphql-js's SingleFieldSubscriptionsRule, which evaluates root
+ * skip/include without variables and throws for a variable condition. Collect
+ * root response keys through fragments and reject root conditionals instead.
+ */
+export const singleRootFieldSubscriptionsRule = (context) => ({
+    OperationDefinition(operation) {
+        if (operation.operation !== "subscription")
+            return;
+        const schema = context.getSchema();
+        const root = schema.getSubscriptionType();
+        if (!root)
+            return;
+        const fields = new Map();
+        const visited = new Set();
+        const forbidden = [];
+        const matches = (fragment) => {
+            if (!fragment.typeCondition)
+                return true;
+            const type = typeFromAST(schema, fragment.typeCondition);
+            return (type === root || (isAbstractType(type) && schema.isSubType(type, root)));
+        };
+        const collect = (selectionSet) => {
+            for (const selection of selectionSet.selections) {
+                // Validation cannot evaluate variables. Like GraphQL 17, root selections are
+                // unconditional and skip/include are forbidden; nested fields are not visited.
+                for (const directive of selection.directives ?? [])
+                    if (directive.name.value === "skip" ||
+                        directive.name.value === "include")
+                        forbidden.push(directive);
+                if (selection.kind === Kind.FIELD) {
+                    const key = selection.alias?.value ?? selection.name.value;
+                    const group = fields.get(key);
+                    if (group)
+                        group.push(selection);
+                    else
+                        fields.set(key, [selection]);
+                }
+                else if (selection.kind === Kind.INLINE_FRAGMENT) {
+                    if (matches(selection))
+                        collect(selection.selectionSet);
+                }
+                else {
+                    const name = selection.name.value;
+                    if (visited.has(name))
+                        continue;
+                    visited.add(name);
+                    const fragment = context.getFragment(name);
+                    // Standard validation owns missing/cyclic fragments; this traversal must terminate.
+                    if (fragment && matches(fragment))
+                        collect(fragment.selectionSet);
+                }
+            }
+        };
+        collect(operation.selectionSet);
+        const name = operation.name
+            ? `Subscription "${operation.name.value}"`
+            : "Anonymous Subscription";
+        if (forbidden.length > 0) {
+            context.reportError(new GraphQLError(`${name} must not use \`@skip\` or \`@include\` directives in the top level selection.`, { nodes: forbidden }));
+            return;
+        }
+        if (fields.size > 1)
+            context.reportError(new GraphQLError(`${name} must select only one top level field.`, {
+                nodes: [...fields.values()].slice(1).flat(),
+            }));
+        for (const nodes of fields.values())
+            if (nodes[0].name.value.startsWith("__"))
+                context.reportError(new GraphQLError(`${name} must not select an introspection top level field.`, { nodes }));
+    },
+});
+//# sourceMappingURL=SubscriptionRule.js.map

package/dist/internal/SubscriptionRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionRule.js","sourceRoot":"","sources":["../../src/internal/SubscriptionRule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,IAAI,EACJ,cAAc,EACd,WAAW,GAOZ,MAAM,SAAS,CAAA;AAEhB;;;;GAIG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC5E,mBAAmB,CAAC,SAAS;QAC3B,IAAI,SAAS,CAAC,SAAS,KAAK,cAAc;YAAE,OAAM;QAClD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAA;QAClC,MAAM,IAAI,GAAG,MAAM,CAAC,mBAAmB,EAAE,CAAA;QACzC,IAAI,CAAC,IAAI;YAAE,OAAM;QACjB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAuB,CAAA;QAC7C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;QACjC,MAAM,SAAS,GAAoB,EAAE,CAAA;QACrC,MAAM,OAAO,GAAG,CAAC,QAAqD,EAAE,EAAE;YACxE,IAAI,CAAC,QAAQ,CAAC,aAAa;gBAAE,OAAO,IAAI,CAAA;YACxC,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAA;YACxD,OAAO,CACL,IAAI,KAAK,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CACxE,CAAA;QACH,CAAC,CAAA;QACD,MAAM,OAAO,GAAG,CAAC,YAA8B,EAAQ,EAAE;YACvD,KAAK,MAAM,SAAS,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;gBAChD,6EAA6E;gBAC7E,+EAA+E;gBAC/E,KAAK,MAAM,SAAS,IAAI,SAAS,CAAC,UAAU,IAAI,EAAE;oBAChD,IACE,SAAS,CAAC,IAAI,CAAC,KAAK,KAAK,MAAM;wBAC/B,SAAS,CAAC,IAAI,CAAC,KAAK,KAAK,SAAS;wBAElC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;gBAC7B,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;oBAClC,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAA;oBAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;oBAC7B,IAAI,KAAK;wBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;;wBAC3B,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAA;gBACnC,CAAC;qBAAM,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,CAAC;oBACnD,IAAI,OAAO,CAAC,SAAS,CAAC;wBAAE,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;gBACzD,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAA;oBACjC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;wBAAE,SAAQ;oBAC/B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;oBACjB,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;oBAC1C,oFAAoF;oBACpF,IAAI,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;wBAAE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;gBACnE,CAAC;YACH,CAAC;QACH,CAAC,CAAA;QACD,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,CAAA;QAC/B,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI;YACzB,CAAC,CAAC,iBAAiB,SAAS,CAAC,IAAI,CAAC,KAAK,GAAG;YAC1C,CAAC,CAAC,wBAAwB,CAAA;QAC5B,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,GAAG,IAAI,gFAAgF,EACvF,EAAE,KAAK,EAAE,SAAS,EAAE,CACrB,CACF,CAAA;YACD,OAAM;QACR,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC;YACjB,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CAAC,GAAG,IAAI,wCAAwC,EAAE;gBAChE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;aAC5C,CAAC,CACH,CAAA;QACH,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE;YACjC,IAAI,KAAK,CAAC,CAAC,CAAE,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;gBACvC,OAAO,CAAC,WAAW,CACjB,IAAI,YAAY,CACd,GAAG,IAAI,oDAAoD,EAC3D,EAAE,KAAK,EAAE,CACV,CACF,CAAA;IACP,CAAC;CACF,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@model-ts/graphql",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "7.1.0",
+  "description": "Effect-native GraphQL schemas, typed model registration and resolver services.",
+  "keywords": [
+    "effect",
+    "graphql",
+    "model"
+  ],
+  "license": "MIT",
+  "author": "Fabian Finke <finkef@icloud.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/finkef/model-ts.git",
+    "directory": "packages/graphql"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./internal/*": null,
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run --project graphql --root ../..",
+    "test:compiler": "bun test/compiler.ts",
+    "test:scale": "bun test/scale.ts",
+    "test:types": "vitest run --project graphql:types --root ../.."
+  },
+  "devDependencies": {
+    "@model-ts/core": "*",
+    "@model-ts/dynamodb": "*",
+    "effect": "4.0.5",
+    "graphql": "16.11.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.5",
+    "graphql": "^16.11.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/src/Assembly.ts

@@ -0,0 +1,352 @@
+import type { Schema } from "effect"
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLEnumType,
+  GraphQLInterfaceType,
+  GraphQLSchema,
+  GraphQLString,
+  GraphQLUnionType,
+  validateSchema,
+  type GraphQLNamedType,
+  type GraphQLFieldConfigMap,
+} from "graphql"
+import { makeConnectionTypes } from "./Connections.ts"
+import {
+  mappedEnumeration,
+  type EnumOptions,
+  type NamedDefinition,
+  type AbstractOptions,
+} from "./Definitions.ts"
+import { describe } from "./FieldRuntime.ts"
+import {
+  type BuildContext,
+  type RuntimeField,
+  type RequestContext,
+} from "./FieldTypes.ts"
+import { InputTypes } from "./InputTypes.ts"
+import { makeResultTypes } from "./Results.ts"
+import { guardScalar } from "./ScalarBoundary.ts"
+import { dateTime, scalar, jsonScalar, enumeration } from "./Scalars.ts"
+import { invalid, unwrap } from "./SchemaTypes.ts"
+
+export interface Collected {
+  readonly name: string
+  readonly description?: string
+  readonly fields: Record<string, RuntimeField>
+  readonly interfaces?: readonly string[]
+  readonly kind?: "object" | "interface"
+  readonly resolveType?: (value: unknown) => string | null
+}
+
+export interface AnyDefinition {
+  readonly "~kind":
+    | "object"
+    | "interface"
+    | "query"
+    | "mutation"
+    | "subscription"
+  readonly "~name"?: string
+  readonly "~model"?: Schema.Top
+  readonly "~implements"?: readonly string[]
+  readonly "~resolveType"?: (value: unknown) => string | null
+  readonly "~description"?: string
+  readonly fields: Readonly<Record<string, RuntimeField>>
+}
+
+export function isDefinition(value: unknown): value is AnyDefinition {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "~kind" in value &&
+    "fields" in value &&
+    typeof value.fields === "object"
+  )
+}
+
+export function isFieldMap(
+  value: unknown,
+): value is Readonly<Record<string, RuntimeField>> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    Object.values(value).every(
+      (field) =>
+        typeof field === "object" &&
+        field !== null &&
+        "build" in field &&
+        typeof field.build === "function",
+    )
+  )
+}
+
+export function assemble(
+  module: Readonly<Record<string, unknown>>,
+): GraphQLSchema {
+  const objects = new Map<string, Collected>()
+  const roots = new Map<string, Collected>([
+    ["Query", { name: "Query", fields: {} }],
+    ["Mutation", { name: "Mutation", fields: {} }],
+    ["Subscription", { name: "Subscription", fields: {} }],
+  ])
+  for (const [key, value] of Object.entries(module)) {
+    if (!isDefinition(value)) continue
+    const fields = value.fields
+    if (!isFieldMap(fields))
+      return invalid(
+        `${key}: fields must be an object of builder field helpers such as GraphQL.string()`,
+      )
+    if (value["~kind"] === "object" || value["~kind"] === "interface") {
+      const name = value["~name"] ?? invalid(`${key} has no GraphQL name`)
+      if (objects.has(name)) invalid(`Duplicate GraphQL object: ${name}`)
+      const description = value["~description"]
+      objects.set(name, {
+        name,
+        ...(value["~resolveType"]
+          ? { resolveType: value["~resolveType"] }
+          : {}),
+        kind: value["~kind"],
+        interfaces: value["~implements"] ?? [],
+        fields: { ...fields },
+        ...(description === undefined ? {} : { description }),
+      })
+      continue
+    }
+    const root = roots.get(
+      value["~kind"] === "query"
+        ? "Query"
+        : value["~kind"] === "mutation"
+          ? "Mutation"
+          : "Subscription",
+    )!
+    for (const [field, config] of Object.entries(fields)) {
+      if (Object.hasOwn(root.fields, field))
+        invalid(`Duplicate field: ${root.name}.${field}`)
+      root.fields[field] = config
+    }
+  }
+
+  const named = new Map<string, GraphQLNamedType>([
+    ["ID", GraphQLID],
+    ["String", GraphQLString],
+    ["Boolean", GraphQLBoolean],
+    ["Int", GraphQLInt],
+    ["Float", GraphQLFloat],
+  ])
+  const add = <T extends GraphQLNamedType>(type: T): T => {
+    if (named.has(type.name)) invalid(`Duplicate GraphQL name: ${type.name}`)
+    named.set(type.name, type)
+    return type
+  }
+  const inputs = new InputTypes(named, add)
+  for (const value of Object.values(module)) {
+    if (typeof value !== "object" || value === null || !("~kind" in value))
+      continue
+    if (value["~kind"] === "scalar" || value["~kind"] === "enum") {
+      // Named constructors store the schema and name together; assembly erases
+      // their heterogeneous value types only after checking the definition kind.
+      const def = value as NamedDefinition<
+        "scalar" | "enum",
+        string,
+        string
+      > & {
+        readonly "~scalar"?: GraphQLScalarType
+        readonly "~enum"?: EnumOptions<string>
+      }
+      const type = add(
+        def["~kind"] === "scalar"
+          ? guardScalar(
+              def["~scalar"] ??
+                scalar(
+                  def["~name"],
+                  def["~model"] as Schema.Codec<string, unknown>,
+                ),
+            )
+          : def["~enum"]
+            ? mappedEnumeration(def["~name"], def["~model"], def["~enum"])
+            : enumeration(def["~name"], def["~model"]),
+      )
+      inputs.register(def["~model"].ast, type)
+    }
+  }
+  const objectType = (name: string, coordinate: string): GraphQLObjectType => {
+    const type = named.get(name) ?? derived(name)
+    return type instanceof GraphQLObjectType
+      ? type
+      : invalid(`Missing object ${name} at ${coordinate}`)
+  }
+  const nodeType = (name: string, coordinate: string) => {
+    const type = named.get(name)
+    return type instanceof GraphQLObjectType ||
+      type instanceof GraphQLInterfaceType ||
+      type instanceof GraphQLUnionType
+      ? type
+      : invalid(
+          `Missing connection node ${name} at ${coordinate}; register an object, interface or union`,
+        )
+  }
+  const { derived, connectionType } = makeConnectionTypes(
+    named,
+    add,
+    nodeType,
+    (name) => {
+      const type = named.get(name)
+      return (
+        type instanceof GraphQLObjectType ||
+        type instanceof GraphQLInterfaceType ||
+        type instanceof GraphQLUnionType
+      )
+    },
+  )
+
+  const context: BuildContext = {
+    input: inputs,
+    output(ref, coordinate) {
+      if (typeof ref !== "string") {
+        const inner = context.output(ref.of, coordinate)
+        return ref.kind === "list"
+          ? new GraphQLNonNull(new GraphQLList(inner))
+          : unwrap(inner)
+      }
+      const scalar =
+        named.get(ref) ??
+        (ref === "DateTime"
+          ? add(dateTime())
+          : ref === "JSON"
+            ? add(jsonScalar())
+            : undefined)
+      return new GraphQLNonNull(
+        scalar instanceof GraphQLScalarType ||
+          scalar instanceof GraphQLEnumType ||
+          scalar instanceof GraphQLUnionType ||
+          scalar instanceof GraphQLInterfaceType
+          ? scalar
+          : objectType(ref, coordinate),
+      )
+    },
+    result: makeResultTypes(inputs, add, objectType, named),
+    connection(node, name, coordinate, counted, edgeName) {
+      nodeType(node, coordinate)
+      return new GraphQLNonNull(
+        connectionType(
+          node,
+          name ?? `${node}${counted ? "Counted" : ""}Connection`,
+          counted,
+          edgeName,
+        ),
+      )
+    },
+  }
+  const fieldConfigs = ({ fields, name, interfaces = [] }: Collected) => {
+    const inherited: GraphQLFieldConfigMap<unknown, RequestContext> = {}
+    for (const name of interfaces) {
+      const definition = named.get(name)
+      if (!(definition instanceof GraphQLInterfaceType))
+        return invalid(`Missing interface ${name}`)
+      // Reuse built configs so inherited result unions retain their interface's type identity.
+      Object.assign(inherited, definition.toConfig().fields)
+    }
+    return {
+      ...inherited,
+      ...Object.fromEntries(
+        Object.entries(fields).map(([field, config]) => [
+          field,
+          config.build(context, field, `${name}.${field}`),
+        ]),
+      ),
+    }
+  }
+
+  const build = (object: Collected) =>
+    add(
+      new GraphQLObjectType({
+        name: object.name,
+        ...describe(object),
+        fields: () => fieldConfigs(object),
+        interfaces: () =>
+          (object.interfaces ?? []).map((name) => {
+            const type = named.get(name)
+            return type instanceof GraphQLInterfaceType
+              ? type
+              : invalid(`Missing interface ${name}`)
+          }),
+      }),
+    )
+  for (const object of objects.values()) {
+    if (object.kind === "interface")
+      add(
+        new GraphQLInterfaceType({
+          name: object.name,
+          ...describe(object),
+          fields: () => fieldConfigs(object),
+          resolveType: (value) => {
+            if (object.resolveType)
+              return object.resolveType(value) ?? undefined
+            if (typeof value !== "object" || value === null) return undefined
+            const name: unknown =
+              Reflect.get(value, "__typename") ?? Reflect.get(value, "_tag")
+            return typeof name === "string" ? name : undefined
+          },
+        }),
+      )
+    else build(object)
+  }
+  for (const value of Object.values(module)) {
+    if (
+      typeof value !== "object" ||
+      value === null ||
+      !("~kind" in value) ||
+      value["~kind"] !== "union"
+    )
+      continue
+    // union() validates member registrations before storing this metadata.
+    const def = value as NamedDefinition<"union", string, unknown> & {
+      readonly options: AbstractOptions<unknown, readonly string[]>
+    }
+    add(
+      new GraphQLUnionType({
+        name: def["~name"],
+        ...describe(def.options),
+        types: () =>
+          def.options.members.map((name) => objectType(name, def["~name"])),
+        resolveType: (value) => {
+          const name: unknown = def.options.resolveType
+            ? def.options.resolveType(value)
+            : (Reflect.get(Object(value), "__typename") ??
+              Reflect.get(Object(value), "_tag"))
+          return typeof name === "string" && def.options.members.includes(name)
+            ? name
+            : undefined
+        },
+      }),
+    )
+  }
+  const query = build(roots.get("Query")!)
+  const mutationRoot = roots.get("Mutation")!
+  const mutation =
+    Object.keys(mutationRoot.fields).length > 0
+      ? build(mutationRoot)
+      : undefined
+  if (Object.keys(roots.get("Query")!.fields).length === 0)
+    invalid("Missing Query fields")
+  const subscriptionRoot = roots.get("Subscription")!
+  const subscription = Object.keys(subscriptionRoot.fields).length
+    ? build(subscriptionRoot)
+    : undefined
+  const schema = new GraphQLSchema({
+    query,
+    ...(subscription ? { subscription } : {}),
+    ...(mutation ? { mutation } : {}),
+    types: [...named.values()],
+  })
+  const problems = validateSchema(schema)
+  if (problems.length)
+    invalid(problems.map((error) => error.message).join("\n"))
+  return schema
+}

package/src/Builder.ts

@@ -0,0 +1,110 @@
+import type { Effect, Stream } from "effect"
+import { assemble } from "./Assembly.ts"
+import {
+  makeDefinitions,
+  type DefinitionBuilder,
+  type CheckedInterfaces,
+} from "./Definitions.ts"
+import { type ErrorPolicyOptions, type ErrorPolicy } from "./Errors.ts"
+import {
+  schemaRequirements,
+  schemaErrorPolicy,
+  type BuiltSchema,
+  type ExecutionResult,
+  type Request,
+  type ContextArgument,
+  subscribe,
+  execute,
+} from "./Execution.ts"
+import { makeFields } from "./Fields.ts"
+import { type Fields, type Requirements } from "./FieldTypes.ts"
+import { type Complete, type CompatibleContexts } from "./Registry.ts"
+import { type ErrorSchema, type ErrorsOf } from "./Results.ts"
+import { input, defaulted, invalid } from "./SchemaTypes.ts"
+
+export interface BuilderOptions {
+  /** Largest "first"/"last" a connection accepts. Defaults to 100. */
+  readonly maxPageSize?: number
+  /** Size for nodes-based slicing when neither first nor last is supplied. Defaults to 20 (capped at maxPageSize). */
+  readonly defaultPageSize?: number
+}
+
+/** Definitions, field helpers and execution for one registry and request context. */
+export interface Builder<Types, G, C = {}>
+  extends DefinitionBuilder<Types, G, C>, Fields<Types, G, C> {
+  input: typeof input
+  default: typeof defaulted
+  /** Errors any resolver may fail with, and how each reaches the response. */
+  withErrorPolicy<
+    const I extends readonly ErrorSchema[] = readonly [],
+    const P extends readonly ErrorSchema[] = readonly [],
+  >(
+    policy: ErrorPolicyOptions<I, P>,
+  ): Builder<Types, G | ErrorsOf<I> | ErrorsOf<P>, C>
+  schema<const M extends Readonly<Record<string, unknown>>>(
+    module: M &
+      Complete<Types, M> &
+      CompatibleContexts<M, C> &
+      CheckedInterfaces<Types, M>,
+  ): BuiltSchema<Requirements<M>, C>
+  /** The request context is per request: it reaches every resolver of this execution and nothing else. */
+  subscribe<R>(
+    schema: BuiltSchema<R, C>,
+    request: Request,
+    ...context: ContextArgument<C>
+  ): Stream.Stream<ExecutionResult, never, R>
+  execute<R>(
+    schema: BuiltSchema<R, C>,
+    request: Request,
+    ...context: ContextArgument<C>
+  ): Effect.Effect<ExecutionResult, never, R>
+}
+
+export function createBuilder<Types, C = {}>(
+  options: BuilderOptions = {},
+): Builder<Types, never, C> {
+  const max = options.maxPageSize ?? 100
+  if (!Number.isSafeInteger(max) || max < 0)
+    invalid("maxPageSize must be a non-negative safe integer")
+  const size = options.defaultPageSize ?? Math.min(20, max)
+  if (!Number.isSafeInteger(size) || size < 0 || size > max)
+    invalid(
+      "defaultPageSize must be a non-negative safe integer no larger than maxPageSize",
+    )
+  return make<Types, never, C>({ internal: [], public: [] }, max, size)
+}
+
+function make<Types, G, C>(
+  policy: ErrorPolicy,
+  maxPageSize: number,
+  defaultPageSize: number,
+): Builder<Types, G, C> {
+  const { fields, rootField } = makeFields<Types, G, C>(
+    policy,
+    maxPageSize,
+    defaultPageSize,
+  )
+  return {
+    ...fields,
+    ...makeDefinitions<Types, G, C>(rootField),
+    input,
+    default: defaulted,
+    withErrorPolicy: (options) =>
+      make(
+        {
+          internal: [...policy.internal, ...(options.internal ?? [])],
+          public: [...policy.public, ...(options.public ?? [])],
+          publicCodes: { ...policy.publicCodes, ...options.publicCodes },
+        },
+        maxPageSize,
+        defaultPageSize,
+      ),
+    schema: (module) => ({
+      schema: assemble(module),
+      [schemaErrorPolicy]: policy,
+      [schemaRequirements]: undefined,
+    }),
+    subscribe,
+    execute,
+  }
+}