grafast 0.1.1-beta.21 → 0.1.1-beta.22

package/dist/interfaces.js

@@ -1,80 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$$deepDepSkip = exports.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS = exports.DEFAULT_FORBIDDEN_FLAGS = exports.TRAPPABLE_FLAGS = exports.DEFAULT_ACCEPT_FLAGS = exports.ALL_FLAGS = exports.FLAG_STOPPED = exports.FLAG_POLY_SKIPPED = exports.FLAG_INHIBITED = exports.FLAG_NULL = exports.FLAG_ERROR = exports.NO_FLAGS = exports.$$ts = exports.$$timeout = exports.$$subroutine = exports.$$safeError = exports.$$proxy = exports.$$streamMore = exports.$$eventEmitter = exports.$$idempotent = exports.$$concreteType = exports.$$extensions = exports.$$data = exports.$$bypassGraphQL = exports.$$verbatim = exports.$$id = exports.$$planResults = exports.$$grafastContext = exports.$$hooked = exports.$$cacheByOperation = exports.$$queryCache = void 0;
-const tslib_1 = require("tslib");
-exports.$$queryCache = Symbol("queryCache");
-/**
- * We store the cache directly onto the GraphQLSchema so that it gets garbage
- * collected along with the schema when it's not needed any more. To do so, we
- * attach it using this symbol.
- */
-exports.$$cacheByOperation = Symbol("cacheByOperation");
-exports.$$hooked = Symbol("hookArgsApplied");
-exports.$$grafastContext = Symbol("context");
-exports.$$planResults = Symbol("planResults");
-exports.$$id = Symbol("id");
-/** Return the value verbatim, don't execute */
-exports.$$verbatim = Symbol("verbatim");
-/**
- * If we're sure the data is the right shape and valid, we can set this key and
- * it can be returned directly
- */
-exports.$$bypassGraphQL = Symbol("bypassGraphQL");
-exports.$$data = Symbol("data");
-/**
- * For attaching additional metadata to the GraphQL execution result, for
- * example details of the plan or SQL queries or similar that were executed.
- */
-exports.$$extensions = Symbol("extensions");
-/**
- * The "GraphQLObjectType" type name, useful when dealing with polymorphism.
- */
-exports.$$concreteType = Symbol("concreteType");
-/**
- * Set this key on a type if that type's serialization is idempotent (that is
- * to say `serialize(serialize(thing)) === serialize(thing)`). This means we
- * don't have to "roll-back" serialization if we need to fallback to graphql-js
- * execution.
- */
-exports.$$idempotent = Symbol("idempotent");
-/**
- * The event emitter used for outputting execution events.
- */
-exports.$$eventEmitter = Symbol("executionEventEmitter");
-/**
- * Used to indicate that an array has more results available via a stream.
- */
-exports.$$streamMore = Symbol("streamMore");
-exports.$$proxy = Symbol("proxy");
-/**
- * If an error has this property set then it's safe to send through to the user
- * without being masked.
- */
-exports.$$safeError = Symbol("safeError");
-/** The layerPlan used as a subroutine for this step */
-exports.$$subroutine = Symbol("subroutine");
-/** For tracking the timeout a TimeoutError happened from */
-exports.$$timeout = Symbol("timeout");
-/** For tracking _when_ the timeout happened (because once the JIT has warmed it might not need so long) */
-exports.$$ts = Symbol("timestamp");
-function flag(f) {
-    return f;
-}
-exports.NO_FLAGS = flag(0);
-exports.FLAG_ERROR = flag(1 << 0);
-exports.FLAG_NULL = flag(1 << 1);
-exports.FLAG_INHIBITED = flag(1 << 2);
-exports.FLAG_POLY_SKIPPED = flag(1 << 3);
-exports.FLAG_STOPPED = flag(1 << 4);
-exports.ALL_FLAGS = flag(exports.FLAG_ERROR | exports.FLAG_NULL | exports.FLAG_INHIBITED | exports.FLAG_POLY_SKIPPED | exports.FLAG_STOPPED);
-/** By default, accept null values as an input */
-exports.DEFAULT_ACCEPT_FLAGS = flag(exports.FLAG_NULL);
-exports.TRAPPABLE_FLAGS = flag(exports.FLAG_ERROR | exports.FLAG_NULL | exports.FLAG_INHIBITED);
-exports.DEFAULT_FORBIDDEN_FLAGS = flag(exports.ALL_FLAGS & ~exports.DEFAULT_ACCEPT_FLAGS);
-exports.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS = flag(exports.FLAG_NULL | exports.FLAG_POLY_SKIPPED);
-tslib_1.__exportStar(require("./planJSONInterfaces.js"), exports);
-/**
- * @internal
- */
-exports.$$deepDepSkip = Symbol("deepDepSkip_experimental");
 //# sourceMappingURL=interfaces.js.map

