Initialisation

Added the packages and files for the backend server

node_modules/@graphql-tools/schema/README.md

@@ -0,0 +1,5 @@
+Check API Reference for more information about this package;
+https://www.graphql-tools.com/docs/api/modules/schema_src
+
+You can also learn more about Generating Executable Schemas in this chapter;
+https://www.graphql-tools.com/docs/generate-schema

node_modules/@graphql-tools/schema/cjs/addResolversToSchema.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addResolversToSchema = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const checkForResolveTypeResolver_js_1 = require("./checkForResolveTypeResolver.js");
+const extendResolversFromInterfaces_js_1 = require("./extendResolversFromInterfaces.js");
+function addResolversToSchema({ schema, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false, }) {
+    const { requireResolversToMatchSchema = 'error', requireResolversForResolveType } = resolverValidationOptions;
+    const resolvers = inheritResolversFromInterfaces
+        ? (0, extendResolversFromInterfaces_js_1.extendResolversFromInterfaces)(schema, inputResolvers)
+        : inputResolvers;
+    for (const typeName in resolvers) {
+        const resolverValue = resolvers[typeName];
+        const resolverType = typeof resolverValue;
+        if (resolverType !== 'object') {
+            throw new Error(`"${typeName}" defined in resolvers, but has invalid value "${resolverValue}". The resolver's value must be of type object.`);
+        }
+        const type = schema.getType(typeName);
+        if (type == null) {
+            if (requireResolversToMatchSchema === 'ignore') {
+                continue;
+            }
+            throw new Error(`"${typeName}" defined in resolvers, but not in schema`);
+        }
+        else if ((0, graphql_1.isSpecifiedScalarType)(type)) {
+            // allow -- without recommending -- overriding of specified scalar types
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else {
+                    type[fieldName] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if ((0, graphql_1.isEnumType)(type)) {
+            const values = type.getValues();
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__') &&
+                    !values.some(value => value.name === fieldName) &&
+                    requireResolversToMatchSchema &&
+                    requireResolversToMatchSchema !== 'ignore') {
+                    throw new Error(`${type.name}.${fieldName} was defined in resolvers, but not present within ${type.name}`);
+                }
+            }
+        }
+        else if ((0, graphql_1.isUnionType)(type)) {
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__') &&
+                    requireResolversToMatchSchema &&
+                    requireResolversToMatchSchema !== 'ignore') {
+                    throw new Error(`${type.name}.${fieldName} was defined in resolvers, but ${type.name} is not an object or interface type`);
+                }
+            }
+        }
+        else if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__')) {
+                    const fields = type.getFields();
+                    const field = fields[fieldName];
+                    if (field == null) {
+                        // Field present in resolver but not in schema
+                        if (requireResolversToMatchSchema && requireResolversToMatchSchema !== 'ignore') {
+                            throw new Error(`${typeName}.${fieldName} defined in resolvers, but not in schema`);
+                        }
+                    }
+                    else {
+                        // Field present in both the resolver and schema
+                        const fieldResolve = resolverValue[fieldName];
+                        if (typeof fieldResolve !== 'function' && typeof fieldResolve !== 'object') {
+                            throw new Error(`Resolver ${typeName}.${fieldName} must be object or function`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    schema = updateResolversInPlace
+        ? addResolversToExistingSchema(schema, resolvers, defaultFieldResolver)
+        : createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver);
+    if (requireResolversForResolveType && requireResolversForResolveType !== 'ignore') {
+        (0, checkForResolveTypeResolver_js_1.checkForResolveTypeResolver)(schema, requireResolversForResolveType);
+    }
+    return schema;
+}
+exports.addResolversToSchema = addResolversToSchema;
+function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const typeMap = schema.getTypeMap();
+    for (const typeName in resolvers) {
+        const type = schema.getType(typeName);
+        const resolverValue = resolvers[typeName];
+        if ((0, graphql_1.isScalarType)(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else if (fieldName === 'astNode' && type.astNode != null) {
+                    type.astNode = {
+                        ...type.astNode,
+                        description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.astNode.description,
+                        directives: ((_c = type.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                    };
+                }
+                else if (fieldName === 'extensionASTNodes' && type.extensionASTNodes != null) {
+                    type.extensionASTNodes = type.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                }
+                else if (fieldName === 'extensions' &&
+                    type.extensions != null &&
+                    resolverValue.extensions != null) {
+                    type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                }
+                else {
+                    type[fieldName] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if ((0, graphql_1.isEnumType)(type)) {
+            const config = type.toConfig();
+            const enumValueConfigMap = config.values;
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    config[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else if (fieldName === 'astNode' && config.astNode != null) {
+                    config.astNode = {
+                        ...config.astNode,
+                        description: (_h = (_g = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _g === void 0 ? void 0 : _g.description) !== null && _h !== void 0 ? _h : config.astNode.description,
+                        directives: ((_j = config.astNode.directives) !== null && _j !== void 0 ? _j : []).concat((_l = (_k = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _k === void 0 ? void 0 : _k.directives) !== null && _l !== void 0 ? _l : []),
+                    };
+                }
+                else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                    config.extensionASTNodes = config.extensionASTNodes.concat((_m = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _m !== void 0 ? _m : []);
+                }
+                else if (fieldName === 'extensions' &&
+                    type.extensions != null &&
+                    resolverValue.extensions != null) {
+                    type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                }
+                else if (enumValueConfigMap[fieldName]) {
+                    enumValueConfigMap[fieldName].value = resolverValue[fieldName];
+                }
+            }
+            typeMap[typeName] = new graphql_1.GraphQLEnumType(config);
+        }
+        else if ((0, graphql_1.isUnionType)(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    // this is for isTypeOf and resolveType and all the other stuff.
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                    continue;
+                }
+                const fields = type.getFields();
+                const field = fields[fieldName];
+                if (field != null) {
+                    const fieldResolve = resolverValue[fieldName];
+                    if (typeof fieldResolve === 'function') {
+                        // for convenience. Allows shorter syntax in resolver definition file
+                        field.resolve = fieldResolve.bind(resolverValue);
+                    }
+                    else {
+                        setFieldProperties(field, fieldResolve);
+                    }
+                }
+            }
+        }
+    }
+    // serialize all default values prior to healing fields with new scalar/enum types.
+    (0, utils_1.forEachDefaultValue)(schema, utils_1.serializeInputValue);
+    // schema may have new scalar/enum types that require healing
+    (0, utils_1.healSchema)(schema);
+    // reparse all default values with new parsing functions.
+    (0, utils_1.forEachDefaultValue)(schema, utils_1.parseInputValue);
+    if (defaultFieldResolver != null) {
+        (0, utils_1.forEachField)(schema, field => {
+            if (!field.resolve) {
+                field.resolve = defaultFieldResolver;
+            }
+        });
+    }
+    return schema;
+}
+function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
+    schema = (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.SCALAR_TYPE]: type => {
+            var _a, _b, _c, _d, _e, _f;
+            const config = type.toConfig();
+            const resolverValue = resolvers[type.name];
+            if (!(0, graphql_1.isSpecifiedScalarType)(type) && resolverValue != null) {
+                for (const fieldName in resolverValue) {
+                    if (fieldName.startsWith('__')) {
+                        config[fieldName.substring(2)] = resolverValue[fieldName];
+                    }
+                    else if (fieldName === 'astNode' && config.astNode != null) {
+                        config.astNode = {
+                            ...config.astNode,
+                            description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : config.astNode.description,
+                            directives: ((_c = config.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                        };
+                    }
+                    else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                        config.extensionASTNodes = config.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                    }
+                    else if (fieldName === 'extensions' &&
+                        config.extensions != null &&
+                        resolverValue.extensions != null) {
+                        config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                    }
+                    else {
+                        config[fieldName] = resolverValue[fieldName];
+                    }
+                }
+                return new graphql_1.GraphQLScalarType(config);
+            }
+        },
+        [utils_1.MapperKind.ENUM_TYPE]: type => {
+            var _a, _b, _c, _d, _e, _f;
+            const resolverValue = resolvers[type.name];
+            const config = type.toConfig();
+            const enumValueConfigMap = config.values;
+            if (resolverValue != null) {
+                for (const fieldName in resolverValue) {
+                    if (fieldName.startsWith('__')) {
+                        config[fieldName.substring(2)] = resolverValue[fieldName];
+                    }
+                    else if (fieldName === 'astNode' && config.astNode != null) {
+                        config.astNode = {
+                            ...config.astNode,
+                            description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : config.astNode.description,
+                            directives: ((_c = config.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                        };
+                    }
+                    else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                        config.extensionASTNodes = config.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                    }
+                    else if (fieldName === 'extensions' &&
+                        config.extensions != null &&
+                        resolverValue.extensions != null) {
+                        config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                    }
+                    else if (enumValueConfigMap[fieldName]) {
+                        enumValueConfigMap[fieldName].value = resolverValue[fieldName];
+                    }
+                }
+                return new graphql_1.GraphQLEnumType(config);
+            }
+        },
+        [utils_1.MapperKind.UNION_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__resolveType']) {
+                    config.resolveType = resolverValue['__resolveType'];
+                }
+                return new graphql_1.GraphQLUnionType(config);
+            }
+        },
+        [utils_1.MapperKind.OBJECT_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__isTypeOf']) {
+                    config.isTypeOf = resolverValue['__isTypeOf'];
+                }
+                return new graphql_1.GraphQLObjectType(config);
+            }
+        },
+        [utils_1.MapperKind.INTERFACE_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__resolveType']) {
+                    config.resolveType = resolverValue['__resolveType'];
+                }
+                return new graphql_1.GraphQLInterfaceType(config);
+            }
+        },
+        [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+            const resolverValue = resolvers[typeName];
+            if (resolverValue != null) {
+                const fieldResolve = resolverValue[fieldName];
+                if (fieldResolve != null) {
+                    const newFieldConfig = { ...fieldConfig };
+                    if (typeof fieldResolve === 'function') {
+                        // for convenience. Allows shorter syntax in resolver definition file
+                        newFieldConfig.resolve = fieldResolve.bind(resolverValue);
+                    }
+                    else {
+                        setFieldProperties(newFieldConfig, fieldResolve);
+                    }
+                    return newFieldConfig;
+                }
+            }
+        },
+    });
+    if (defaultFieldResolver != null) {
+        schema = (0, utils_1.mapSchema)(schema, {
+            [utils_1.MapperKind.OBJECT_FIELD]: fieldConfig => ({
+                ...fieldConfig,
+                resolve: fieldConfig.resolve != null ? fieldConfig.resolve : defaultFieldResolver,
+            }),
+        });
+    }
+    return schema;
+}
+function setFieldProperties(field, propertiesObj) {
+    for (const propertyName in propertiesObj) {
+        field[propertyName] = propertiesObj[propertyName];
+    }
+}

