graphile-utils 5.0.0-beta.9 → 5.0.0-rc.1

package/dist/makeExtendSchemaPlugin.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeExtendSchemaPlugin = void 0;
+exports.extendSchema = extendSchema;
 const exportable_js_1 = require("./exportable.js");
-function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugin_${String(Math.random()).slice(2)}`) {
+function extendSchema(generator, uniquePluginName = `ExtendSchemaPlugin_${String(Math.random()).slice(2)}`) {
     let graphql;
     if (typeof generator === "function" && generator.length >= 2) {
         console.trace("[DEPRECATED] Your makeExtendSchemaPlugin generator callback accepts two arguments: `(build, options)`; instead you should just use the `build` argument since `options` is just `build.options`.");
@@ -21,32 +22,42 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     return build;
                 },
                 init(_, build, _context) {
-                    const { GraphQLDirective, GraphQLEnumType, GraphQLError, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, Kind, } = graphql;
-                    const { typeDefs, resolvers = Object.create(null), plans = Object.create(null), } = typeof generator === "function"
+                    const { GraphQLDirective, GraphQLEnumType, GraphQLError, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, Kind, parse, } = graphql;
+                    const { typeDefs, resolvers = Object.create(null), plans: rawPlans, enums, scalars, inputObjects, interfaces, unions, objects, } = typeof generator === "function"
                         ? generator.length === 1
                             ? generator(build)
                             : /* TODO: DELETE THIS! */
                                 generator(build, build.options)
                         : generator;
-                    const typeDefsArr = Array.isArray(typeDefs) ? typeDefs : [typeDefs];
-                    const mergedTypeDefinitions = typeDefsArr.reduce((definitions, typeDef) => {
-                        if (!typeDef || typeDef.kind !== "Document") {
-                            throw new Error("The first argument to makeExtendSchemaPlugin must be generated by the `gql` helper, or be an array of the same.");
-                        }
-                        definitions.push(...typeDef.definitions);
-                        return definitions;
-                    }, []);
+                    if (typeDefs == null) {
+                        throw new Error("The first argument to makeExtendSchemaPlugin must be an object containing a `typeDefs` field.");
+                    }
+                    const document = typeof typeDefs === "string"
+                        ? parse(typeDefs)
+                        : Array.isArray(typeDefs)
+                            ? {
+                                kind: graphql.Kind.DOCUMENT,
+                                definitions: typeDefs.flatMap((t) => {
+                                    if (!t || t.kind !== "Document") {
+                                        throw new Error('The first argument to makeExtendSchemaPlugin must be an object containing a `typeDefs` field; the value for this field must be generated by the `gql` helper (`import { gql, makeExtendSchemaPlugin } from "postgraphile/utils"`), or be an array of the same.');
+                                    }
+                                    return t.definitions;
+                                }),
+                            }
+                            : typeDefs;
+                    if (!document || document.kind !== "Document") {
+                        throw new Error('The first argument to makeExtendSchemaPlugin must be an object containing a `typeDefs` field; the value for this field must be generated by the `gql` helper (`import { gql, makeExtendSchemaPlugin } from "postgraphile/utils"`), or be an array of the same.');
+                    }
                     const typeExtensions = {
                         GraphQLSchema: {
                             directives: [],
-                            types: [],
                         },
                         GraphQLInputObjectType: {},
                         GraphQLObjectType: {},
                         GraphQLInterfaceType: {},
                     };
                     const newTypes = [];
-                    mergedTypeDefinitions.forEach((definition) => {
+                    document.definitions.forEach((definition) => {
                         if (definition.kind === "EnumTypeDefinition") {
                             newTypes.push({
                                 type: GraphQLEnumType,
@@ -117,6 +128,196 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             throw new Error(`Unexpected '${definition.kind}' definition; we were expecting 'GraphQLEnumType', 'ObjectTypeExtension', 'InputObjectTypeExtension', 'ObjectTypeDefinition' or 'InputObjectTypeDefinition', i.e. something like 'extend type Foo { ... }'`);
                         }
                     });
+                    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 definitionNodes = document.definitions.filter((d) => d.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                            d.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                            d.kind === Kind.UNION_TYPE_DEFINITION ||
+                            d.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+                            d.kind === Kind.ENUM_TYPE_DEFINITION ||
+                            d.kind === Kind.SCALAR_TYPE_DEFINITION ||
+                            d.kind === Kind.OBJECT_TYPE_EXTENSION ||
+                            d.kind === Kind.INTERFACE_TYPE_EXTENSION ||
+                            d.kind === Kind.UNION_TYPE_EXTENSION ||
+                            d.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION ||
+                            d.kind === Kind.ENUM_TYPE_EXTENSION ||
+                            d.kind === Kind.SCALAR_TYPE_EXTENSION);
+                        const assertLocation = (typeName, expectedLocation) => {
+                            const nodes = definitionNodes.filter((n) => n.name.value === typeName);
+                            const node = nodes[0];
+                            if (!node) {
+                                throw new Error(`You detailed '${expectedLocation}.${typeName}', but the '${typeName}' type is not defined or extended in your 'typeDefs'.`);
+                            }
+                            const [description, attr, names = []] = (() => {
+                                if (node.kind === Kind.OBJECT_TYPE_EXTENSION ||
+                                    node.kind === Kind.OBJECT_TYPE_DEFINITION) {
+                                    return [
+                                        "an object type",
+                                        "objects",
+                                        nodes
+                                            .flatMap((n) => n.fields?.map((f) => f.name.value))
+                                            .filter(isNotNullish),
+                                    ];
+                                }
+                                else if (node.kind === Kind.INTERFACE_TYPE_EXTENSION ||
+                                    node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+                                    return [
+                                        "an interface type",
+                                        "interfaces",
+                                        nodes
+                                            .flatMap((n) => n.fields?.map((f) => f.name.value))
+                                            .filter(isNotNullish),
+                                    ];
+                                }
+                                else if (node.kind === Kind.UNION_TYPE_EXTENSION ||
+                                    node.kind === Kind.UNION_TYPE_DEFINITION) {
+                                    return ["a union type", "unions"];
+                                }
+                                else if (node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION ||
+                                    node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+                                    return [
+                                        "an input object type",
+                                        "inputObjects",
+                                        nodes
+                                            .flatMap((n) => n.fields?.map((f) => f.name.value))
+                                            .filter(isNotNullish),
+                                    ];
+                                }
+                                else if (node.kind === Kind.SCALAR_TYPE_EXTENSION ||
+                                    node.kind === Kind.SCALAR_TYPE_DEFINITION) {
+                                    return ["a scalar type", "scalars"];
+                                }
+                                else if (node.kind === Kind.ENUM_TYPE_EXTENSION ||
+                                    node.kind === Kind.ENUM_TYPE_DEFINITION) {
+                                    return [
+                                        "an enum type",
+                                        "enums",
+                                        nodes
+                                            .flatMap((n) => n.values?.map((f) => f.name.value))
+                                            .filter(isNotNullish),
+                                    ];
+                                }
+                                else {
+                                    throw new Error(`Type ${typeName} not understood`);
+                                }
+                            })();
+                            if (expectedLocation !== attr) {
+                                throw new Error(`You defined '${typeName}' under '${expectedLocation}', but it is ${description} so it should be defined under '${attr}'.`);
+                            }
+                            return names;
+                        };
+                        for (const [typeName, spec] of Object.entries(objects ?? {})) {
+                            const fields = assertLocation(typeName, "objects");
+                            const o = {};
+                            plans[typeName] = o;
+                            const { plans: planResolvers = {}, ...rest } = spec;
+                            for (const [key, val] of Object.entries(rest)) {
+                                assertNotDunder(`objects.${typeName}`, key);
+                                o[`__${key}`] = val;
+                            }
+                            for (const [key, val] of Object.entries(planResolvers)) {
+                                if (!fields.includes(key)) {
+                                    throw new Error(`Object type '${typeName}' field '${key}' was not defined in this plugin.`);
+                                }
+                                o[key] = val;
+                            }
+                        }
+                        for (const [typeName, spec] of Object.entries(inputObjects ?? {})) {
+                            const fields = assertLocation(typeName, "inputObjects");
+                            const o = {};
+                            plans[typeName] = o;
+                            const { plans: planResolvers = {}, ...rest } = spec;
+                            for (const [key, val] of Object.entries(rest)) {
+                                assertNotDunder(`inputObjects.${typeName}`, key);
+                                o[`__${key}`] = val;
+                            }
+                            for (const [key, val] of Object.entries(planResolvers)) {
+                                if (!fields.includes(key)) {
+                                    throw new Error(`Input object type '${typeName}' field '${key}' was not defined in this plugin.`);
+                                }
+                                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)) {
+                                assertNotDunder(`unions.${typeName}`, key);
+                                o[`__${key}`] = val;
+                            }
+                        }
+                        for (const [typeName, spec] of Object.entries(interfaces ?? {})) {
+                            const fields = assertLocation(typeName, "interfaces");
+                            const o = {};
+                            plans[typeName] = o;
+                            const { fields: fieldConfigs = {}, ...rest } = spec;
+                            for (const [key, val] of Object.entries(rest)) {
+                                assertNotDunder(`interfaces.${typeName}`, key);
+                                o[`__${key}`] = val;
+                            }
+                            for (const [key, val] of Object.entries(fieldConfigs)) {
+                                if (!fields.includes(key)) {
+                                    throw new Error(`Interface type '${typeName}' field '${key}' was not defined in this plugin.`);
+                                }
+                                o[key] = val;
+                            }
+                        }
+                        for (const [typeName, spec] of Object.entries(scalars ?? {})) {
+                            assertLocation(typeName, "scalars");
+                            if (spec instanceof GraphQLScalarType) {
+                                plans[typeName] = spec;
+                            }
+                            else {
+                                const { plan, serialize, extensions, parseValue, parseLiteral, ...rest } = spec;
+                                const o = {
+                                    plan,
+                                    serialize,
+                                    extensions,
+                                    parseValue,
+                                    parseLiteral,
+                                };
+                                plans[typeName] = o;
+                                for (const [key, val] of Object.entries(rest)) {
+                                    assertNotDunder(`scalars.${typeName}`, key);
+                                    o[`__${key}`] = val;
+                                }
+                            }
+                        }
+                        for (const [typeName, spec] of Object.entries(enums ?? {})) {
+                            const enumValues = assertLocation(typeName, "enums");
+                            const o = {};
+                            plans[typeName] = o;
+                            const { values = {}, ...rest } = spec;
+                            if ("plans" in rest) {
+                                throw new Error(`Enum type '${typeName}' cannot have field plans, please use 'values'.`);
+                            }
+                            for (const [key, val] of Object.entries(rest)) {
+                                assertNotDunder(`enums.${typeName}`, key);
+                                o[`__${key}`] = val;
+                            }
+                            for (const [key, val] of Object.entries(values)) {
+                                if (!enumValues.includes(key)) {
+                                    throw new Error(`Enum type '${typeName}' value '${key}' was not defined in this plugin.`);
+                                }
+                                o[key] = val;
+                            }
+                        }
+                    }
                     build.makeExtendSchemaPlugin[uniquePluginName] = {
                         typeExtensions,
                         newTypes,
@@ -130,7 +331,9 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             const name = getName(definition.name);
                             const description = getDescription(definition.description);
                             const directives = getDirectives(definition.directives);
-                            const relevantResolver = plans[name] || resolvers[name] || {};
+                            const relevantResolver = (plans[name] ??
+                                resolvers[name] ??
+                                {});
                             const values = (definition.values ?? []).reduce((memo, value) => {
                                 const valueName = getName(value.name);
                                 const valueDescription = getDescription(value.description);
@@ -158,7 +361,12 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                                     },
                                 };
                             }, Object.create(null));
-                            const scope = scopeFromDirectives(directives);
+                            const scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                                ...plans[name]?.__scope,
+                            };
                             build.registerEnumType(name, scope, () => ({ values, description }), uniquePluginName);
                         }
                         else if (def.type === GraphQLObjectType) {
@@ -166,19 +374,27 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             // https://graphql.org/graphql-js/type/#graphqlobjecttype
                             const name = getName(definition.name);
                             const description = getDescription(definition.description);
-                            const interfaces = getInterfaces(definition.interfaces, build);
                             const directives = getDirectives(definition.directives);
+                            const p = (plans[name] ?? {});
                             const scope = {
                                 __origin: `makeExtendSchemaPlugin`,
                                 directives,
                                 ...scopeFromDirectives(directives),
+                                ...p.__scope,
                             };
                             build.registerObjectType(name, scope, () => ({
-                                interfaces,
-                                fields: (fieldsContext) => getFields(fieldsContext.Self, definition.fields, resolvers, plans, fieldsContext, build),
-                                ...(description
+                                interfaces: () => getInterfaces(definition.interfaces, build),
+                                fields: (fieldsContext) => getFields(build, fieldsContext, fieldsContext.Self, definition.fields, resolvers, plans),
+                                ...(description ? { description } : null),
+                                ...(p.__isTypeOf ? { isTypeOf: p.__isTypeOf } : null),
+                                ...(p.__assertStep || p.__planType
                                     ? {
-                                        description,
+                                        extensions: {
+                                            grafast: {
+                                                assertStep: p.__assertStep,
+                                                planType: p.__planType,
+                                            },
+                                        },
                                     }
                                     : null),
                             }), uniquePluginName);
@@ -193,14 +409,11 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                                 __origin: `makeExtendSchemaPlugin`,
                                 directives,
                                 ...scopeFromDirectives(directives),
+                                ...plans[name]?.__scope,
                             };
                             build.registerInputObjectType(name, scope, () => ({
-                                fields: ({ Self }) => getInputFields(Self, definition.fields, build),
-                                ...(description
-                                    ? {
-                                        description,
-                                    }
-                                    : null),
+                                fields: (context) => getInputFields(build, context, definition.fields, plans),
+                                ...(description ? { description } : null),
                             }), uniquePluginName);
                         }
                         else if (def.type === GraphQLUnionType) {
@@ -209,12 +422,21 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             const name = getName(definition.name);
                             const description = getDescription(definition.description);
                             const directives = getDirectives(definition.directives);
+                            const tp = plans[name];
+                            const tr = resolvers[name];
+                            if (tp && tr) {
+                                throw new Error(`You must set only plans.${name} or resolvers.${name} - not both!`);
+                            }
+                            const t = tp ?? tr;
                             const scope = {
                                 __origin: `makeExtendSchemaPlugin`,
                                 directives,
                                 ...scopeFromDirectives(directives),
+                                ...t?.__scope,
                             };
-                            const resolveType = resolvers[name]?.__resolveType;
+                            const resolveType = t?.__resolveType;
+                            const toSpecifier = t?.__toSpecifier;
+                            const planType = t?.__planType;
                             build.registerUnionType(name, scope, () => ({
                                 types: () => {
                                     if (Array.isArray(definition.types)) {
@@ -230,6 +452,8 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                                     }
                                 },
                                 ...(resolveType ? { resolveType } : null),
+                                ...(toSpecifier ? { toSpecifier } : null),
+                                ...(planType ? { planType } : null),
                                 ...(description ? { description } : null),
                             }), uniquePluginName);
                         }
@@ -239,18 +463,27 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             const name = getName(definition.name);
                             const description = getDescription(definition.description);
                             const directives = getDirectives(definition.directives);
+                            const tp = plans[name];
+                            const tr = resolvers[name];
+                            if (tp && tr) {
+                                throw new Error(`You must set only plans.${name} or resolvers.${name} - not both!`);
+                            }
+                            const t = tp ?? tr;
                             const scope = {
                                 __origin: `makeExtendSchemaPlugin`,
                                 directives,
                                 ...scopeFromDirectives(directives),
+                                ...t?.__scope,
                             };
-                            const resolveType = resolvers[name]?.__resolveType;
+                            const resolveType = t?.__resolveType;
+                            const toSpecifier = t?.__toSpecifier;
+                            const planType = t?.__planType;
                             build.registerInterfaceType(name, scope, () => ({
                                 ...(resolveType ? { resolveType } : null),
+                                ...(toSpecifier ? { toSpecifier } : null),
+                                ...(planType ? { planType } : null),
                                 ...(description ? { description } : null),
-                                fields: (fieldsContext) => getFields(fieldsContext.Self, definition.fields, Object.create(null), // Interface doesn't need resolvers
-                                Object.create(null), // Interface doesn't need resolvers
-                                fieldsContext, build),
+                                fields: (fieldsContext) => getFields(build, fieldsContext, fieldsContext.Self, definition.fields, resolvers, plans),
                                 ...(description
                                     ? {
                                         description,
@@ -267,34 +500,42 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                                 __origin: `makeExtendSchemaPlugin`,
                                 directives,
                                 ...scopeFromDirectives(directives),
+                                ...plans[name]?.__scope,
                             };
+                            const possiblePlan = plans[name];
+                            const possibleResolver = resolvers[name];
+                            if (possiblePlan && possibleResolver) {
+                                throw new Error(`You must set only plans.${name} or resolvers.${name} - not both!`);
+                            }
+                            const rawConfig = possiblePlan ?? possibleResolver;
+                            const config = rawConfig
+                                ? rawConfig instanceof GraphQLScalarType
+                                    ? (0, exportable_js_1.EXPORTABLE)((rawConfig) => rawConfig.toConfig(), [rawConfig])
+                                    : rawConfig
+                                : null;
                             build.registerScalarType(name, scope, () => ({
                                 description,
-                                serialize: (0, exportable_js_1.EXPORTABLE)(() => (value) => String(value), []),
-                                parseValue: (0, exportable_js_1.EXPORTABLE)(() => (value) => String(value), []),
-                                parseLiteral: (0, exportable_js_1.EXPORTABLE)((GraphQLError, Kind, name) => (ast) => {
-                                    if (ast.kind !== Kind.STRING) {
-                                        throw new GraphQLError(`${name} can only parse string values`);
-                                    }
-                                    return ast.value;
-                                }, [GraphQLError, Kind, name]),
+                                astNode: definition,
+                                extensions: config?.extensions,
+                                specifiedByURL: config?.specifiedByURL,
+                                serialize: config?.serialize
+                                    ? (0, exportable_js_1.EXPORTABLE)((config) => config.serialize, [config])
+                                    : (0, exportable_js_1.EXPORTABLE)(() => (value) => String(value), []),
+                                parseValue: config?.parseValue
+                                    ? (0, exportable_js_1.EXPORTABLE)((config) => config.parseValue, [config])
+                                    : (0, exportable_js_1.EXPORTABLE)(() => (value) => String(value), []),
+                                parseLiteral: config?.parseLiteral
+                                    ? (0, exportable_js_1.EXPORTABLE)((config) => config.parseLiteral, [config])
+                                    : (0, exportable_js_1.EXPORTABLE)((GraphQLError, Kind, name) => (ast) => {
+                                        if (ast.kind !== Kind.STRING) {
+                                            throw new GraphQLError(`${name} can only parse string values`);
+                                        }
+                                        return ast.value;
+                                    }, [GraphQLError, Kind, name]),
                             }), uniquePluginName);
                         }
                         else if (def.type === GraphQLDirective) {
-                            const definition = def.definition;
-                            // https://github.com/graphql/graphql-js/blob/3c54315ab13c6b9d337fb7c33ad7e27b92ca4a40/src/type/directives.js#L106-L113
-                            const name = getName(definition.name);
-                            const description = getDescription(definition.description);
-                            const locations = definition.locations.map(getName);
-                            const args = getArguments(definition.arguments, build);
-                            // Ignoring isRepeatable and astNode for now
-                            const directive = new GraphQLDirective({
-                                name,
-                                locations,
-                                args,
-                                ...(description ? { description } : null),
-                            });
-                            typeExtensions.GraphQLSchema.directives.push(directive);
+                            typeExtensions.GraphQLSchema.directives.push(def.definition);
                         }
                         else {
                             throw new Error(`We have no code to build an object of type '${def.type}'; it should not have reached this area of the code.`);
@@ -303,16 +544,37 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     return _;
                 },
                 GraphQLSchema(schema, build, _context) {
-                    const { makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { graphql: { GraphQLDirective }, inflection, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions, newTypes }, }, } = build;
+                    const newDirectives = [];
+                    for (const definition of typeExtensions.GraphQLSchema.directives) {
+                        // https://github.com/graphql/graphql-js/blob/3c54315ab13c6b9d337fb7c33ad7e27b92ca4a40/src/type/directives.js#L106-L113
+                        const name = getName(definition.name);
+                        const description = getDescription(definition.description);
+                        const locations = definition.locations.map(getName);
+                        const args = getArguments(definition.arguments, build);
+                        // Ignoring isRepeatable and astNode for now
+                        const directive = new GraphQLDirective({
+                            name,
+                            locations,
+                            args,
+                            ...(description ? { description } : null),
+                        });
+                        newDirectives.push(directive);
+                    }
                     return {
                         ...schema,
                         directives: [
-                            ...(schema.directives || build.graphql.specifiedDirectives || []),
-                            ...typeExtensions.GraphQLSchema.directives,
+                            ...(schema.directives || build.graphql.specifiedDirectives),
+                            ...newDirectives,
                         ],
                         types: [
                             ...(schema.types || []),
-                            ...typeExtensions.GraphQLSchema.types,
+                            ...[
+                                build.getTypeByName(inflection.builtin("Query")),
+                                build.getTypeByName(inflection.builtin("Mutation")),
+                                build.getTypeByName(inflection.builtin("Subscription")),
+                                ...newTypes.map(({ definition }) => build.getTypeByName(definition.name.value)),
+                            ].filter((_) => _ != null),
                         ],
                     };
                 },
@@ -321,7 +583,7 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     const { Self } = context;
                     if (typeExtensions.GraphQLObjectType[Self.name]) {
                         const newFields = typeExtensions.GraphQLObjectType[Self.name].reduce((memo, extension) => {
-                            const moreFields = getFields(Self, extension.fields, resolvers, plans, context, build);
+                            const moreFields = getFields(build, context, Self, extension.fields, resolvers, plans);
                             return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
                         }, Object.create(null));
                         return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
@@ -345,11 +607,11 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     }
                 },
                 GraphQLInputObjectType_fields(fields, build, context) {
-                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions, plans }, }, } = build;
                     const { Self } = context;
                     if (typeExtensions.GraphQLInputObjectType[Self.name]) {
                         const newFields = typeExtensions.GraphQLInputObjectType[Self.name].reduce((memo, extension) => {
-                            const moreFields = getInputFields(Self, extension.fields, build);
+                            const moreFields = getInputFields(build, context, extension.fields, plans);
                             return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
                         }, Object.create(null));
                         return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
@@ -359,13 +621,11 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     }
                 },
                 GraphQLInterfaceType_fields(fields, build, context) {
-                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions, resolvers, plans }, }, } = build;
                     const { Self } = context;
                     if (typeExtensions.GraphQLInterfaceType[Self.name]) {
                         const newFields = typeExtensions.GraphQLInterfaceType[Self.name].reduce((memo, extension) => {
-                            const moreFields = getFields(Self, extension.fields, Object.create(null), // No resolvers for interfaces
-                            Object.create(null), // No resolvers for interfaces
-                            context, build);
+                            const moreFields = getFields(build, context, Self, extension.fields, resolvers, plans);
                             return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
                         }, Object.create(null));
                         return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
@@ -412,7 +672,7 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
         if (type.kind === "NamedType") {
             const Type = build.getTypeByName(getName(type.name));
             if (!Type) {
-                throw new Error(`Could not find type named '${getName(type.name)}'.`);
+                throw new Error(`${uniquePluginName} could not find type named '${getName(type.name)}'.`);
             }
             return Type;
         }
@@ -507,8 +767,12 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     if (arg.defaultValue) {
                         defaultValue = getValue(arg.defaultValue, type);
                     }
+                    const argDirectives = getDirectives(arg.directives);
+                    const deprecatedDirective = argDirectives.find((d) => d.directiveName === "deprecated");
+                    const deprecationReason = deprecatedDirective?.args.reason;
                     memo[name] = {
                         type,
+                        deprecationReason,
                         ...(defaultValue != null ? { defaultValue } : null),
                         ...(description ? { description } : null),
                     };
@@ -521,7 +785,8 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
         }
         return {};
     }
-    function getFields(SelfGeneric, fields, resolvers, plans, context, build) {
+    function getFields(build, context, SelfGeneric, fields, resolvers, plans) {
+        const { graphql: { getNullableType, getNamedType }, } = build;
         const { fieldWithHooks } = context;
         const isRootSubscription = "isRootSubscription" in context.scope && context.scope.isRootSubscription;
         if (!build.graphql.isNamedType(SelfGeneric)) {
@@ -536,25 +801,6 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                     const args = getArguments(field.arguments, build);
                     const type = getType(field.type, build);
                     const directives = getDirectives(field.directives);
-                    const scope = {
-                        fieldName,
-                        /*
-                        ...(typeScope.pgIntrospection &&
-                        typeScope.pgIntrospection.kind === "class"
-                          ? {
-                              pgFieldIntrospection: typeScope.pgIntrospection,
-                            }
-                          : null),
-                        ...(typeScope.isPgRowConnectionType && typeScope.pgIntrospection
-                          ? {
-                              isPgFieldConnection: true,
-                              pgFieldIntrospection: typeScope.pgIntrospection,
-                            }
-                          : null),
-                          */
-                        fieldDirectives: directives,
-                        ...scopeFromDirectives(directives),
-                    };
                     const deprecatedDirective = directives.find((d) => d.directiveName === "deprecated");
                     const deprecationReason = deprecatedDirective?.args.reason;
                     /*
@@ -563,24 +809,18 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                      * other relevant methods.
                      */
                     const possiblePlan = plans[Self.name]?.[fieldName];
+                    build.exportNameHint(possiblePlan, `${Self.name}_${fieldName}_plan`);
                     const possibleResolver = resolvers[Self.name]?.[fieldName];
+                    build.exportNameHint(possibleResolver, `${Self.name}_${fieldName}_resolver`);
                     if (possiblePlan && possibleResolver) {
                         throw new Error(`You must set only plans.${Self.name}.${fieldName} or resolvers.${Self.name}.${fieldName} - not both!`);
                     }
                     const spec = possiblePlan ?? possibleResolver;
                     const fieldSpecGenerator = () => {
                         return {
-                            ...(deprecationReason
-                                ? {
-                                    deprecationReason,
-                                }
-                                : null),
-                            ...(description
-                                ? {
-                                    description,
-                                }
-                                : null),
-                            ...(typeof spec === "function"
+                            ...(deprecationReason ? { deprecationReason } : null),
+                            ...(description ? { description } : null),
+                            ...(build.graphql.isObjectType(Self) && typeof spec === "function"
                                 ? {
                                     [possiblePlan
                                         ? isRootSubscription
@@ -595,6 +835,42 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
                             args,
                         };
                     };
+                    const nullableType = getNullableType(type);
+                    const namedType = getNamedType(type);
+                    const typeScope = build.scopeByType.get(namedType);
+                    const scope = {
+                        fieldDirectives: directives,
+                        // Guess a codec and resource
+                        ...(typeScope && "pgCodec" in typeScope && typeScope.pgCodec
+                            ? {
+                                pgFieldCodec: typeScope.pgCodec,
+                                // First guess at a resource; may be overwritten
+                                pgFieldResource: Object.values(build.input.pgRegistry.pgResources).find((r) => r.codec === typeScope.pgCodec &&
+                                    !r.isUnique &&
+                                    !r.parameters &&
+                                    !r.isVirtual &&
+                                    !r.isList &&
+                                    !r.codec.polymorphism),
+                            }
+                            : null),
+                        // Guess (more accurately) a resource
+                        ...(typeScope &&
+                            "pgTypeResource" in typeScope &&
+                            typeScope.pgTypeResource
+                            ? { pgFieldResource: typeScope.pgTypeResource }
+                            : null),
+                        // Guess if it's a connection
+                        ...(nullableType === namedType &&
+                            typeScope &&
+                            "isConnectionType" in typeScope
+                            ? { isPgFieldConnection: typeScope.isConnectionType }
+                            : null),
+                        // Allow user to overwrite
+                        ...scopeFromDirectives(directives),
+                        ...(typeof spec === "object" && spec !== null ? spec.scope : null),
+                        // fieldName always wins
+                        fieldName,
+                    };
                     return build.extend(memo, {
                         [fieldName]: fieldWithHooks(scope, fieldSpecGenerator),
                     }, `Adding '${fieldName}' to '${Self.name}' from '${uniquePluginName}'`);
@@ -606,25 +882,37 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
         }
         return {};
     }
-    function getInputFields(_Self, fields, build) {
+    function getInputFields(build, context, fields, plans) {
+        const { Self } = context;
         if (fields && fields.length) {
             return fields.reduce((memo, field) => {
                 if (field.kind === "InputValueDefinition") {
                     const description = getDescription(field.description);
                     const fieldName = getName(field.name);
                     const type = getType(field.type, build);
+                    const directives = getDirectives(field.directives);
+                    if (!build.graphql.isInputType(type)) {
+                        throw new Error(`${Self.name}.${fieldName} must use an input type`);
+                    }
                     const defaultValue = field.defaultValue
                         ? getValue(field.defaultValue, type)
                         : undefined;
-                    memo[fieldName] = {
-                        type,
-                        defaultValue,
-                        ...(description
-                            ? {
-                                description,
-                            }
+                    const spec = plans[Self.name]?.[fieldName];
+                    const scope = {
+                        fieldDirectives: directives,
+                        // Allow user to overwrite
+                        ...scopeFromDirectives(directives),
+                        ...(typeof spec === "object" && spec !== null
+                            ? spec.scope
                             : null),
+                        // fieldName always wins
+                        fieldName,
                     };
+                    memo[fieldName] = context.fieldWithHooks(scope, {
+                        type,
+                        defaultValue,
+                        ...(description ? { description } : null),
+                    });
                 }
                 else {
                     throw new Error(`AST issue: expected 'FieldDefinition', instead received '${field.kind}'`);
@@ -635,7 +923,6 @@ function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugi
         return {};
     }
 }
-exports.makeExtendSchemaPlugin = makeExtendSchemaPlugin;
 function scopeFromDirectives(directives) {
     return {
         ...directives
@@ -644,4 +931,14 @@ function scopeFromDirectives(directives) {
             .reduce((memo, a) => Object.assign(memo, a), Object.create(null)),
     };
 }
+function isNotNullish(v) {
+    return v != null;
+}
+/** @deprecated Renamed to 'extendSchema' */
+exports.makeExtendSchemaPlugin = extendSchema;
+function assertNotDunder(loc, key) {
+    if (key.startsWith("__")) {
+        throw new Error(`Key ${JSON.stringify(key)} defined at location ${loc} shouldn't start with __`);
+    }
+}
 //# sourceMappingURL=makeExtendSchemaPlugin.js.map