package/dist/makeGrafastSchema.d.ts

@@ -1,16 +1,11 @@
-import type { GraphQLFieldResolver, GraphQLScalarLiteralParser, GraphQLScalarSerializer, GraphQLScalarValueParser } from "graphql";
+import type { GraphQLFieldResolver } from "graphql";
 import { GraphQLSchema } from "graphql";
 import * as graphql from "graphql";
-import type { ArgumentApplyPlanResolver, EnumValueApplyResolver, FieldPlanResolver, InputObjectFieldApplyResolver, InputObjectTypeBakedResolver, ScalarPlanResolver } from "./interfaces.js";
+import type { AbstractTypePlanner, ArgumentApplyPlanResolver, BaseGraphQLArguments, EnumValueApplyResolver, FieldPlanResolver, InputObjectFieldApplyResolver, InputObjectTypeBakedResolver, ScalarPlanResolver } from "./interfaces.js";
 import type { Step } from "./step.js";
-/**
- * When defining a field with `typeDefs/plans` you can declare the field plan
- * directly, or you can define a configuration object that accepts the plan and
- * more.
- */
-export type FieldPlans = FieldPlanResolver<any, any, any> | {
-    plan?: FieldPlanResolver<any, any, any>;
-    subscribePlan?: FieldPlanResolver<any, any, any>;
+export interface ObjectFieldConfig<TSource extends Step = Step, TArgs extends BaseGraphQLArguments = any, TResultStep extends Step = Step> {
+    plan?: FieldPlanResolver<TSource, TArgs, TResultStep>;
+    subscribePlan?: FieldPlanResolver<TSource, TArgs, TResultStep>;
     resolve?: GraphQLFieldResolver<any, any>;
     subscribe?: GraphQLFieldResolver<any, any>;
     args?: {
@@ -20,21 +15,39 @@ export type FieldPlans = FieldPlanResolver<any, any, any> | {
             extensions?: graphql.GraphQLArgumentExtensions;
         };
     };
-};
+}
 /**
- * The plans/config for each field of a GraphQL object type.
+ * When defining a field with `typeDefs/objects` you can declare the field plan
+ * directly, or you can define a configuration object that accepts the plan and
+ * more.
  */