node_modules/@graphql-tools/schema/cjs/assertResolversPresent.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertResolversPresent = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+function assertResolversPresent(schema, resolverValidationOptions = {}) {
+    const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions;
+    if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) {
+        throw new TypeError('requireResolversForAllFields takes precedence over the more specific assertions. ' +
+            'Please configure either requireResolversForAllFields or requireResolversForArgs / ' +
+            'requireResolversForNonScalar, but not a combination of them.');
+    }
+    (0, utils_1.forEachField)(schema, (field, typeName, fieldName) => {
+        // requires a resolver for *every* field.
+        if (requireResolversForAllFields) {
+            expectResolver('requireResolversForAllFields', requireResolversForAllFields, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that has arguments
+        if (requireResolversForArgs && field.args.length > 0) {
+            expectResolver('requireResolversForArgs', requireResolversForArgs, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that returns a non-scalar type
+        if (requireResolversForNonScalar !== 'ignore' && !(0, graphql_1.isScalarType)((0, graphql_1.getNamedType)(field.type))) {
+            expectResolver('requireResolversForNonScalar', requireResolversForNonScalar, field, typeName, fieldName);
+        }
+    });
+}
+exports.assertResolversPresent = assertResolversPresent;
+function expectResolver(validator, behavior, field, typeName, fieldName) {
+    if (!field.resolve) {
+        const message = `Resolver missing for "${typeName}.${fieldName}".
+To disable this validator, use:
+  resolverValidationOptions: {
+    ${validator}: 'ignore'
+  }`;
+        if (behavior === 'error') {
+            throw new Error(message);
+        }
+        if (behavior === 'warn') {
+            console.warn(message);
+        }
+        return;
+    }
+    if (typeof field.resolve !== 'function') {
+        throw new Error(`Resolver "${typeName}.${fieldName}" must be a function`);
+    }
+}

node_modules/@graphql-tools/schema/cjs/chainResolvers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainResolvers = void 0;
+const graphql_1 = require("graphql");
+function chainResolvers(resolvers) {
+    return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
+        if (curResolver != null) {
+            return curResolver(prev, args, ctx, info);
+        }
+        return (0, graphql_1.defaultFieldResolver)(prev, args, ctx, info);
+    }, root);
+}
+exports.chainResolvers = chainResolvers;

node_modules/@graphql-tools/schema/cjs/checkForResolveTypeResolver.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForResolveTypeResolver = void 0;
+const utils_1 = require("@graphql-tools/utils");
+// If we have any union or interface types throw if no there is no resolveType resolver
+function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
+    (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+            if (!type.resolveType) {
+                const message = `Type "${type.name}" is missing a "__resolveType" resolver. Pass 'ignore' into ` +
+                    '"resolverValidationOptions.requireResolversForResolveType" to disable this error.';
+                if (requireResolversForResolveType === 'error') {
+                    throw new Error(message);
+                }
+                if (requireResolversForResolveType === 'warn') {
+                    console.warn(message);
+                }
+            }
+            return undefined;
+        },
+    });
+}
+exports.checkForResolveTypeResolver = checkForResolveTypeResolver;

