graphile-utils 4.12.3 → 5.0.0-0.3

package/dist/makeExtendSchemaPlugin.js

@@ -0,0 +1,654 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExtendSchemaPlugin = exports.EXPORTABLE = void 0;
+function EXPORTABLE(factory, args) {
+    const fn = factory(...args);
+    if (!("$exporter$factory" in fn)) {
+        Object.defineProperties(fn, {
+            $exporter$args: { value: args },
+            $exporter$factory: { value: factory },
+        });
+    }
+    return fn;
+}
+exports.EXPORTABLE = EXPORTABLE;
+function makeExtendSchemaPlugin(generator, uniquePluginName = `ExtendSchemaPlugin_${String(Math.random()).slice(2)}`) {
+    let graphql;
+    return {
+        name: uniquePluginName,
+        version: "0.0.0",
+        schema: {
+            hooks: {
+                build(build) {
+                    // Extract GraphQL into the scope so that our other functions can use it.
+                    graphql = build.graphql;
+                    const { options } = build;
+                    const { GraphQLEnumType, GraphQLInputObjectType, GraphQLObjectType, GraphQLScalarType, GraphQLDirective, GraphQLUnionType, GraphQLInterfaceType, } = graphql;
+                    const { typeDefs, resolvers = {}, plans = {}, } = typeof generator === "function"
+                        ? generator(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;
+                    }, []);
+                    const typeExtensions = {
+                        GraphQLSchema: {
+                            directives: [],
+                            types: [],
+                        },
+                        GraphQLInputObjectType: {},
+                        GraphQLObjectType: {},
+                        GraphQLInterfaceType: {},
+                    };
+                    const newTypes = [];
+                    mergedTypeDefinitions.forEach((definition) => {
+                        if (definition.kind === "EnumTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLEnumType,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "ObjectTypeExtension") {
+                            const name = getName(definition.name);
+                            if (!typeExtensions.GraphQLObjectType[name]) {
+                                typeExtensions.GraphQLObjectType[name] = [];
+                            }
+                            typeExtensions.GraphQLObjectType[name].push(definition);
+                        }
+                        else if (definition.kind === "InputObjectTypeExtension") {
+                            const name = getName(definition.name);
+                            if (!typeExtensions.GraphQLInputObjectType[name]) {
+                                typeExtensions.GraphQLInputObjectType[name] = [];
+                            }
+                            typeExtensions.GraphQLInputObjectType[name].push(definition);
+                        }
+                        else if (definition.kind === "InterfaceTypeExtension") {
+                            const name = getName(definition.name);
+                            if (!typeExtensions.GraphQLInterfaceType[name]) {
+                                typeExtensions.GraphQLInterfaceType[name] = [];
+                            }
+                            typeExtensions.GraphQLInterfaceType[name].push(definition);
+                        }
+                        else if (definition.kind === "ObjectTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLObjectType,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "InputObjectTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLInputObjectType,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "UnionTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLUnionType,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "InterfaceTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLInterfaceType,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "DirectiveDefinition") {
+                            newTypes.push({
+                                type: GraphQLDirective,
+                                definition,
+                            });
+                        }
+                        else if (definition.kind === "ScalarTypeDefinition") {
+                            newTypes.push({
+                                type: GraphQLScalarType,
+                                definition,
+                            });
+                        }
+                        else {
+                            if (definition.kind === "TypeExtensionDefinition") {
+                                throw new Error(`You appear to be using a GraphQL version prior to v0.12.0 which has different syntax for schema extensions (e.g. 'TypeExtensionDefinition' instead of 'ObjectTypeExtension'). Sadly makeExtendSchemaPlugin does not support versions of graphql prior to 0.12.0, please update your version of graphql.`);
+                            }
+                            throw new Error(`Unexpected '${definition.kind}' definition; we were expecting 'GraphQLEnumType', 'ObjectTypeExtension', 'InputObjectTypeExtension', 'ObjectTypeDefinition' or 'InputObjectTypeDefinition', i.e. something like 'extend type Foo { ... }'`);
+                        }
+                    });
+                    if (!build.makeExtendSchemaPlugin) {
+                        build.makeExtendSchemaPlugin = Object.create(null);
+                    }
+                    build.makeExtendSchemaPlugin[uniquePluginName] = {
+                        typeExtensions,
+                        newTypes,
+                        resolvers,
+                        plans,
+                    };
+                    return build;
+                },
+                init(_, build, _context) {
+                    const { makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions, newTypes, resolvers, plans, }, }, graphql: { GraphQLEnumType, GraphQLObjectType, GraphQLInputObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLScalarType, GraphQLDirective, Kind, }, } = build;
+                    newTypes.forEach((def) => {
+                        if (def.type === GraphQLEnumType) {
+                            const definition = def.definition;
+                            // https://graphql.org/graphql-js/type/#graphqlenumtype
+                            const name = getName(definition.name);
+                            const description = getDescription(definition.description);
+                            const directives = getDirectives(definition.directives);
+                            const relevantResolver = plans[name] || resolvers[name] || {};
+                            const values = (definition.values ?? []).reduce((memo, value) => {
+                                const valueName = getName(value.name);
+                                const valueDescription = getDescription(value.description);
+                                const valueDirectives = getDirectives(value.directives);
+                                // Value cannot be expressed via SDL, so we grab the value from the resolvers instead.
+                                // resolvers = {
+                                //   MyEnum: {
+                                //     MY_ENUM_VALUE1: 'value1',
+                                //     MY_ENUM_VALUE2: 'value2',
+                                //   }
+                                // }
+                                // Ref: https://github.com/graphql/graphql-js/issues/525#issuecomment-255834625
+                                const valueValue = relevantResolver[valueName] !== undefined
+                                    ? relevantResolver[valueName]
+                                    : valueName;
+                                const deprecatedDirective = valueDirectives.find((d) => d.directiveName === "deprecated");
+                                const valueDeprecationReason = deprecatedDirective?.args.reason;
+                                return {
+                                    ...memo,
+                                    [valueName]: {
+                                        value: valueValue,
+                                        deprecationReason: valueDeprecationReason,
+                                        description: valueDescription,
+                                        directives: valueDirectives,
+                                    },
+                                };
+                            }, {});
+                            const scope = scopeFromDirectives(directives);
+                            build.registerEnumType(name, scope, () => ({ values, description }), uniquePluginName);
+                        }
+                        else if (def.type === GraphQLObjectType) {
+                            const definition = def.definition;
+                            // 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 scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                            };
+                            build.registerObjectType(name, scope, null, () => ({
+                                interfaces,
+                                fields: (fieldsContext) => getFields(fieldsContext.Self, definition.fields, resolvers, plans, fieldsContext, build),
+                                ...(description
+                                    ? {
+                                        description,
+                                    }
+                                    : null),
+                            }), uniquePluginName);
+                        }
+                        else if (def.type === GraphQLInputObjectType) {
+                            const definition = def.definition;
+                            // https://graphql.org/graphql-js/type/#graphqlinputobjecttype
+                            const name = getName(definition.name);
+                            const description = getDescription(definition.description);
+                            const directives = getDirectives(definition.directives);
+                            const scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                            };
+                            build.registerInputObjectType(name, scope, () => ({
+                                fields: ({ Self }) => getInputFields(Self, definition.fields, build),
+                                ...(description
+                                    ? {
+                                        description,
+                                    }
+                                    : null),
+                            }), uniquePluginName);
+                        }
+                        else if (def.type === GraphQLUnionType) {
+                            const definition = def.definition;
+                            // https://graphql.org/graphql-js/type/#graphqluniontype
+                            const name = getName(definition.name);
+                            const description = getDescription(definition.description);
+                            const directives = getDirectives(definition.directives);
+                            const scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                            };
+                            const resolveType = resolvers[name]?.__resolveType;
+                            build.registerUnionType(name, scope, () => ({
+                                types: () => {
+                                    if (Array.isArray(definition.types)) {
+                                        return definition.types.map((typeAST) => {
+                                            if (typeAST.kind !== "NamedType") {
+                                                throw new Error("Only support unions of named types");
+                                            }
+                                            return getType(typeAST, build);
+                                        });
+                                    }
+                                    else {
+                                        return [];
+                                    }
+                                },
+                                ...(resolveType ? { resolveType } : null),
+                                ...(description ? { description } : null),
+                            }), uniquePluginName);
+                        }
+                        else if (def.type === GraphQLInterfaceType) {
+                            const definition = def.definition;
+                            // https://graphql.org/graphql-js/type/#graphqluniontype
+                            const name = getName(definition.name);
+                            const description = getDescription(definition.description);
+                            const directives = getDirectives(definition.directives);
+                            const scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                            };
+                            const resolveType = resolvers[name]?.__resolveType;
+                            build.registerInterfaceType(name, scope, () => ({
+                                ...(resolveType ? { resolveType } : null),
+                                ...(description ? { description } : null),
+                                fields: (fieldsContext) => getFields(fieldsContext.Self, definition.fields, {}, // Interface doesn't need resolvers
+                                {}, // Interface doesn't need resolvers
+                                fieldsContext, build),
+                                ...(description
+                                    ? {
+                                        description,
+                                    }
+                                    : null),
+                            }), uniquePluginName);
+                        }
+                        else if (def.type === GraphQLScalarType) {
+                            const definition = def.definition;
+                            const name = getName(definition.name);
+                            const description = getDescription(definition.description);
+                            const directives = getDirectives(definition.directives);
+                            const scope = {
+                                __origin: `makeExtendSchemaPlugin`,
+                                directives,
+                                ...scopeFromDirectives(directives),
+                            };
+                            build.registerScalarType(name, scope, () => ({
+                                description,
+                                serialize: EXPORTABLE(() => (value) => String(value), []),
+                                parseValue: EXPORTABLE(() => (value) => String(value), []),
+                                parseLiteral: EXPORTABLE((Kind) => (ast) => {
+                                    if (ast.kind !== Kind.STRING) {
+                                        throw new Error("Can only parse string values");
+                                    }
+                                    return ast.value;
+                                }, [Kind]),
+                            }), 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
+                            // TODO: should we add hooks for directives?
+                            const directive = new GraphQLDirective({
+                                name,
+                                locations,
+                                args,
+                                ...(description ? { description } : null),
+                            });
+                            typeExtensions.GraphQLSchema.directives.push(directive);
+                        }
+                        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.`);
+                        }
+                    });
+                    return _;
+                },
+                GraphQLSchema(schema, build, _context) {
+                    const { makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    return {
+                        ...schema,
+                        directives: [
+                            ...(schema.directives || build.graphql.specifiedDirectives || []),
+                            ...typeExtensions.GraphQLSchema.directives,
+                        ],
+                        types: [
+                            ...(schema.types || []),
+                            ...typeExtensions.GraphQLSchema.types,
+                        ],
+                    };
+                },
+                GraphQLObjectType_fields(fields, build, context) {
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions, resolvers, plans }, }, } = build;
+                    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);
+                            return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
+                        }, {});
+                        return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
+                    }
+                    else {
+                        return fields;
+                    }
+                },
+                GraphQLObjectType_interfaces(interfaces, build, context) {
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { Self } = context;
+                    if (typeExtensions.GraphQLObjectType[Self.name]) {
+                        const newInterfaces = typeExtensions.GraphQLObjectType[Self.name].reduce((memo, extension) => {
+                            const moreInterfaces = getInterfaces(extension.interfaces, build);
+                            return extend(memo, moreInterfaces, `Adding interfaces from ${uniquePluginName}`);
+                        }, {});
+                        return extend(interfaces, newInterfaces, `Adding interfaces from ${uniquePluginName}`);
+                    }
+                    else {
+                        return interfaces;
+                    }
+                },
+                GraphQLInputObjectType_fields(fields, build, context) {
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = 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);
+                            return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
+                        }, {});
+                        return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
+                    }
+                    else {
+                        return fields;
+                    }
+                },
+                GraphQLInterfaceType_fields(fields, build, context) {
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { Self } = context;
+                    if (typeExtensions.GraphQLInterfaceType[Self.name]) {
+                        const newFields = typeExtensions.GraphQLInterfaceType[Self.name].reduce((memo, extension) => {
+                            const moreFields = getFields(Self, extension.fields, {}, // No resolvers for interfaces
+                            {}, // No resolvers for interfaces
+                            context, build);
+                            return extend(memo, moreFields, `Adding fields from ${uniquePluginName}`);
+                        }, {});
+                        return extend(fields, newFields, `Adding fields from ${uniquePluginName}`);
+                    }
+                    else {
+                        return fields;
+                    }
+                },
+                GraphQLInterfaceType_interfaces(interfaces, build, context) {
+                    const { extend, makeExtendSchemaPlugin: { [uniquePluginName]: { typeExtensions }, }, } = build;
+                    const { Self } = context;
+                    if (typeExtensions.GraphQLInterfaceType[Self.name]) {
+                        const newInterfaces = typeExtensions.GraphQLInterfaceType[Self.name].reduce((memo, extension) => {
+                            const moreInterfaces = getInterfaces(extension.interfaces, build);
+                            return extend(memo, moreInterfaces, `Adding interfaces from ${uniquePluginName}`);
+                        }, {});
+                        return extend(interfaces, newInterfaces, `Adding interfaces from ${uniquePluginName}`);
+                    }
+                    else {
+                        return interfaces;
+                    }
+                },
+            },
+        },
+    };
+    function getName(name) {
+        if (name && name.kind === "Name" && name.value) {
+            return name.value;
+        }
+        throw new Error("Could not extract name from AST");
+    }
+    function getDescription(desc) {
+        if (!desc) {
+            return null;
+        }
+        else if (desc.kind === "StringValue") {
+            return desc.value;
+        }
+        else {
+            throw new Error(`AST issue, we weren't expecting a description of kind '${desc.kind}' - PRs welcome!`);
+        }
+    }
+    function getType(type, build) {
+        if (type.kind === "NamedType") {
+            const Type = build.getTypeByName(getName(type.name));
+            if (!Type) {
+                throw new Error(`Could not find type named '${getName(type.name)}'.`);
+            }
+            return Type;
+        }
+        else if (type.kind === "NonNullType") {
+            return new build.graphql.GraphQLNonNull(getType(type.type, build));
+        }
+        else if (type.kind === "ListType") {
+            return new build.graphql.GraphQLList(getType(type.type, build));
+        }
+        else {
+            throw new Error(`We don't support AST type definition of kind '${type.kind}' yet... PRs welcome!`);
+        }
+    }
+    function getInterfaces(interfaces, build) {
+        if (!interfaces)
+            return [];
+        return interfaces.map((i) => build.getTypeByName(i.name.value));
+    }
+    function getValue(value, inType) {
+        const type = inType && graphql.isNonNullType(inType) ? inType.ofType : inType;
+        if (value.kind === "BooleanValue") {
+            return !!value.value;
+        }
+        else if (value.kind === "StringValue") {
+            return value.value;
+        }
+        else if (value.kind === "IntValue") {
+            return parseInt(value.value, 10);
+        }
+        else if (value.kind === "FloatValue") {
+            return parseFloat(value.value);
+        }
+        else if (value.kind === "EnumValue") {
+            if (!type) {
+                throw new Error("We do not support EnumValue arguments in directives at this time");
+            }
+            const enumValueName = value.value;
+            const enumType = graphql.isEnumType(type)
+                ? type
+                : null;
+            if (!enumType) {
+                throw new Error(`Tried to interpret an EnumValue for non-enum type ${type}`);
+            }
+            const values = enumType.getValues();
+            const enumValue = values.find((v) => v.name === enumValueName);
+            return enumValue ? enumValue.value : undefined;
+        }
+        else if (value.kind === "NullValue") {
+            return null;
+        }
+        else if (value.kind === "ListValue") {
+            // This is used in directives, so we cannot assume the type is known.
+            const childType = type && graphql.isListType(type) ? type.ofType : null;
+            return value.values.map((value) => getValue(value, childType));
+        }
+        else {
+            throw new Error(`Value kind '${value.kind}' not supported yet. PRs welcome!`);
+        }
+    }
+    function getDirectives(directives) {
+        return (directives || []).reduce((directivesList, directive) => {
+            if (directive.kind !== "Directive") {
+                throw new Error(`Unexpected '${directive.kind}', we were expecting 'Directive'`);
+            }
+            const name = getName(directive.name);
+            const value = (directive.arguments || []).reduce((argumentValues, arg) => {
+                if (arg.kind === "Argument") {
+                    const argName = getName(arg.name);
+                    const argValue = getValue(arg.value);
+                    if (argumentValues[name]) {
+                        throw new Error(`Argument '${argName}' of directive '${name}' must only be used once.`);
+                    }
+                    argumentValues[argName] = argValue;
+                }
+                else {
+                    throw new Error(`Unexpected '${arg.kind}', we were expecting 'Argument'`);
+                }
+                return argumentValues;
+            }, Object.create(null));
+            directivesList.push({ directiveName: name, args: value });
+            return directivesList;
+        }, []);
+    }
+    function getArguments(args, build) {
+        if (args && args.length) {
+            return args.reduce((memo, arg) => {
+                if (arg.kind === "InputValueDefinition") {
+                    const name = getName(arg.name);
+                    const type = getType(arg.type, build);
+                    const description = getDescription(arg.description);
+                    let defaultValue;
+                    if (arg.defaultValue) {
+                        defaultValue = getValue(arg.defaultValue, type);
+                    }
+                    memo[name] = {
+                        type,
+                        ...(defaultValue != null ? { defaultValue } : null),
+                        ...(description ? { description } : null),
+                    };
+                }
+                else {
+                    throw new Error(`Unexpected '${arg.kind}', we were expecting an 'InputValueDefinition'`);
+                }
+                return memo;
+            }, {});
+        }
+        return {};
+    }
+    function getFields(SelfGeneric, fields, resolvers, plans, { fieldWithHooks, }, build) {
+        if (!build.graphql.isNamedType(SelfGeneric)) {
+            throw new Error("getFields only supports named types");
+        }
+        const Self = SelfGeneric;
+        if (fields && fields.length) {
+            return fields.reduce((memo, field) => {
+                if (field.kind === "FieldDefinition") {
+                    const description = getDescription(field.description);
+                    const fieldName = getName(field.name);
+                    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;
+                    const functionToResolveObject = (functionOrResolveObject) => typeof functionOrResolveObject === "function"
+                        ? { resolve: functionOrResolveObject }
+                        : functionOrResolveObject;
+                    /*
+                     * We accept a resolver function directly, or an object which can
+                     * define 'resolve', 'subscribe' and other relevant methods.
+                     */
+                    const possiblePlan = plans[Self.name]?.[fieldName];
+                    const possibleResolver = resolvers[Self.name]
+                        ? resolvers[Self.name][fieldName]
+                        : null;
+                    const resolver = possibleResolver &&
+                        (typeof possibleResolver === "object" ||
+                            typeof possibleResolver === "function")
+                        ? possibleResolver
+                        : null;
+                    const rawResolversSpec = resolver
+                        ? functionToResolveObject(resolver)
+                        : null;
+                    const fieldSpecGenerator = () => {
+                        const resolversSpec = rawResolversSpec;
+                        return {
+                            type: type,
+                            args,
+                            ...(deprecationReason
+                                ? {
+                                    deprecationReason,
+                                }
+                                : null),
+                            ...(description
+                                ? {
+                                    description,
+                                }
+                                : null),
+                            ...resolversSpec,
+                            ...(possiblePlan
+                                ? { plan: possiblePlan }
+                                : null),
+                        };
+                    };
+                    return build.extend(memo, {
+                        [fieldName]: fieldWithHooks(scope, fieldSpecGenerator),
+                    }, `Adding '${fieldName}' to '${Self.name}' from '${uniquePluginName}'`);
+                }
+                else {
+                    throw new Error(`AST issue: expected 'FieldDefinition', instead received '${field.kind}'`);
+                }
+            }, {});
+        }
+        return {};
+    }
+    function getInputFields(_Self, fields, build) {
+        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 defaultValue = field.defaultValue
+                        ? getValue(field.defaultValue, type)
+                        : undefined;
+                    memo[fieldName] = {
+                        type,
+                        defaultValue,
+                        ...(description
+                            ? {
+                                description,
+                            }
+                            : null),
+                    };
+                }
+                else {
+                    throw new Error(`AST issue: expected 'FieldDefinition', instead received '${field.kind}'`);
+                }
+                return memo;
+            }, {});
+        }
+        return {};
+    }
+}
+exports.makeExtendSchemaPlugin = makeExtendSchemaPlugin;
+function scopeFromDirectives(directives) {
+    return {
+        ...directives
+            .filter((d) => d.directiveName === "scope")
+            .map((d) => d.args)
+            .reduce((memo, a) => Object.assign(memo, a), Object.create(null)),
+    };
+}
+//# sourceMappingURL=makeExtendSchemaPlugin.js.map