-export type ObjectPlans = {
-    __assertStep?: ((step: Step) => asserts step is Step) | {
-        new (...args: any[]): Step;
+export type FieldPlan<TSource extends Step = Step, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments, TResultStep extends Step = Step> = FieldPlanResolver<TSource, TArgs, TResultStep> | ObjectFieldConfig<TSource, TArgs, TResultStep>;
+export type DeprecatedObjectPlan<TSource extends Step = Step> = {
+    __assertStep?: ((step: Step) => asserts step is TSource) | {
+        new (...args: any[]): TSource;
     };
+    __isTypeOf?: graphql.GraphQLIsTypeOfFn<any, any>;
+    __planType?($specifier: Step): TSource;
 } & {
-    [fieldName: string]: FieldPlans;
+    [key: string]: FieldPlan<TSource, any, any>;
 };
+/**
+ * The plans/config for each field of a GraphQL object type.
+ */
+export interface ObjectPlan<TSource extends Step = Step> {
+    assertStep?: ((step: Step) => asserts step is TSource) | {
+        new (...args: any[]): TSource;
+    };
+    isTypeOf?: graphql.GraphQLIsTypeOfFn<any, any>;
+    planType?($specifier: Step): TSource;
+    plans?: {
+        [key: string]: FieldPlan<TSource, any, any>;
+    };
+}
 /**
  * The plans for each field of a GraphQL input object type.
  */
-export type InputObjectPlans = {
+export type DeprecatedInputObjectPlan = {
     __baked?: InputObjectTypeBakedResolver;
 } & {
     [fieldName: string]: InputObjectFieldApplyResolver<any> | {
@@ -42,44 +55,114 @@ export type InputObjectPlans = {
         extensions?: graphql.GraphQLInputFieldExtensions;
     };
 };
+export interface InputObjectFieldConfig<TParent = any, TData = any> {
+    apply?: InputObjectFieldApplyResolver<TParent, TData>;
+    extensions?: graphql.GraphQLInputFieldExtensions;
+}
+export type InputFieldPlan<TParent = any, TData = any> = InputObjectFieldApplyResolver<TParent, TData> | InputObjectFieldConfig<TParent, TData>;
+export interface InputObjectPlan {
+    baked?: InputObjectTypeBakedResolver;
+    plans?: {
+        [fieldName: string]: InputFieldPlan;
+    };
+}
 /**
  * The plan config for an interface or union type.
  */
-export type InterfaceOrUnionPlans = {
-    __resolveType?: (o: unknown) => string;
+export interface AbstractTypePlan<TSource extends Step = any, TSpecifier extends Step = TSource> {
+    /**
+     * Runtime. If the polymorphic data just needs resolving to a type name, this
+     * method can be used to return said type name. If planning of polymorphism
+     * is more complex for this polymorphic type (for example, if it includes
+     * fetching of data) then the `planType` method should be used instead.
+     *
+     * Warning: this method is more expensive than planType because it requires
+     * the implementation of GraphQL.js emulation.
+     */
+    resolveType?: graphql.GraphQLTypeResolver<any, Grafast.Context>;
+    /**
+     * Takes a step representing this polymorphic position, and returns a
+     * "specifier" step that will be input to planType. If not specified, the
+     * step's own `.toSpecifier()` will be used, if present, otherwise the
+     * step's own `.toRecord()`, and failing that the step itself.
+     */
+    toSpecifier?($step: TSource): TSpecifier;
+    /**
+     * Plantime. `$specifier` is either a step returned from a field or list
+     * position with an abstract type, or a `__ValueStep` that represents the
+     * combined values of such steps (to prevent unbounded plan branching).
+     * `planType` must then construct a step that represents the `__typename`
+     * related to this given specifier (or `null` if no match can be found) and a
+     * `planForType` method which, when called, should return the step for the
+     * given type.
+     */
+    planType?: ($specifier: TSpecifier) => AbstractTypePlanner;
+}
+export interface InterfacePlan<TSource extends Step = any, TSpecifier extends Step = TSource> extends AbstractTypePlan<TSource, TSpecifier> {
+}
+export interface UnionPlan<TSource extends Step = any, TSpecifier extends Step = TSource> extends AbstractTypePlan<TSource, TSpecifier> {
+}
+export type DeprecatedUnionOrInterfacePlan = {
+    [TKey in keyof AbstractTypePlan as `__${TKey}`]: AbstractTypePlan[TKey];
 };
 /**
  * The config for a GraphQL scalar type.
  */
-export type ScalarPlans = {
-    serialize?: GraphQLScalarSerializer<any>;
-    parseValue?: GraphQLScalarValueParser<any>;
-    parseLiteral?: GraphQLScalarLiteralParser<any>;
+export interface ScalarPlan<TInternal = any, TExternal = any> extends Omit<graphql.GraphQLScalarTypeConfig<TInternal, TExternal>, "name" | "description" | "specifiedByURL" | "astNode" | "extensionASTNodes"> {
     plan?: ScalarPlanResolver<any, any>;
-};
+}
+export interface EnumValueConfig extends Omit<graphql.GraphQLEnumValueConfig, "description" | "deprecationReason" | "astNode"> {
+    apply?: EnumValueApplyResolver;
+}
+export type EnumValueInput = EnumValueApplyResolver | EnumValueConfig | string | number | boolean;
 /**
  * The values/configs for the entries in a GraphQL enum type.
  */
-export type EnumPlans = {
-    [enumValueName: string]: EnumValueApplyResolver | string | number | boolean | {
-        value?: unknown;
-        extensions?: graphql.GraphQLEnumValueExtensions;
-        apply?: EnumValueApplyResolver;
+export type EnumPlan = {
+    values?: {
+        [enumValueName: string]: EnumValueInput | undefined;
     };
 };
 /**
  * A map from GraphQL named type to the config for that type.
+ *
+ * @deprecated Please use the different plan types instead
  */
 export interface GrafastPlans {
-    [typeName: string]: ObjectPlans | InputObjectPlans | InterfaceOrUnionPlans | ScalarPlans | EnumPlans;
+    [typeName: string]: DeprecatedObjectPlan | DeprecatedInputObjectPlan | DeprecatedUnionOrInterfacePlan | ScalarPlan | EnumPlan;
+}
+export interface GrafastSchemaConfig {
+    typeDefs: string | graphql.DocumentNode | graphql.DocumentNode[];
+    /**
+     * All the different types of plans smooshed together to simulate the old
+     * typeDefs/resolvers pattern. Avoid.
+     *
+     * @deprecated Please use objects, unions, interfaces, inputObjects, scalars or enums as appropriate.
+     */
+    plans?: GrafastPlans;
+    scalars?: {
+        [typeName: string]: ScalarPlan;
+    };
+    enums?: {
+        [typeName: string]: EnumPlan;
+    };
+    objects?: {
+        [typeName: string]: ObjectPlan<any>;
+    };
+    unions?: {
+        [typeName: string]: UnionPlan<any>;
+    };
+    interfaces?: {
+        [typeName: string]: InterfacePlan<any>;
+    };
+    inputObjects?: {
+        [typeName: string]: InputObjectPlan;
+    };
+    enableDeferStream?: boolean;
 }
 /**
  * Takes a GraphQL schema definition in Interface Definition Language (IDL/SDL)
  * syntax and configs for the types in it and returns a GraphQL schema.
  */
-export declare function makeGrafastSchema(details: {
-    typeDefs: string;
-    plans: GrafastPlans;
-    enableDeferStream?: boolean;
-}): GraphQLSchema;
+export declare function makeGrafastSchema(details: GrafastSchemaConfig): GraphQLSchema;
 //# sourceMappingURL=makeGrafastSchema.d.ts.map

package/dist/makeGrafastSchema.js

@@ -11,10 +11,134 @@ const { buildASTSchema, isEnumType, isInputObjectType, isInterfaceType, isObject
  * syntax and configs for the types in it and returns a GraphQL schema.
  */
 function makeGrafastSchema(details) {
-    const { typeDefs, plans, enableDeferStream = false } = details;
-    const astSchema = buildASTSchema(parse(typeDefs), {
+    const { typeDefs, plans: rawPlans, objects, unions, interfaces, inputObjects, scalars, enums, enableDeferStream = false, } = details;
+    const document = typeof typeDefs === "string"
+        ? parse(typeDefs)
+        : Array.isArray(typeDefs)
+            ? {
+                kind: graphql.Kind.DOCUMENT,
+                definitions: typeDefs.flatMap((t) => t.definitions),
+            }
+            : typeDefs;
+    if (!document || document.kind !== "Document") {
+        throw new Error("The first argument to makeGrafastSchema must be an object containing a `typeDefs` field; the value for this field should be a parsed GraphQL document, array of these, or a string.");
+    }
+    const astSchema = buildASTSchema(document, {
         enableDeferStream,
     });
+    let plans;
+    if (rawPlans) {
+        if (objects || unions || interfaces || inputObjects || scalars || enums) {
+            throw new Error(`plans is deprecated and may not be specified alongside newer approaches`);
+        }
+        plans = rawPlans;
+    }
+    else {
+        // Hackily convert the new format into the old format. We'll do away with
+        // this in future, but for now it's the easiest way to ensure compatibility
+        plans = {};
+        const assertLocation = (typeName, expectedLocation) => {
+            const t = astSchema.getType(typeName);
+            if (!t) {
+                throw new Error(`You detailed '${expectedLocation}.${typeName}', but the '${typeName}' type does not exist in the schema.`);
+            }
+            const [description, attr] = (() => {
+                if (isObjectType(t)) {
+                    return ["an object type", "objects"];
+                }
+                else if (isInterfaceType(t)) {
+                    return ["an interface type", "interfaces"];
+                }
+                else if (isUnionType(t)) {
+                    return ["a union type", "unions"];
+                }
+                else if (isInputObjectType(t)) {
+                    return ["an input object type", "inputObjects"];
+                }
+                else if (isScalarType(t)) {
+                    return ["a scalar type", "scalars"];
+                }
+                else if (isEnumType(t)) {
+                    return ["an enum type", "enums"];
+                }
+                else {
+                    throw new Error(`Type ${t} not understood`);
+                }
+            })();
+            if (expectedLocation !== attr) {
+                throw new Error(`You defined '${t}' under '${expectedLocation}', but it is ${description} so it should be defined under '${attr}'.`);
+            }
+            return t;
+        };
+        for (const [typeName, spec] of Object.entries(objects ?? {})) {
+            const t = assertLocation(typeName, "objects");
+            const o = {};
+            plans[typeName] = o;
+            const { plans: planResolvers = {}, ...rest } = spec;
+            for (const [key, val] of Object.entries(rest)) {
+                o[`__${key}`] = val;
+            }
+            for (const [key, val] of Object.entries(planResolvers)) {
+                if (!t.getFields()[key]) {
+                    throw new Error(`Object type '${t}' has no field '${key}'.`);
+                }
+                o[key] = val;
+            }
+        }
+        for (const [typeName, spec] of Object.entries(inputObjects ?? {})) {
+            const t = assertLocation(typeName, "inputObjects");
+            const o = {};
+            plans[typeName] = o;
+            const { plans: planResolvers = {}, ...rest } = spec;
+            for (const [key, val] of Object.entries(rest)) {
+                o[`__${key}`] = val;
+            }
+            for (const [key, val] of Object.entries(planResolvers)) {
+                if (!t.getFields()[key]) {
+                    throw new Error(`Input object type '${t}' has no input field '${key}'.`);
+                }
+                o[key] = val;
+            }
+        }
+        for (const [typeName, spec] of Object.entries(unions ?? {})) {
+            assertLocation(typeName, "unions");
+            const o = {};
+            plans[typeName] = o;
+            for (const [key, val] of Object.entries(spec)) {
+                o[`__${key}`] = val;
+            }
+        }
+        for (const [typeName, spec] of Object.entries(interfaces ?? {})) {
+            assertLocation(typeName, "interfaces");
+            const o = {};
+            plans[typeName] = o;
+            for (const [key, val] of Object.entries(spec)) {
+                o[`__${key}`] = val;
+            }
+        }
+        for (const [typeName, spec] of Object.entries(scalars ?? {})) {
+            assertLocation(typeName, "scalars");
+            plans[typeName] = spec;
+        }
+        for (const [typeName, spec] of Object.entries(enums ?? {})) {
+            const t = assertLocation(typeName, "enums");
+            const o = {};
+            plans[typeName] = o;
+            const { values = {}, ...rest } = spec;
+            if ("plans" in rest) {
+                throw new Error(`Enum type '${t}' cannot have field plans, please use 'values'.`);
+            }
+            for (const [key, val] of Object.entries(rest)) {
+                o[`__${key}`] = val;
+            }
+            for (const [key, val] of Object.entries(values)) {
+                if (!t.getValues().find((v) => v.name === key)) {
+                    throw new Error(`Enum type '${t}' has no value '${key}'.`);
+                }
+                o[key] = val;
+            }
+        }
+    }
     const schemaConfig = astSchema.toConfig();
     const typeByName = new Map();
     function mapType(type) {
@@ -51,7 +175,7 @@ function makeGrafastSchema(details) {
             }
             if (isObjectType(astType)) {
                 const rawConfig = astType.toConfig();
-                const objectPlans = plans[astType.name];
+                const objectPlan = plans[astType.name];
                 const rawFields = rawConfig.fields;
                 const rawInterfaces = rawConfig.interfaces;
                 const config = {
@@ -60,11 +184,24 @@ function makeGrafastSchema(details) {
                         ...rawConfig.extensions,
                     },
                 };
-                if (objectPlans) {
-                    for (const [fieldName, rawFieldSpec] of Object.entries(objectPlans)) {
+                const ext = config.extensions;
+                if (objectPlan) {
+                    for (const [fieldName, rawFieldSpec] of Object.entries(objectPlan)) {
                         if (fieldName === "__assertStep") {
                             (0, utils_js_1.exportNameHint)(rawFieldSpec, `${typeName}_assertStep`);
-                            config.extensions.grafast = { assertStep: rawFieldSpec };
+                            ext.grafast ??= {};
+                            config.extensions.grafast.assertStep = rawFieldSpec;
+                            continue;
+                        }
+                        else if (fieldName === "__planType") {
+                            (0, utils_js_1.exportNameHint)(rawFieldSpec, `${typeName}_planType`);
+                            ext.grafast ??= {};
+                            config.extensions.grafast.planType = rawFieldSpec;
+                            continue;
+                        }
+                        else if (fieldName === "__isTypeOf") {
+                            (0, utils_js_1.exportNameHint)(rawFieldSpec, `${typeName}_isTypeOf`);
+                            config.isTypeOf = rawFieldSpec;
                             continue;
                         }
                         else if (fieldName.startsWith("__")) {
@@ -98,8 +235,8 @@ function makeGrafastSchema(details) {
                         if (fieldName.startsWith("__")) {
                             continue;
                         }
-                        const fieldSpec = objectPlans && Object.hasOwn(objectPlans, fieldName)
-                            ? objectPlans[fieldName]
+                        const fieldSpec = objectPlan && Object.hasOwn(objectPlan, fieldName)
+                            ? objectPlan[fieldName]
                             : undefined;
                         const fieldConfig = {
                             ...rawFieldSpec,
@@ -186,9 +323,9 @@ function makeGrafastSchema(details) {
                         },
                     },
                 };
-                const inputObjectPlans = plans[astType.name];
-                if (inputObjectPlans) {
-                    for (const [fieldName, fieldSpec] of Object.entries(inputObjectPlans)) {
+                const inputObjectPlan = plans[astType.name];
+                if (inputObjectPlan) {
+                    for (const [fieldName, fieldSpec] of Object.entries(inputObjectPlan)) {
                         if (fieldName === "__baked") {
                             config.extensions.grafast.baked =
                                 fieldSpec;
@@ -208,8 +345,8 @@ function makeGrafastSchema(details) {
                 config.fields = function () {
                     const fields = Object.create(null);
                     for (const [fieldName, rawFieldConfig] of Object.entries(rawFields)) {
-                        const fieldSpec = inputObjectPlans && Object.hasOwn(inputObjectPlans, fieldName)
-                            ? inputObjectPlans[fieldName]
+                        const fieldSpec = inputObjectPlan && Object.hasOwn(inputObjectPlan, fieldName)
+                            ? inputObjectPlan[fieldName]
                             : undefined;
                         const fieldConfig = {
                             ...rawFieldConfig,
@@ -270,6 +407,18 @@ function makeGrafastSchema(details) {
                     (0, utils_js_1.exportNameHint)(polyPlans.__resolveType, `${typeName}_resolveType`);
                     config.resolveType = polyPlans.__resolveType;
                 }
+                if (polyPlans?.__toSpecifier) {
+                    (0, utils_js_1.exportNameHint)(polyPlans.__toSpecifier, `${typeName}_toSpecifier`);
+                    config.extensions ??= Object.create(null);
+                    config.extensions.grafast ??= Object.create(null);
+                    config.extensions.grafast.toSpecifier = polyPlans.__toSpecifier;
+                }
+                if (polyPlans?.__planType) {
+                    (0, utils_js_1.exportNameHint)(polyPlans.__planType, `${typeName}_planType`);
+                    config.extensions ??= Object.create(null);
+                    config.extensions.grafast ??= Object.create(null);
+                    config.extensions.grafast.planType = polyPlans.__planType;
+                }
                 return new graphql.GraphQLInterfaceType(config);
             }
             else if (isUnionType(astType)) {
@@ -286,6 +435,18 @@ function makeGrafastSchema(details) {
                     (0, utils_js_1.exportNameHint)(polyPlans.__resolveType, `${typeName}_resolveType`);
                     config.resolveType = polyPlans.__resolveType;
                 }
+                if (polyPlans?.__toSpecifier) {
+                    (0, utils_js_1.exportNameHint)(polyPlans.__toSpecifier, `${typeName}_toSpecifier`);
+                    config.extensions ??= Object.create(null);
+                    config.extensions.grafast ??= Object.create(null);
+                    config.extensions.grafast.toSpecifier = polyPlans.__toSpecifier;
+                }
+                if (polyPlans?.__planType) {
+                    (0, utils_js_1.exportNameHint)(polyPlans.__planType, `${typeName}_planType`);
+                    config.extensions ??= Object.create(null);
+                    config.extensions.grafast ??= Object.create(null);
+                    config.extensions.grafast.planType = polyPlans.__planType;
+                }
                 return new graphql.GraphQLUnionType(config);
             }
             else if (isScalarType(astType)) {
@@ -296,22 +457,22 @@ function makeGrafastSchema(details) {
                         ...rawConfig.extensions,
                     },
                 };
-                const scalarPlans = plans[astType.name];
-                if (typeof scalarPlans?.serialize === "function") {
-                    (0, utils_js_1.exportNameHint)(scalarPlans.serialize, `${typeName}_serialize`);
-                    config.serialize = scalarPlans.serialize;
+                const scalarPlan = plans[astType.name];
+                if (typeof scalarPlan?.serialize === "function") {
+                    (0, utils_js_1.exportNameHint)(scalarPlan.serialize, `${typeName}_serialize`);
+                    config.serialize = scalarPlan.serialize;
                 }
-                if (typeof scalarPlans?.parseValue === "function") {
-                    (0, utils_js_1.exportNameHint)(scalarPlans.parseValue, `${typeName}_parseValue`);
-                    config.parseValue = scalarPlans.parseValue;
+                if (typeof scalarPlan?.parseValue === "function") {
+                    (0, utils_js_1.exportNameHint)(scalarPlan.parseValue, `${typeName}_parseValue`);
+                    config.parseValue = scalarPlan.parseValue;
                 }
-                if (typeof scalarPlans?.parseLiteral === "function") {
-                    (0, utils_js_1.exportNameHint)(scalarPlans.parseLiteral, `${typeName}_parseLiteral`);
-                    config.parseLiteral = scalarPlans.parseLiteral;
+                if (typeof scalarPlan?.parseLiteral === "function") {
+                    (0, utils_js_1.exportNameHint)(scalarPlan.parseLiteral, `${typeName}_parseLiteral`);
+                    config.parseLiteral = scalarPlan.parseLiteral;
                 }
-                if (typeof scalarPlans?.plan === "function") {
-                    (0, utils_js_1.exportNameHint)(scalarPlans.plan, `${typeName}_plan`);
-                    config.extensions.grafast = { plan: scalarPlans.plan };
+                if (typeof scalarPlan?.plan === "function") {
+                    (0, utils_js_1.exportNameHint)(scalarPlan.plan, `${typeName}_plan`);
+                    config.extensions.grafast = { plan: scalarPlan.plan };
                 }
                 return new graphql.GraphQLScalarType(config);
             }
@@ -320,10 +481,10 @@ function makeGrafastSchema(details) {
                 const config = {
                     ...rawConfig,
                 };
-                const enumPlans = plans[astType.name];
+                const enumPlan = plans[astType.name];
                 const enumValues = config.values;
-                if (enumPlans) {
-                    for (const [enumValueName, enumValueSpec] of Object.entries(enumPlans)) {
+                if (enumPlan) {
+                    for (const [enumValueName, enumValueSpec] of Object.entries(enumPlan)) {
                         const enumValue = enumValues[enumValueName];
                         if (!enumValue) {
                             console.warn(`'plans' specified configuration for enum type '${typeName}' value '${enumValueName}', but that value was not present in the type`);
@@ -389,6 +550,13 @@ function makeGrafastSchema(details) {
         }
     }
     const schema = new graphql_1.GraphQLSchema(schemaConfig);
+    const errors = graphql.validateSchema(schema);
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    else if (errors.length > 1) {
+        throw new AggregateError(errors, `Invalid schema; first few errors:\n${errors.slice(0, 5).join("\n")}`);
+    }
     return schema;
 }
 //# sourceMappingURL=makeGrafastSchema.js.map