node_modules/@graphql-tools/schema/cjs/extendResolversFromInterfaces.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendResolversFromInterfaces = void 0;
+function extendResolversFromInterfaces(schema, resolvers) {
+    const extendedResolvers = {};
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        if ('getInterfaces' in type) {
+            extendedResolvers[typeName] = {};
+            for (const iFace of type.getInterfaces()) {
+                if (resolvers[iFace.name]) {
+                    for (const fieldName in resolvers[iFace.name]) {
+                        if (fieldName === '__isTypeOf' || !fieldName.startsWith('__')) {
+                            extendedResolvers[typeName][fieldName] = resolvers[iFace.name][fieldName];
+                        }
+                    }
+                }
+            }
+            const typeResolvers = resolvers[typeName];
+            extendedResolvers[typeName] = {
+                ...extendedResolvers[typeName],
+                ...typeResolvers,
+            };
+        }
+        else {
+            const typeResolvers = resolvers[typeName];
+            if (typeResolvers != null) {
+                extendedResolvers[typeName] = typeResolvers;
+            }
+        }
+    }
+    return extendedResolvers;
+}
+exports.extendResolversFromInterfaces = extendResolversFromInterfaces;

node_modules/@graphql-tools/schema/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExtensionsFromSchema = exports.extendResolversFromInterfaces = exports.checkForResolveTypeResolver = exports.addResolversToSchema = exports.chainResolvers = exports.assertResolversPresent = void 0;
+const tslib_1 = require("tslib");
+var assertResolversPresent_js_1 = require("./assertResolversPresent.js");
+Object.defineProperty(exports, "assertResolversPresent", { enumerable: true, get: function () { return assertResolversPresent_js_1.assertResolversPresent; } });
+var chainResolvers_js_1 = require("./chainResolvers.js");
+Object.defineProperty(exports, "chainResolvers", { enumerable: true, get: function () { return chainResolvers_js_1.chainResolvers; } });
+var addResolversToSchema_js_1 = require("./addResolversToSchema.js");
+Object.defineProperty(exports, "addResolversToSchema", { enumerable: true, get: function () { return addResolversToSchema_js_1.addResolversToSchema; } });
+var checkForResolveTypeResolver_js_1 = require("./checkForResolveTypeResolver.js");
+Object.defineProperty(exports, "checkForResolveTypeResolver", { enumerable: true, get: function () { return checkForResolveTypeResolver_js_1.checkForResolveTypeResolver; } });
+var extendResolversFromInterfaces_js_1 = require("./extendResolversFromInterfaces.js");
+Object.defineProperty(exports, "extendResolversFromInterfaces", { enumerable: true, get: function () { return extendResolversFromInterfaces_js_1.extendResolversFromInterfaces; } });
+tslib_1.__exportStar(require("./makeExecutableSchema.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./merge-schemas.js"), exports);
+var utils_1 = require("@graphql-tools/utils");
+Object.defineProperty(exports, "extractExtensionsFromSchema", { enumerable: true, get: function () { return utils_1.extractExtensionsFromSchema; } });

