graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c

package/esm/module/metadata.js

@@ -0,0 +1,107 @@
+import { visit, Kind, } from 'graphql';
+export function metadataFactory(typeDefs, config) {
+    const implemented = {};
+    const extended = {};
+    function collectObjectDefinition(node) {
+        if (!implemented[node.name.value]) {
+            implemented[node.name.value] = [];
+        }
+        if (node.fields && node.fields.length > 0) {
+            implemented[node.name.value].push(...node.fields.map((field) => field.name.value));
+        }
+        if (node.kind === Kind.OBJECT_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__isTypeOf');
+        }
+        if (node.kind === Kind.OBJECT_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__resolveReference');
+            implemented[node.name.value].push('__resolveObject');
+        }
+        if (node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__resolveType');
+        }
+    }
+    function collectObjectExtension(node) {
+        if (node.fields) {
+            if (!extended[node.name.value]) {
+                extended[node.name.value] = [];
+            }
+            node.fields.forEach((field) => {
+                extended[node.name.value].push(field.name.value);
+            });
+        }
+    }
+    for (const doc of typeDefs) {
+        visit(doc, {
+            // Object
+            ObjectTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            ObjectTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Interface
+            InterfaceTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            InterfaceTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Union
+            UnionTypeDefinition(node) {
+                if (!implemented[node.name.value]) {
+                    implemented[node.name.value] = [];
+                }
+                if (node.types) {
+                    implemented[node.name.value].push(...node.types.map((type) => type.name.value));
+                }
+                implemented[node.name.value].push('__resolveType');
+            },
+            UnionTypeExtension(node) {
+                if (node.types) {
+                    if (!extended[node.name.value]) {
+                        extended[node.name.value] = [];
+                    }
+                    extended[node.name.value].push(...node.types.map((type) => type.name.value));
+                }
+            },
+            // Input
+            InputObjectTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            InputObjectTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Enum
+            EnumTypeDefinition(node) {
+                if (node.values) {
+                    if (!implemented[node.name.value]) {
+                        implemented[node.name.value] = [];
+                    }
+                    implemented[node.name.value].push(...node.values.map((value) => value.name.value));
+                }
+            },
+            EnumTypeExtension(node) {
+                if (node.values) {
+                    if (!extended[node.name.value]) {
+                        extended[node.name.value] = [];
+                    }
+                    extended[node.name.value].push(...node.values.map((value) => value.name.value));
+                }
+            },
+            // Scalar
+            ScalarTypeDefinition(node) {
+                if (!implemented.__scalars) {
+                    implemented.__scalars = [];
+                }
+                implemented.__scalars.push(node.name.value);
+            },
+        });
+    }
+    return {
+        id: config.id,
+        typeDefs,
+        implements: implemented,
+        extends: extended,
+        dirname: config.dirname,
+    };
+}

package/esm/module/module.js

@@ -0,0 +1,24 @@
+import { moduleFactory } from './factory';
+/**
+ * @api
+ * Creates a Module, an element used by Application. Accepts `ModuleConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createModule, gql } from 'graphql-modules';
+ *
+ * export const usersModule = createModule({
+ *   id: 'users',
+ *   typeDefs: gql`
+ *     // GraphQL SDL
+ *   `,
+ *   resolvers: {
+ *     // ...
+ *   }
+ * });
+ * ```
+ */
+export function createModule(config) {
+    return moduleFactory(config);
+}

package/esm/module/resolvers.js