node_modules/@graphql-tools/schema/cjs/makeExecutableSchema.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExecutableSchema = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const addResolversToSchema_js_1 = require("./addResolversToSchema.js");
+const assertResolversPresent_js_1 = require("./assertResolversPresent.js");
+const merge_1 = require("@graphql-tools/merge");
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use GraphQL magic comment provide additional syntax
+ * highlighting in your editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = /* GraphQL *\/ `
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
+function makeExecutableSchema({ typeDefs, resolvers = {}, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false, schemaExtensions, ...otherOptions }) {
+    // Validate and clean up arguments
+    if (typeof resolverValidationOptions !== 'object') {
+        throw new Error('Expected `resolverValidationOptions` to be an object');
+    }
+    if (!typeDefs) {
+        throw new Error('Must provide typeDefs');
+    }
+    let schema;
+    if ((0, graphql_1.isSchema)(typeDefs)) {
+        schema = typeDefs;
+    }
+    else if (otherOptions === null || otherOptions === void 0 ? void 0 : otherOptions.commentDescriptions) {
+        const mergedTypeDefs = (0, merge_1.mergeTypeDefs)(typeDefs, {
+            ...otherOptions,
+            commentDescriptions: true,
+        });
+        schema = (0, graphql_1.buildSchema)(mergedTypeDefs, otherOptions);
+    }
+    else {
+        const mergedTypeDefs = (0, merge_1.mergeTypeDefs)(typeDefs, otherOptions);
+        schema = (0, graphql_1.buildASTSchema)(mergedTypeDefs, otherOptions);
+    }
+    // We allow passing in an array of resolver maps, in which case we merge them
+    schema = (0, addResolversToSchema_js_1.addResolversToSchema)({
+        schema,
+        resolvers: (0, merge_1.mergeResolvers)(resolvers),
+        resolverValidationOptions,
+        inheritResolversFromInterfaces,
+        updateResolversInPlace,
+    });
+    if (Object.keys(resolverValidationOptions).length > 0) {
+        (0, assertResolversPresent_js_1.assertResolversPresent)(schema, resolverValidationOptions);
+    }
+    if (schemaExtensions) {
+        schemaExtensions = (0, merge_1.mergeExtensions)((0, utils_1.asArray)(schemaExtensions));
+        (0, merge_1.applyExtensions)(schema, schemaExtensions);
+    }
+    return schema;
+}
+exports.makeExecutableSchema = makeExecutableSchema;

node_modules/@graphql-tools/schema/cjs/merge-schemas.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemas = void 0;
+const utils_1 = require("@graphql-tools/utils");
+const makeExecutableSchema_js_1 = require("./makeExecutableSchema.js");
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+function mergeSchemas(config) {
+    const extractedTypeDefs = [];
+    const extractedResolvers = [];
+    const extractedSchemaExtensions = [];
+    if (config.schemas != null) {
+        for (const schema of config.schemas) {
+            extractedTypeDefs.push(schema);
+            extractedResolvers.push((0, utils_1.getResolversFromSchema)(schema));
+            extractedSchemaExtensions.push((0, utils_1.extractExtensionsFromSchema)(schema));
+        }
+    }
+    if (config.typeDefs != null) {
+        extractedTypeDefs.push(config.typeDefs);
+    }
+    if (config.resolvers != null) {
+        const additionalResolvers = (0, utils_1.asArray)(config.resolvers);
+        extractedResolvers.push(...additionalResolvers);
+    }
+    if (config.schemaExtensions != null) {
+        const additionalSchemaExtensions = (0, utils_1.asArray)(config.schemaExtensions);
+        extractedSchemaExtensions.push(...additionalSchemaExtensions);
+    }
+    return (0, makeExecutableSchema_js_1.makeExecutableSchema)({
+        ...config,
+        typeDefs: extractedTypeDefs,
+        resolvers: extractedResolvers,
+        schemaExtensions: extractedSchemaExtensions,
+    });
+}
+exports.mergeSchemas = mergeSchemas;

node_modules/@graphql-tools/schema/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

node_modules/@graphql-tools/schema/esm/addResolversToSchema.js

@@ -0,0 +1,314 @@
+import { GraphQLEnumType, GraphQLScalarType, GraphQLUnionType, GraphQLInterfaceType, GraphQLObjectType, isSpecifiedScalarType, isScalarType, isEnumType, isUnionType, isInterfaceType, isObjectType, } from 'graphql';
+import { mapSchema, MapperKind, forEachDefaultValue, serializeInputValue, healSchema, parseInputValue, forEachField, } from '@graphql-tools/utils';
+import { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
+import { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
+export function addResolversToSchema({ schema, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false, }) {
+    const { requireResolversToMatchSchema = 'error', requireResolversForResolveType } = resolverValidationOptions;
+    const resolvers = inheritResolversFromInterfaces
+        ? extendResolversFromInterfaces(schema, inputResolvers)
+        : inputResolvers;
+    for (const typeName in resolvers) {
+        const resolverValue = resolvers[typeName];
+        const resolverType = typeof resolverValue;
+        if (resolverType !== 'object') {
+            throw new Error(`"${typeName}" defined in resolvers, but has invalid value "${resolverValue}". The resolver's value must be of type object.`);
+        }
+        const type = schema.getType(typeName);
+        if (type == null) {
+            if (requireResolversToMatchSchema === 'ignore') {
+                continue;
+            }
+            throw new Error(`"${typeName}" defined in resolvers, but not in schema`);
+        }
+        else if (isSpecifiedScalarType(type)) {
+            // allow -- without recommending -- overriding of specified scalar types
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else {
+                    type[fieldName] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if (isEnumType(type)) {
+            const values = type.getValues();
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__') &&
+                    !values.some(value => value.name === fieldName) &&
+                    requireResolversToMatchSchema &&
+                    requireResolversToMatchSchema !== 'ignore') {
+                    throw new Error(`${type.name}.${fieldName} was defined in resolvers, but not present within ${type.name}`);
+                }
+            }
+        }
+        else if (isUnionType(type)) {
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__') &&
+                    requireResolversToMatchSchema &&
+                    requireResolversToMatchSchema !== 'ignore') {
+                    throw new Error(`${type.name}.${fieldName} was defined in resolvers, but ${type.name} is not an object or interface type`);
+                }
+            }
+        }
+        else if (isObjectType(type) || isInterfaceType(type)) {
+            for (const fieldName in resolverValue) {
+                if (!fieldName.startsWith('__')) {
+                    const fields = type.getFields();
+                    const field = fields[fieldName];
+                    if (field == null) {
+                        // Field present in resolver but not in schema
+                        if (requireResolversToMatchSchema && requireResolversToMatchSchema !== 'ignore') {
+                            throw new Error(`${typeName}.${fieldName} defined in resolvers, but not in schema`);
+                        }
+                    }
+                    else {
+                        // Field present in both the resolver and schema
+                        const fieldResolve = resolverValue[fieldName];
+                        if (typeof fieldResolve !== 'function' && typeof fieldResolve !== 'object') {
+                            throw new Error(`Resolver ${typeName}.${fieldName} must be object or function`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    schema = updateResolversInPlace
+        ? addResolversToExistingSchema(schema, resolvers, defaultFieldResolver)
+        : createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver);
+    if (requireResolversForResolveType && requireResolversForResolveType !== 'ignore') {
+        checkForResolveTypeResolver(schema, requireResolversForResolveType);
+    }
+    return schema;
+}
+function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const typeMap = schema.getTypeMap();
+    for (const typeName in resolvers) {
+        const type = schema.getType(typeName);
+        const resolverValue = resolvers[typeName];
+        if (isScalarType(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else if (fieldName === 'astNode' && type.astNode != null) {
+                    type.astNode = {
+                        ...type.astNode,
+                        description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.astNode.description,
+                        directives: ((_c = type.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                    };
+                }
+                else if (fieldName === 'extensionASTNodes' && type.extensionASTNodes != null) {
+                    type.extensionASTNodes = type.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                }
+                else if (fieldName === 'extensions' &&
+                    type.extensions != null &&
+                    resolverValue.extensions != null) {
+                    type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                }
+                else {
+                    type[fieldName] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if (isEnumType(type)) {
+            const config = type.toConfig();
+            const enumValueConfigMap = config.values;
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    config[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+                else if (fieldName === 'astNode' && config.astNode != null) {
+                    config.astNode = {
+                        ...config.astNode,
+                        description: (_h = (_g = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _g === void 0 ? void 0 : _g.description) !== null && _h !== void 0 ? _h : config.astNode.description,
+                        directives: ((_j = config.astNode.directives) !== null && _j !== void 0 ? _j : []).concat((_l = (_k = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _k === void 0 ? void 0 : _k.directives) !== null && _l !== void 0 ? _l : []),
+                    };
+                }
+                else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                    config.extensionASTNodes = config.extensionASTNodes.concat((_m = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _m !== void 0 ? _m : []);
+                }
+                else if (fieldName === 'extensions' &&
+                    type.extensions != null &&
+                    resolverValue.extensions != null) {
+                    type.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                }
+                else if (enumValueConfigMap[fieldName]) {
+                    enumValueConfigMap[fieldName].value = resolverValue[fieldName];
+                }
+            }
+            typeMap[typeName] = new GraphQLEnumType(config);
+        }
+        else if (isUnionType(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                }
+            }
+        }
+        else if (isObjectType(type) || isInterfaceType(type)) {
+            for (const fieldName in resolverValue) {
+                if (fieldName.startsWith('__')) {
+                    // this is for isTypeOf and resolveType and all the other stuff.
+                    type[fieldName.substring(2)] = resolverValue[fieldName];
+                    continue;
+                }
+                const fields = type.getFields();
+                const field = fields[fieldName];
+                if (field != null) {
+                    const fieldResolve = resolverValue[fieldName];
+                    if (typeof fieldResolve === 'function') {
+                        // for convenience. Allows shorter syntax in resolver definition file
+                        field.resolve = fieldResolve.bind(resolverValue);
+                    }
+                    else {
+                        setFieldProperties(field, fieldResolve);
+                    }
+                }
+            }
+        }
+    }
+    // serialize all default values prior to healing fields with new scalar/enum types.
+    forEachDefaultValue(schema, serializeInputValue);
+    // schema may have new scalar/enum types that require healing
+    healSchema(schema);
+    // reparse all default values with new parsing functions.
+    forEachDefaultValue(schema, parseInputValue);
+    if (defaultFieldResolver != null) {
+        forEachField(schema, field => {
+            if (!field.resolve) {
+                field.resolve = defaultFieldResolver;
+            }
+        });
+    }
+    return schema;
+}
+function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
+    schema = mapSchema(schema, {
+        [MapperKind.SCALAR_TYPE]: type => {
+            var _a, _b, _c, _d, _e, _f;
+            const config = type.toConfig();
+            const resolverValue = resolvers[type.name];
+            if (!isSpecifiedScalarType(type) && resolverValue != null) {
+                for (const fieldName in resolverValue) {
+                    if (fieldName.startsWith('__')) {
+                        config[fieldName.substring(2)] = resolverValue[fieldName];
+                    }
+                    else if (fieldName === 'astNode' && config.astNode != null) {
+                        config.astNode = {
+                            ...config.astNode,
+                            description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : config.astNode.description,
+                            directives: ((_c = config.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                        };
+                    }
+                    else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                        config.extensionASTNodes = config.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                    }
+                    else if (fieldName === 'extensions' &&
+                        config.extensions != null &&
+                        resolverValue.extensions != null) {
+                        config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                    }
+                    else {
+                        config[fieldName] = resolverValue[fieldName];
+                    }
+                }
+                return new GraphQLScalarType(config);
+            }
+        },
+        [MapperKind.ENUM_TYPE]: type => {
+            var _a, _b, _c, _d, _e, _f;
+            const resolverValue = resolvers[type.name];
+            const config = type.toConfig();
+            const enumValueConfigMap = config.values;
+            if (resolverValue != null) {
+                for (const fieldName in resolverValue) {
+                    if (fieldName.startsWith('__')) {
+                        config[fieldName.substring(2)] = resolverValue[fieldName];
+                    }
+                    else if (fieldName === 'astNode' && config.astNode != null) {
+                        config.astNode = {
+                            ...config.astNode,
+                            description: (_b = (_a = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : config.astNode.description,
+                            directives: ((_c = config.astNode.directives) !== null && _c !== void 0 ? _c : []).concat((_e = (_d = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.astNode) === null || _d === void 0 ? void 0 : _d.directives) !== null && _e !== void 0 ? _e : []),
+                        };
+                    }
+                    else if (fieldName === 'extensionASTNodes' && config.extensionASTNodes != null) {
+                        config.extensionASTNodes = config.extensionASTNodes.concat((_f = resolverValue === null || resolverValue === void 0 ? void 0 : resolverValue.extensionASTNodes) !== null && _f !== void 0 ? _f : []);
+                    }
+                    else if (fieldName === 'extensions' &&
+                        config.extensions != null &&
+                        resolverValue.extensions != null) {
+                        config.extensions = Object.assign(Object.create(null), type.extensions, resolverValue.extensions);
+                    }
+                    else if (enumValueConfigMap[fieldName]) {
+                        enumValueConfigMap[fieldName].value = resolverValue[fieldName];
+                    }
+                }
+                return new GraphQLEnumType(config);
+            }
+        },
+        [MapperKind.UNION_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__resolveType']) {
+                    config.resolveType = resolverValue['__resolveType'];
+                }
+                return new GraphQLUnionType(config);
+            }
+        },
+        [MapperKind.OBJECT_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__isTypeOf']) {
+                    config.isTypeOf = resolverValue['__isTypeOf'];
+                }
+                return new GraphQLObjectType(config);
+            }
+        },
+        [MapperKind.INTERFACE_TYPE]: type => {
+            const resolverValue = resolvers[type.name];
+            if (resolverValue != null) {
+                const config = type.toConfig();
+                if (resolverValue['__resolveType']) {
+                    config.resolveType = resolverValue['__resolveType'];
+                }
+                return new GraphQLInterfaceType(config);
+            }
+        },
+        [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+            const resolverValue = resolvers[typeName];
+            if (resolverValue != null) {
+                const fieldResolve = resolverValue[fieldName];
+                if (fieldResolve != null) {
+                    const newFieldConfig = { ...fieldConfig };
+                    if (typeof fieldResolve === 'function') {
+                        // for convenience. Allows shorter syntax in resolver definition file
+                        newFieldConfig.resolve = fieldResolve.bind(resolverValue);
+                    }
+                    else {
+                        setFieldProperties(newFieldConfig, fieldResolve);
+                    }
+                    return newFieldConfig;
+                }
+            }
+        },
+    });
+    if (defaultFieldResolver != null) {
+        schema = mapSchema(schema, {
+            [MapperKind.OBJECT_FIELD]: fieldConfig => ({
+                ...fieldConfig,
+                resolve: fieldConfig.resolve != null ? fieldConfig.resolve : defaultFieldResolver,
+            }),
+        });
+    }
+    return schema;
+}
+function setFieldProperties(field, propertiesObj) {
+    for (const propertyName in propertiesObj) {
+        field[propertyName] = propertiesObj[propertyName];
+    }
+}

node_modules/@graphql-tools/schema/esm/assertResolversPresent.js

@@ -0,0 +1,43 @@
+import { getNamedType, isScalarType } from 'graphql';
+import { forEachField } from '@graphql-tools/utils';
+export function assertResolversPresent(schema, resolverValidationOptions = {}) {
+    const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions;
+    if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) {
+        throw new TypeError('requireResolversForAllFields takes precedence over the more specific assertions. ' +
+            'Please configure either requireResolversForAllFields or requireResolversForArgs / ' +
+            'requireResolversForNonScalar, but not a combination of them.');
+    }
+    forEachField(schema, (field, typeName, fieldName) => {
+        // requires a resolver for *every* field.
+        if (requireResolversForAllFields) {
+            expectResolver('requireResolversForAllFields', requireResolversForAllFields, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that has arguments
+        if (requireResolversForArgs && field.args.length > 0) {
+            expectResolver('requireResolversForArgs', requireResolversForArgs, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that returns a non-scalar type
+        if (requireResolversForNonScalar !== 'ignore' && !isScalarType(getNamedType(field.type))) {
+            expectResolver('requireResolversForNonScalar', requireResolversForNonScalar, field, typeName, fieldName);
+        }
+    });
+}
+function expectResolver(validator, behavior, field, typeName, fieldName) {
+    if (!field.resolve) {
+        const message = `Resolver missing for "${typeName}.${fieldName}".
+To disable this validator, use:
+  resolverValidationOptions: {
+    ${validator}: 'ignore'
+  }`;
+        if (behavior === 'error') {
+            throw new Error(message);
+        }
+        if (behavior === 'warn') {
+            console.warn(message);
+        }
+        return;
+    }
+    if (typeof field.resolve !== 'function') {
+        throw new Error(`Resolver "${typeName}.${fieldName}" must be a function`);
+    }
+}

node_modules/@graphql-tools/schema/esm/chainResolvers.js

@@ -0,0 +1,9 @@
+import { defaultFieldResolver } from 'graphql';
+export function chainResolvers(resolvers) {
+    return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
+        if (curResolver != null) {
+            return curResolver(prev, args, ctx, info);
+        }
+        return defaultFieldResolver(prev, args, ctx, info);
+    }, root);
+}

node_modules/@graphql-tools/schema/esm/checkForResolveTypeResolver.js

@@ -0,0 +1,19 @@
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+// If we have any union or interface types throw if no there is no resolveType resolver
+export function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
+    mapSchema(schema, {
+        [MapperKind.ABSTRACT_TYPE]: type => {
+            if (!type.resolveType) {
+                const message = `Type "${type.name}" is missing a "__resolveType" resolver. Pass 'ignore' into ` +
+                    '"resolverValidationOptions.requireResolversForResolveType" to disable this error.';
+                if (requireResolversForResolveType === 'error') {
+                    throw new Error(message);
+                }
+                if (requireResolversForResolveType === 'warn') {
+                    console.warn(message);
+                }
+            }
+            return undefined;
+        },
+    });
+}

node_modules/@graphql-tools/schema/esm/extendResolversFromInterfaces.js

@@ -0,0 +1,31 @@
+export function extendResolversFromInterfaces(schema, resolvers) {
+    const extendedResolvers = {};
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        if ('getInterfaces' in type) {
+            extendedResolvers[typeName] = {};
+            for (const iFace of type.getInterfaces()) {
+                if (resolvers[iFace.name]) {
+                    for (const fieldName in resolvers[iFace.name]) {
+                        if (fieldName === '__isTypeOf' || !fieldName.startsWith('__')) {
+                            extendedResolvers[typeName][fieldName] = resolvers[iFace.name][fieldName];
+                        }
+                    }
+                }
+            }
+            const typeResolvers = resolvers[typeName];
+            extendedResolvers[typeName] = {
+                ...extendedResolvers[typeName],
+                ...typeResolvers,
+            };
+        }
+        else {
+            const typeResolvers = resolvers[typeName];
+            if (typeResolvers != null) {
+                extendedResolvers[typeName] = typeResolvers;
+            }
+        }
+    }
+    return extendedResolvers;
+}

node_modules/@graphql-tools/schema/esm/index.js

@@ -0,0 +1,9 @@
+export { assertResolversPresent } from './assertResolversPresent.js';
+export { chainResolvers } from './chainResolvers.js';
+export { addResolversToSchema } from './addResolversToSchema.js';
+export { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
+export { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
+export * from './makeExecutableSchema.js';
+export * from './types.js';
+export * from './merge-schemas.js';
+export { extractExtensionsFromSchema } from '@graphql-tools/utils';

node_modules/@graphql-tools/schema/esm/makeExecutableSchema.js

@@ -0,0 +1,88 @@
+import { buildASTSchema, buildSchema, isSchema } from 'graphql';
+import { asArray } from '@graphql-tools/utils';
+import { addResolversToSchema } from './addResolversToSchema.js';
+import { assertResolversPresent } from './assertResolversPresent.js';
+import { applyExtensions, mergeExtensions, mergeResolvers, mergeTypeDefs } from '@graphql-tools/merge';
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use GraphQL magic comment provide additional syntax
+ * highlighting in your editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = /* GraphQL *\/ `
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
+export function makeExecutableSchema({ typeDefs, resolvers = {}, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false, schemaExtensions, ...otherOptions }) {
+    // Validate and clean up arguments
+    if (typeof resolverValidationOptions !== 'object') {
+        throw new Error('Expected `resolverValidationOptions` to be an object');
+    }
+    if (!typeDefs) {
+        throw new Error('Must provide typeDefs');
+    }
+    let schema;
+    if (isSchema(typeDefs)) {
+        schema = typeDefs;
+    }
+    else if (otherOptions === null || otherOptions === void 0 ? void 0 : otherOptions.commentDescriptions) {
+        const mergedTypeDefs = mergeTypeDefs(typeDefs, {
+            ...otherOptions,
+            commentDescriptions: true,
+        });
+        schema = buildSchema(mergedTypeDefs, otherOptions);
+    }
+    else {
+        const mergedTypeDefs = mergeTypeDefs(typeDefs, otherOptions);
+        schema = buildASTSchema(mergedTypeDefs, otherOptions);
+    }
+    // We allow passing in an array of resolver maps, in which case we merge them
+    schema = addResolversToSchema({
+        schema,
+        resolvers: mergeResolvers(resolvers),
+        resolverValidationOptions,
+        inheritResolversFromInterfaces,
+        updateResolversInPlace,
+    });
+    if (Object.keys(resolverValidationOptions).length > 0) {
+        assertResolversPresent(schema, resolverValidationOptions);
+    }
+    if (schemaExtensions) {
+        schemaExtensions = mergeExtensions(asArray(schemaExtensions));
+        applyExtensions(schema, schemaExtensions);
+    }
+    return schema;
+}

node_modules/@graphql-tools/schema/esm/merge-schemas.js

@@ -0,0 +1,35 @@
+import { asArray, getResolversFromSchema, extractExtensionsFromSchema, } from '@graphql-tools/utils';
+import { makeExecutableSchema } from './makeExecutableSchema.js';
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+export function mergeSchemas(config) {
+    const extractedTypeDefs = [];
+    const extractedResolvers = [];
+    const extractedSchemaExtensions = [];
+    if (config.schemas != null) {
+        for (const schema of config.schemas) {
+            extractedTypeDefs.push(schema);
+            extractedResolvers.push(getResolversFromSchema(schema));
+            extractedSchemaExtensions.push(extractExtensionsFromSchema(schema));
+        }
+    }
+    if (config.typeDefs != null) {
+        extractedTypeDefs.push(config.typeDefs);
+    }
+    if (config.resolvers != null) {
+        const additionalResolvers = asArray(config.resolvers);
+        extractedResolvers.push(...additionalResolvers);
+    }
+    if (config.schemaExtensions != null) {
+        const additionalSchemaExtensions = asArray(config.schemaExtensions);
+        extractedSchemaExtensions.push(...additionalSchemaExtensions);
+    }
+    return makeExecutableSchema({
+        ...config,
+        typeDefs: extractedTypeDefs,
+        resolvers: extractedResolvers,
+        schemaExtensions: extractedSchemaExtensions,
+    });
+}

node_modules/@graphql-tools/schema/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@graphql-tools/schema",
+  "version": "9.0.19",
+  "description": "A set of utils for faster development of GraphQL tools",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
+  },
+  "dependencies": {
+    "@graphql-tools/merge": "^8.4.1",
+    "@graphql-tools/utils": "^9.2.1",
+    "tslib": "^2.4.0",
+    "value-or-promise": "^1.0.12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/graphql-tools",
+    "directory": "packages/schema"
+  },
+  "license": "MIT",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./*": {
+      "require": {
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

node_modules/@graphql-tools/schema/typings/addResolversToSchema.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IAddResolversToSchemaOptions } from '@graphql-tools/utils';
+export declare function addResolversToSchema({ schema, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions, inheritResolversFromInterfaces, updateResolversInPlace, }: IAddResolversToSchemaOptions): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/addResolversToSchema.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IAddResolversToSchemaOptions } from '@graphql-tools/utils';
+export declare function addResolversToSchema({ schema, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions, inheritResolversFromInterfaces, updateResolversInPlace, }: IAddResolversToSchemaOptions): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/assertResolversPresent.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IResolverValidationOptions } from '@graphql-tools/utils';
+export declare function assertResolversPresent(schema: GraphQLSchema, resolverValidationOptions?: IResolverValidationOptions): void;

node_modules/@graphql-tools/schema/typings/assertResolversPresent.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IResolverValidationOptions } from '@graphql-tools/utils';
+export declare function assertResolversPresent(schema: GraphQLSchema, resolverValidationOptions?: IResolverValidationOptions): void;

node_modules/@graphql-tools/schema/typings/chainResolvers.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLResolveInfo, GraphQLFieldResolver } from 'graphql';
+import { Maybe } from '@graphql-tools/utils';
+export declare function chainResolvers<TArgs extends {
+    [argName: string]: any;
+}>(resolvers: Array<Maybe<GraphQLFieldResolver<any, any, TArgs>>>): (root: any, args: TArgs, ctx: any, info: GraphQLResolveInfo) => any;

node_modules/@graphql-tools/schema/typings/chainResolvers.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLResolveInfo, GraphQLFieldResolver } from 'graphql';
+import { Maybe } from '@graphql-tools/utils';
+export declare function chainResolvers<TArgs extends {
+    [argName: string]: any;
+}>(resolvers: Array<Maybe<GraphQLFieldResolver<any, any, TArgs>>>): (root: any, args: TArgs, ctx: any, info: GraphQLResolveInfo) => any;

node_modules/@graphql-tools/schema/typings/checkForResolveTypeResolver.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { ValidatorBehavior } from '@graphql-tools/utils';
+export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType?: ValidatorBehavior): void;

node_modules/@graphql-tools/schema/typings/checkForResolveTypeResolver.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { ValidatorBehavior } from '@graphql-tools/utils';
+export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType?: ValidatorBehavior): void;

node_modules/@graphql-tools/schema/typings/extendResolversFromInterfaces.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IResolvers } from '@graphql-tools/utils';
+export declare function extendResolversFromInterfaces(schema: GraphQLSchema, resolvers: IResolvers): IResolvers;

node_modules/@graphql-tools/schema/typings/extendResolversFromInterfaces.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { IResolvers } from '@graphql-tools/utils';
+export declare function extendResolversFromInterfaces(schema: GraphQLSchema, resolvers: IResolvers): IResolvers;

node_modules/@graphql-tools/schema/typings/index.d.cts

@@ -0,0 +1,9 @@
+export { assertResolversPresent } from './assertResolversPresent.cjs';
+export { chainResolvers } from './chainResolvers.cjs';
+export { addResolversToSchema } from './addResolversToSchema.cjs';
+export { checkForResolveTypeResolver } from './checkForResolveTypeResolver.cjs';
+export { extendResolversFromInterfaces } from './extendResolversFromInterfaces.cjs';
+export * from './makeExecutableSchema.cjs';
+export * from './types.cjs';
+export * from './merge-schemas.cjs';
+export { extractExtensionsFromSchema } from '@graphql-tools/utils';

node_modules/@graphql-tools/schema/typings/index.d.ts

@@ -0,0 +1,9 @@
+export { assertResolversPresent } from './assertResolversPresent.js';
+export { chainResolvers } from './chainResolvers.js';
+export { addResolversToSchema } from './addResolversToSchema.js';
+export { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
+export { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
+export * from './makeExecutableSchema.js';
+export * from './types.js';
+export * from './merge-schemas.js';
+export { extractExtensionsFromSchema } from '@graphql-tools/utils';

node_modules/@graphql-tools/schema/typings/makeExecutableSchema.d.cts

@@ -0,0 +1,46 @@
+import { GraphQLSchema } from 'graphql';
+import { IExecutableSchemaDefinition } from './types.cjs';
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use GraphQL magic comment provide additional syntax
+ * highlighting in your editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = /* GraphQL *\/ `
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
+export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, resolverValidationOptions, inheritResolversFromInterfaces, updateResolversInPlace, schemaExtensions, ...otherOptions }: IExecutableSchemaDefinition<TContext>): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/makeExecutableSchema.d.ts

@@ -0,0 +1,46 @@
+import { GraphQLSchema } from 'graphql';
+import { IExecutableSchemaDefinition } from './types.js';
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use GraphQL magic comment provide additional syntax
+ * highlighting in your editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = /* GraphQL *\/ `
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
+export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, resolverValidationOptions, inheritResolversFromInterfaces, updateResolversInPlace, schemaExtensions, ...otherOptions }: IExecutableSchemaDefinition<TContext>): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/merge-schemas.d.cts

@@ -0,0 +1,16 @@
+import { GraphQLSchema } from 'graphql';
+import { IExecutableSchemaDefinition } from './types.cjs';
+/**
+ * Configuration object for schema merging
+ */
+export type MergeSchemasConfig<T = any> = Partial<IExecutableSchemaDefinition<T>> & {
+    /**
+     * The schemas to be merged
+     */
+    schemas?: GraphQLSchema[];
+};
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+export declare function mergeSchemas(config: MergeSchemasConfig): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/merge-schemas.d.ts

@@ -0,0 +1,16 @@
+import { GraphQLSchema } from 'graphql';
+import { IExecutableSchemaDefinition } from './types.js';
+/**
+ * Configuration object for schema merging
+ */
+export type MergeSchemasConfig<T = any> = Partial<IExecutableSchemaDefinition<T>> & {
+    /**
+     * The schemas to be merged
+     */
+    schemas?: GraphQLSchema[];
+};
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+export declare function mergeSchemas(config: MergeSchemasConfig): GraphQLSchema;

node_modules/@graphql-tools/schema/typings/types.d.cts

@@ -0,0 +1,35 @@
+import { TypeSource, IResolvers, IResolverValidationOptions, GraphQLParseOptions, SchemaExtensions } from '@graphql-tools/utils';
+import { BuildSchemaOptions, GraphQLSchema } from 'graphql';
+export interface GraphQLSchemaWithContext<TContext> extends GraphQLSchema {
+    __context?: TContext;
+}
+/**
+ * Configuration object for creating an executable schema
+ */
+export interface IExecutableSchemaDefinition<TContext = any> extends BuildSchemaOptions, GraphQLParseOptions {
+    /**
+     * The type definitions used to create the schema
+     */
+    typeDefs: TypeSource;
+    /**
+     * Object describing the field resolvers for the provided type definitions
+     */
+    resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
+    /**
+     * Additional options for validating the provided resolvers
+     */
+    resolverValidationOptions?: IResolverValidationOptions;
+    /**
+     * GraphQL object types that implement interfaces will inherit any missing
+     * resolvers from their interface types defined in the `resolvers` object
+     */
+    inheritResolversFromInterfaces?: boolean;
+    /**
+     * Do not create a schema again and use the one from `buildASTSchema`
+     */
+    updateResolversInPlace?: boolean;
+    /**
+     * Schema extensions
+     */
+    schemaExtensions?: SchemaExtensions | Array<SchemaExtensions>;
+}