@@ -0,0 +1,337 @@
+import { GraphQLScalarType, concatAST, Kind, defaultFieldResolver, } from 'graphql';
+import { useLocation, ExtraResolverError, ResolverDuplicatedError, ResolverInvalidError, } from './../shared/errors';
+import { isNil, isDefined, isPrimitive } from '../shared/utils';
+import { createMiddleware, mergeMiddlewareMaps, validateMiddlewareMap, } from '../shared/middleware';
+const resolverMetadataProp = Symbol('metadata');
+export function createResolvers(config, metadata, app) {
+    const ensure = ensureImplements(metadata);
+    const normalizedModuleMiddlewareMap = config.middlewares || {};
+    const middlewareMap = mergeMiddlewareMaps(app.middlewareMap, normalizedModuleMiddlewareMap);
+    validateMiddlewareMap(normalizedModuleMiddlewareMap, metadata);
+    const resolvers = addDefaultResolvers(mergeResolvers(config), middlewareMap, config);
+    // Wrap resolvers
+    for (const typeName in resolvers) {
+        if (resolvers.hasOwnProperty(typeName)) {
+            const obj = resolvers[typeName];
+            if (isScalarResolver(obj)) {
+                continue;
+            }
+            else if (isEnumResolver(obj)) {
+                continue;
+            }
+            else if (obj && typeof obj === 'object') {
+                for (const fieldName in obj) {
+                    if (obj.hasOwnProperty(fieldName)) {
+                        ensure.type(typeName, fieldName);
+                        const path = [typeName, fieldName];
+                        // function
+                        if (isResolveFn(obj[fieldName])) {
+                            const resolver = wrapResolver({
+                                config,
+                                resolver: obj[fieldName],
+                                middlewareMap,
+                                path,
+                                isTypeResolver: fieldName === '__isTypeOf' || fieldName === '__resolveType',
+                                isReferenceResolver: fieldName === '__resolveReference',
+                                isObjectResolver: fieldName === '__resolveObject',
+                            });
+                            resolvers[typeName][fieldName] = resolver;
+                        }
+                        else if (isResolveOptions(obj[fieldName])) {
+                            // { resolve }
+                            if (isDefined(obj[fieldName].resolve)) {
+                                const resolver = wrapResolver({
+                                    config,
+                                    resolver: obj[fieldName].resolve,
+                                    middlewareMap,
+                                    path,
+                                });
+                                resolvers[typeName][fieldName].resolve = resolver;
+                            }
+                            // { subscribe }
+                            if (isDefined(obj[fieldName].subscribe)) {
+                                const resolver = wrapResolver({
+                                    config,
+                                    resolver: obj[fieldName].subscribe,
+                                    middlewareMap,
+                                    path,
+                                });
+                                resolvers[typeName][fieldName].subscribe = resolver;
+                            }
+                            if (isDefined(obj[fieldName].extensions)) {
+                                // Do NOT add a resolve if one is not specified, it will cause
+                                // change in behavior in systems like `grafast`
+                                resolvers[typeName][fieldName].extensions =
+                                    obj[fieldName].extensions;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return resolvers;
+}
+/**
+ * Wrap a resolver so we use module's context instead of app context.
+ * Use a middleware if available.
+ * Attach metadata to a resolver (we will see if it's helpful, probably in error handling)
+ */
+function wrapResolver({ resolver, config, path, middlewareMap, isTypeResolver, isReferenceResolver, isObjectResolver, }) {
+    if (isTypeResolver || isReferenceResolver) {
+        const wrappedResolver = (root, context, info) => {
+            const ctx = {
+                root,
+                context: isReferenceResolver
+                    ? context.ɵgetModuleContext(config.id, context)
+                    : // We mark the context object as possibly undefined,
+                        // because graphql-jit for some reason doesn't pass it for isTypeOf or resolveType methods
+                        context === null || context === void 0 ? void 0 : context.ɵgetModuleContext(config.id, context),
+                info,
+            };
+            return resolver(ctx.root, ctx.context, ctx.info);
+        };
+        writeResolverMetadata(wrappedResolver, config);
+        return wrappedResolver;
+    }
+    if (isObjectResolver) {
+        const wrappedResolver = (root, fields, context, info) => {
+            const moduleContext = context.ɵgetModuleContext(config.id, context);
+            return resolver(root, fields, moduleContext, info);
+        };
+        writeResolverMetadata(wrappedResolver, config);
+        return wrappedResolver;
+    }
+    const middleware = createMiddleware(path, middlewareMap);
+    const wrappedResolver = (root, args, context, info) => {
+        const ctx = {
+            root,
+            args,
+            context: context.ɵgetModuleContext(config.id, context),
+            info,
+        };
+        return middleware(ctx, () => resolver(ctx.root, ctx.args, ctx.context, ctx.info));
+    };
+    writeResolverMetadata(wrappedResolver, config);
+    return wrappedResolver;
+}
+/**
+ * We iterate over every defined resolver and check if it's valid and not duplicated
+ */
+function mergeResolvers(config) {
+    if (!config.resolvers) {
+        return {};
+    }
+    const resolvers = Array.isArray(config.resolvers)
+        ? config.resolvers
+        : [config.resolvers];
+    const container = {};
+    for (const currentResolvers of resolvers) {
+        for (const typeName in currentResolvers) {
+            if (currentResolvers.hasOwnProperty(typeName)) {
+                const value = currentResolvers[typeName];
+                if (isNil(value)) {
+                    continue;
+                }
+                else if (isScalarResolver(value)) {
+                    addScalar({ typeName, resolver: value, container, config });
+                }
+                else if (isEnumResolver(value)) {
+                    addEnum({ typeName, resolver: value, container, config });
+                }
+                else if (value && typeof value === 'object') {
+                    addObject({ typeName, fields: value, container, config });
+                }
+                else {
+                    throw new ResolverInvalidError(`Resolver of "${typeName}" is invalid`, useLocation({ dirname: config.dirname, id: config.id }));
+                }
+            }
+        }
+    }
+    return container;
+}
+function addObject({ typeName, fields, container, config, }) {
+    if (!container[typeName]) {
+        container[typeName] = {};
+    }
+    for (const fieldName in fields) {
+        if (fields.hasOwnProperty(fieldName)) {
+            const resolver = fields[fieldName];
+            if (isResolveFn(resolver)) {
+                if (container[typeName][fieldName]) {
+                    throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}"`, useLocation({ dirname: config.dirname, id: config.id }));
+                }
+                writeResolverMetadata(resolver, config);
+                container[typeName][fieldName] = resolver;
+            }
+            else if (isResolveOptions(resolver)) {
+                if (!container[typeName][fieldName]) {
+                    container[typeName][fieldName] = {};
+                }
+                // resolve
+                if (isDefined(resolver.resolve)) {
+                    if (container[typeName][fieldName].resolve) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (resolve method)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.resolve, config);
+                    container[typeName][fieldName].resolve = resolver.resolve;
+                }
+                // subscribe
+                if (isDefined(resolver.subscribe)) {
+                    if (container[typeName][fieldName].subscribe) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (subscribe method)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.subscribe, config);
+                    container[typeName][fieldName].subscribe = resolver.subscribe;
+                }
+                // extensions
+                if (isDefined(resolver.extensions)) {
+                    if (container[typeName][fieldName].extensions) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (extensions object)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.extensions, config);
+                    container[typeName][fieldName].extensions = resolver.extensions;
+                }
+            }
+        }
+    }
+}
+function addScalar({ typeName, resolver, container, config, }) {
+    if (container[typeName]) {
+        throw new ResolverDuplicatedError(`Duplicated resolver of scalar "${typeName}"`, useLocation({ dirname: config.dirname, id: config.id }));
+    }
+    writeResolverMetadata(resolver.parseLiteral, config);
+    writeResolverMetadata(resolver.parseValue, config);
+    writeResolverMetadata(resolver.serialize, config);
+    container[typeName] = resolver;
+}
+function addEnum({ typeName, resolver, container, config, }) {
+    if (!container[typeName]) {
+        container[typeName] = {};
+    }
+    for (const key in resolver) {
+        if (resolver.hasOwnProperty(key)) {
+            const value = resolver[key];
+            if (container[typeName][key]) {
+                throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${key}" enum value`, useLocation({ dirname: config.dirname, id: config.id }));
+            }
+            container[typeName][key] = value;
+        }
+    }
+}
+/**
+ * Helps to make sure a resolver has a corresponding type/field definition.
+ * We don't want to pass resolve function that are not related to the module.
+ */
+function ensureImplements(metadata) {
+    return {
+        type(name, field) {
+            var _a, _b;
+            const type = []
+                .concat((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[name], (_b = metadata.extends) === null || _b === void 0 ? void 0 : _b[name])
+                .filter(isDefined);
+            if (type === null || type === void 0 ? void 0 : type.includes(field)) {
+                return true;
+            }
+            const id = `"${name}.${field}"`;
+            throw new ExtraResolverError(`Resolver of "${id}" type cannot be implemented`, `${id} is not defined`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+        },
+        scalar(name) {
+            var _a;
+            if ((((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a.__scalars) || []).includes(name)) {
+                return true;
+            }
+            throw new ExtraResolverError(`Resolver of "${name}" scalar cannot be implemented`, `${name} is not defined`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+        },
+    };
+}
+function writeResolverMetadata(resolver, config) {
+    if (!resolver) {
+        return;
+    }
+    resolver[resolverMetadataProp] = {
+        moduleId: config.id,
+    };
+}
+export function readResolverMetadata(resolver) {
+    return resolver[resolverMetadataProp];
+}
+/**
+ * In order to use middlewares on fields
+ * that are defined in SDL but have no implemented resolvers,
+ * we would have to recreate GraphQLSchema and wrap resolve functions.
+ *
+ * Since we can't access GraphQLSchema on a module level
+ * and recreating GraphQLSchema seems unreasonable,
+ * we can create default resolvers instead.
+ *
+ * @example
+ *
+ * gql`
+ *  type Query {
+ *    me: User!
+ *  }
+ *
+ *  type User {
+ *    name: String!
+ *  }
+ * `
+ *
+ * The resolver of `Query.me` is implemented and resolver of `User.name` is not.
+ * In case where a middleware wants to intercept the resolver of `User.name`,
+ * we use a default field resolver from `graphql` package
+ * and put it next to other defined resolvers.
+ *
+ * This way our current logic of wrapping resolvers and running
+ * middleware functions stays untouched.
+ */
+function addDefaultResolvers(resolvers, middlewareMap, config) {
+    const container = resolvers;
+    const sdl = Array.isArray(config.typeDefs)
+        ? concatAST(config.typeDefs)
+        : config.typeDefs;
+    function hasMiddleware(typeName, fieldName) {
+        var _a, _b, _c, _d, _e, _f;
+        return ((((_b = (_a = middlewareMap['*']) === null || _a === void 0 ? void 0 : _a['*']) === null || _b === void 0 ? void 0 : _b.length) ||
+            ((_d = (_c = middlewareMap[typeName]) === null || _c === void 0 ? void 0 : _c['*']) === null || _d === void 0 ? void 0 : _d.length) ||
+            ((_f = (_e = middlewareMap[typeName]) === null || _e === void 0 ? void 0 : _e[fieldName]) === null || _f === void 0 ? void 0 : _f.length)) > 0);
+    }
+    sdl.definitions.forEach((definition) => {
+        if (definition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+            definition.kind === Kind.OBJECT_TYPE_EXTENSION) {
+            // Right now we only support Object type
+            if (definition.fields) {
+                const typeName = definition.name.value;
+                definition.fields.forEach((field) => {
+                    var _a;
+                    const fieldName = field.name.value;
+                    if (!((_a = container[typeName]) === null || _a === void 0 ? void 0 : _a[fieldName]) &&
+                        hasMiddleware(typeName, fieldName)) {
+                        if (!container[typeName]) {
+                            container[typeName] = {};
+                        }
+                        container[typeName][fieldName] = defaultFieldResolver;
+                    }
+                });
+            }
+        }
+    });
+    return container;
+}
+//
+// Resolver helpers
+//
+function isResolveFn(value) {
+    return typeof value === 'function';
+}
+function isResolveOptions(value) {
+    return (isDefined(value.resolve) ||
+        isDefined(value.subscribe) ||
+        isDefined(value.extensions));
+}
+function isScalarResolver(obj) {
+    return obj instanceof GraphQLScalarType;
+}
+function isEnumResolver(obj) {
+    return Object.values(obj).every(isPrimitive);
+}

package/esm/module/tokens.js

@@ -0,0 +1,18 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `MODULE_ID` is an InjectionToken representing module's ID
+ *
+ * @example
+ * ```typescript
+ * import { MODULE_ID, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(MODULE_ID) moduleId: string) {
+ *     console.log(`Data used in ${moduleId} module`)
+ *   }
+ * }
+ * ```
+ */
+export const MODULE_ID = new InjectionToken('module-id');

package/esm/module/type-defs.js

@@ -0,0 +1,21 @@
+import { Kind } from 'graphql';
+import { NonDocumentNodeError, useLocation } from '../shared/errors';
+/**
+ * Create a list of DocumentNode objects based on Module's config.
+ * Add a location, so we get richer errors.
+ */
+export function createTypeDefs(config) {
+    const typeDefs = Array.isArray(config.typeDefs)
+        ? config.typeDefs
+        : [config.typeDefs];
+    ensureDocumentNode(config, typeDefs);
+    return typeDefs;
+}
+function ensureDocumentNode(config, typeDefs) {
+    function ensureEach(doc, i) {
+        if ((doc === null || doc === void 0 ? void 0 : doc.kind) !== Kind.DOCUMENT) {
+            throw new NonDocumentNodeError(`Expected parsed document but received ${typeof doc} at index ${i} in typeDefs list`, useLocation(config));
+        }
+    }
+    typeDefs.forEach(ensureEach);
+}

package/esm/shared/errors.js

@@ -0,0 +1,69 @@
+export class ModuleNonUniqueIdError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ModuleDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ExtraResolverError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ExtraMiddlewareError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ResolverDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ResolverInvalidError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class NonDocumentNodeError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+// helpers
+export function useLocation({ dirname, id }) {
+    return dirname
+        ? `Module "${id}" located at ${dirname}`
+        : [
+            `Module "${id}"`,
+            `Hint: pass __dirname to "dirname" option of your modules to get more insightful errors`,
+        ].join('\n');
+}
+export function ExtendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+        cls.apply(this, arguments);
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype);
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+    return ExtendableBuiltin;
+}
+export function composeMessage(...lines) {
+    return lines.join('\n');
+}

package/esm/shared/gql.js

@@ -0,0 +1,9 @@
+import { parse, Kind } from 'graphql';
+export function gql(literals) {
+    const result = typeof literals === 'string' ? literals : literals[0];
+    const parsed = parse(result);
+    if (!parsed || parsed.kind !== Kind.DOCUMENT) {
+        throw new Error('Not a valid GraphQL document.');
+    }
+    return parsed;
+}