node_modules/@graphql-tools/schema/typings/types.d.ts

@@ -0,0 +1,35 @@
+import { TypeSource, IResolvers, IResolverValidationOptions, GraphQLParseOptions, SchemaExtensions } from '@graphql-tools/utils';
+import { BuildSchemaOptions, GraphQLSchema } from 'graphql';
+export interface GraphQLSchemaWithContext<TContext> extends GraphQLSchema {
+    __context?: TContext;
+}
+/**
+ * Configuration object for creating an executable schema
+ */
+export interface IExecutableSchemaDefinition<TContext = any> extends BuildSchemaOptions, GraphQLParseOptions {
+    /**
+     * The type definitions used to create the schema
+     */
+    typeDefs: TypeSource;
+    /**
+     * Object describing the field resolvers for the provided type definitions
+     */
+    resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
+    /**
+     * Additional options for validating the provided resolvers
+     */
+    resolverValidationOptions?: IResolverValidationOptions;
+    /**
+     * GraphQL object types that implement interfaces will inherit any missing
+     * resolvers from their interface types defined in the `resolvers` object
+     */
+    inheritResolversFromInterfaces?: boolean;
+    /**
+     * Do not create a schema again and use the one from `buildASTSchema`
+     */
+    updateResolversInPlace?: boolean;
+    /**
+     * Schema extensions
+     */
+    schemaExtensions?: SchemaExtensions | Array<SchemaExtensions>;
+}