graphql-modules 3.1.2-alpha-20260121023952-c6236f99446644c787494ddb1a9a973180bab70e → 3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c

package/cjs/shared/gql.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gql = gql;
+const graphql_1 = require("graphql");
+function gql(literals) {
+    const result = typeof literals === 'string' ? literals : literals[0];
+    const parsed = (0, graphql_1.parse)(result);
+    if (!parsed || parsed.kind !== graphql_1.Kind.DOCUMENT) {
+        throw new Error('Not a valid GraphQL document.');
+    }
+    return parsed;
+}

package/cjs/shared/middleware.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+exports.createMiddleware = createMiddleware;
+exports.mergeMiddlewareMaps = mergeMiddlewareMaps;
+exports.validateMiddlewareMap = validateMiddlewareMap;
+const ramda_1 = require("ramda");
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+function compose(middleware) {
+    if (!Array.isArray(middleware)) {
+        throw new TypeError('Middleware stack must be an array!');
+    }
+    for (const fn of middleware) {
+        if (typeof fn !== 'function') {
+            throw new TypeError('Middleware must be composed of functions!');
+        }
+    }
+    return function composed(context, next) {
+        // last called middleware
+        let index = -1;
+        function dispatch(i) {
+            if (i <= index) {
+                return Promise.reject(new Error('next() called multiple times'));
+            }
+            index = i;
+            const fn = i === middleware.length ? next : middleware[i];
+            if (!fn) {
+                return Promise.resolve();
+            }
+            try {
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+        return dispatch(0);
+    };
+}
+function createMiddleware(path, middlewareMap) {
+    const middlewares = middlewareMap ? pickMiddlewares(path, middlewareMap) : [];
+    return compose(middlewares);
+}
+function mergeMiddlewareMaps(app, mod) {
+    const merge = (left, right) => {
+        return (0, ramda_1.mergeDeepWith)((l, r) => {
+            if (Array.isArray(l)) {
+                return l.concat(r || []);
+            }
+            return merge(l, r);
+        }, left, right);
+    };
+    return merge(app, mod);
+}
+function pickMiddlewares(path, middlewareMap) {
+    var _a;
+    const middlewares = [];
+    const [type, field] = path;
+    if ((_a = middlewareMap['*']) === null || _a === void 0 ? void 0 : _a['*']) {
+        middlewares.push(...middlewareMap['*']['*']);
+    }
+    const typeMap = middlewareMap[type];
+    if (typeMap) {
+        if (typeMap['*']) {
+            middlewares.push(...typeMap['*']);
+        }
+        if (field && typeMap[field]) {
+            middlewares.push(...typeMap[field]);
+        }
+    }
+    return middlewares.filter(utils_1.isDefined);
+}
+function validateMiddlewareMap(middlewareMap, metadata) {
+    const exists = checkExistence(metadata);
+    for (const typeName in middlewareMap.types) {
+        if (middlewareMap.types.hasOwnProperty(typeName)) {
+            const typeMiddlewareMap = middlewareMap[typeName];
+            if (!exists.type(typeName)) {
+                throw new errors_1.ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}" type`, (0, errors_1.useLocation)({ dirname: metadata.dirname, id: metadata.id }));
+            }
+            for (const fieldName in typeMiddlewareMap[typeName]) {
+                if (typeMiddlewareMap[typeName].hasOwnProperty(fieldName)) {
+                    if (!exists.field(typeName, fieldName)) {
+                        throw new errors_1.ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}.${fieldName}" type.field`, (0, errors_1.useLocation)({ dirname: metadata.dirname, id: metadata.id }));
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Helps to make sure a middleware has a corresponding type/field definition.
+ * We don't want to pass a module-level middlewares that are not related to the module.
+ * Not because it's dangerous but to prevent unused middlewares.
+ */
+function checkExistence(metadata) {
+    return {
+        type(name) {
+            var _a, _b;
+            return (0, utils_1.isDefined)(((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = metadata.extends) === null || _b === void 0 ? void 0 : _b[name]));
+        },
+        field(type, name) {
+            var _a, _b, _c, _d;
+            return (0, utils_1.isDefined)(((_b = (_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[type]) === null || _b === void 0 ? void 0 : _b.includes(name)) ||
+                ((_d = (_c = metadata.extends) === null || _c === void 0 ? void 0 : _c[type]) === null || _d === void 0 ? void 0 : _d.includes(name)));
+        },
+    };
+}

package/cjs/shared/utils.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = flatten;
+exports.isDefined = isDefined;
+exports.isNil = isNil;
+exports.isObject = isObject;
+exports.isPrimitive = isPrimitive;
+exports.isAsyncIterable = isAsyncIterable;
+exports.tapAsyncIterator = tapAsyncIterator;
+exports.once = once;
+exports.share = share;
+exports.uniqueId = uniqueId;
+exports.isNotSchema = isNotSchema;
+exports.merge = merge;
+const graphql_1 = require("graphql");
+function flatten(arr) {
+    return Array.prototype.concat(...arr);
+}
+function isDefined(val) {
+    return !isNil(val);
+}
+function isNil(val) {
+    return val === null || typeof val === 'undefined';
+}
+function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+function isPrimitive(val) {
+    return ['number', 'string', 'boolean', 'symbol', 'bigint'].includes(typeof val);
+}
+function isAsyncIterable(obj) {
+    return obj && typeof obj[Symbol.asyncIterator] === 'function';
+}
+function tapAsyncIterator(iterable, doneCallback) {
+    const iteratorMethod = iterable[Symbol.asyncIterator];
+    const iterator = iteratorMethod.call(iterable);
+    function mapResult(result) {
+        if (result.done) {
+            doneCallback();
+        }
+        return result;
+    }
+    return {
+        async next() {
+            try {
+                let result = await iterator.next();
+                return mapResult(result);
+            }
+            catch (error) {
+                doneCallback();
+                throw error;
+            }
+        },
+        async return(value) {
+            try {
+                const result = await iterator.return(value);
+                return mapResult(result);
+            }
+            catch (error) {
+                doneCallback();
+                throw error;
+            }
+        },
+        throw(error) {
+            doneCallback();
+            return iterator.throw(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+function once(cb) {
+    let called = false;
+    return () => {
+        if (!called) {
+            called = true;
+            cb();
+        }
+    };
+}
+function share(factory) {
+    let cached = null;
+    return (arg) => {
+        if (!cached) {
+            cached = factory(arg);
+        }
+        return cached;
+    };
+}
+function uniqueId(isNotUsed) {
+    let id;
+    while (!isNotUsed((id = Math.random().toString(16).substr(2)))) { }
+    return id;
+}
+function isNotSchema(obj) {
+    return obj instanceof graphql_1.GraphQLSchema === false;
+}
+function merge(source, target) {
+    const result = {
+        ...source,
+        ...target,
+    };
+    function attachSymbols(obj) {
+        const symbols = Object.getOwnPropertySymbols(obj);
+        for (const symbol of symbols) {
+            result[symbol] = obj[symbol];
+        }
+    }
+    if (source) {
+        attachSymbols(source);
+    }
+    attachSymbols(target);
+    return result;
+}

package/cjs/testing/di.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideEmpty = provideEmpty;
+function provideEmpty(token) {
+    return {
+        provide: token,
+        useValue: {},
+    };
+}

package/cjs/testing/graphql.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+function execute(app, inputs, options) {
+    const executor = app.createExecution(options);
+    return executor({
+        schema: app.schema,
+        ...inputs,
+    });
+}

package/cjs/testing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testkit = void 0;
+const test_application_1 = require("./test-application");
+const test_module_1 = require("./test-module");
+const test_injector_1 = require("./test-injector");
+const graphql_1 = require("./graphql");
+const di_1 = require("./di");
+exports.testkit = {
+    mockApplication: test_application_1.mockApplication,
+    mockModule: test_module_1.mockModule,
+    testModule: test_module_1.testModule,
+    testInjector: test_injector_1.testInjector,
+    readProviderOptions: test_injector_1.readProviderOptions,
+    provideEmpty: di_1.provideEmpty,
+    execute: graphql_1.execute,
+};

package/cjs/testing/test-application.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockApplication = mockApplication;
+const utils_1 = require("../shared/utils");
+function mockApplication(app) {
+    function mockedFactory(newConfig) {
+        const sharedFactory = (0, utils_1.share)(() => app.ɵfactory(newConfig));
+        return {
+            get typeDefs() {
+                return sharedFactory().typeDefs;
+            },
+            get resolvers() {
+                return sharedFactory().resolvers;
+            },
+            get schema() {
+                return sharedFactory().schema;
+            },
+            get injector() {
+                return sharedFactory().injector;
+            },
+            createOperationController(options) {
+                return sharedFactory().createOperationController(options);
+            },
+            createSubscription(options) {
+                return sharedFactory().createSubscription(options);
+            },
+            createExecution(options) {
+                return sharedFactory().createExecution(options);
+            },
+            createSchemaForApollo() {
+                return sharedFactory().createSchemaForApollo();
+            },
+            createApolloExecutor() {
+                return sharedFactory().createApolloExecutor();
+            },
+            get ɵfactory() {
+                return sharedFactory().ɵfactory;
+            },
+            get ɵconfig() {
+                return sharedFactory().ɵconfig;
+            },
+            replaceModule(newModule) {
+                const config = sharedFactory().ɵconfig;
+                return mockedFactory({
+                    ...config,
+                    modules: config.modules.map((mod) => mod.id === newModule.ɵoriginalModule.id ? newModule : mod),
+                });
+            },
+            addProviders(newProviders) {
+                const config = sharedFactory().ɵconfig;
+                const existingProviders = typeof config.providers === 'function'
+                    ? config.providers()
+                    : config.providers;
+                const providers = Array.isArray(existingProviders)
+                    ? existingProviders.concat(newProviders)
+                    : newProviders;
+                return mockedFactory({
+                    ...config,
+                    providers,
+                });
+            },
+        };
+    }
+    return mockedFactory();
+}

package/cjs/testing/test-injector.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInjector = testInjector;
+exports.readProviderOptions = readProviderOptions;
+const injector_1 = require("../di/injector");
+const tokens_1 = require("../application/tokens");
+const metadata_1 = require("../di/metadata");
+function testInjector(providers) {
+    const resolvedProviders = injector_1.ReflectiveInjector.resolve([
+        { provide: tokens_1.CONTEXT, useValue: {} },
+        ...providers,
+    ]);
+    const injector = injector_1.ReflectiveInjector.createFromResolved({
+        name: 'test',
+        providers: resolvedProviders,
+    });
+    injector.instantiateAll();
+    return injector;
+}
+function readProviderOptions(provider) {
+    return (0, metadata_1.readInjectableMetadata)(provider, true).options;
+}

package/cjs/testing/test-module.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockModule = mockModule;
+exports.testModule = testModule;
+const graphql_1 = require("graphql");
+const factory_1 = require("../module/factory");
+const application_1 = require("../application/application");
+const module_1 = require("../module/module");
+function mockModule(testedModule, overrideConfig) {
+    const sourceProviders = typeof testedModule.config.providers === 'function'
+        ? testedModule.config.providers()
+        : testedModule.config.providers;
+    const overrideProviders = typeof overrideConfig.providers === 'function'
+        ? overrideConfig.providers()
+        : overrideConfig.providers;
+    const newModule = (0, module_1.createModule)({
+        ...testedModule.config,
+        providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+    });
+    newModule['ɵoriginalModule'] = testedModule;
+    return newModule;
+}
+function testModule(testedModule, config) {
+    var _a;
+    const mod = transformModule(testedModule, config);
+    const modules = [mod].concat((_a = config === null || config === void 0 ? void 0 : config.modules) !== null && _a !== void 0 ? _a : []);
+    return (0, application_1.createApplication)({
+        ...(config || {}),
+        modules,
+        providers: config === null || config === void 0 ? void 0 : config.providers,
+        middlewares: config === null || config === void 0 ? void 0 : config.middlewares,
+    });
+}
+function transformModule(mod, config) {
+    const transforms = [];
+    if (config === null || config === void 0 ? void 0 : config.replaceExtensions) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: replaceExtensions(m.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.typeDefs) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: m.typeDefs.concat(config.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.inheritTypeDefs) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: inheritTypeDefs(m.typeDefs, config.inheritTypeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.resolvers) {
+        transforms.push((m) => {
+            const resolvers = m.config.resolvers
+                ? Array.isArray(m.config.resolvers)
+                    ? m.config.resolvers
+                    : [m.config.resolvers]
+                : [];
+            return (0, factory_1.moduleFactory)({
+                ...m.config,
+                resolvers: resolvers.concat(config.resolvers),
+            });
+        });
+    }
+    if (config === null || config === void 0 ? void 0 : config.providers) {
+        transforms.push((m) => {
+            const sourceProviders = typeof m.config.providers === 'function'
+                ? m.config.providers()
+                : m.config.providers;
+            const overrideProviders = typeof config.providers === 'function'
+                ? config.providers()
+                : config.providers;
+            return (0, factory_1.moduleFactory)({
+                ...m.config,
+                providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+            });
+        });
+    }
+    if (transforms) {
+        return transforms.reduce((m, transform) => transform(m), mod);
+    }
+    return mod;
+}
+function inheritTypeDefs(originalTypeDefs, modules) {
+    const original = (0, graphql_1.concatAST)(originalTypeDefs);
+    const typeDefs = treeshakeTypesDefs(original, modules.reduce((typeDefs, externalMod) => typeDefs.concat(externalMod.typeDefs), []));
+    return typeDefs;
+}
+function replaceExtensions(typeDefs) {
+    const types = [];
+    const extensions = [];
+    // List all object types
+    typeDefs.forEach((doc) => {
+        (0, graphql_1.visit)(doc, {
+            ObjectTypeDefinition(node) {
+                types.push(node.name.value);
+            },
+        });
+    });
+    // turn object type extensions into object types
+    return typeDefs.map((doc) => {
+        return (0, graphql_1.visit)(doc, {
+            ObjectTypeExtension(node) {
+                // only if object type doesn't exist
+                if (extensions.includes(node.name.value) ||
+                    types.includes(node.name.value)) {
+                    return node;
+                }
+                return {
+                    ...node,
+                    kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+                };
+            },
+        });
+    });
+}
+function treeshakeTypesDefs(originalSource, sources) {
+    const namedTypes = originalSource.definitions.filter(isNamedTypeDefinition);
+    const typesToVisit = namedTypes.map((def) => def.name.value);
+    const rootFields = namedTypes.reduce((acc, node) => {
+        const typeName = node.name.value;
+        if (isRootType(typeName) && hasFields(node)) {
+            if (!acc[typeName]) {
+                acc[typeName] = [];
+            }
+            node.fields.forEach((field) => {
+                acc[typeName].push(field.name.value);
+            });
+        }
+        return acc;
+    }, {});
+    const schema = (0, graphql_1.concatAST)([originalSource].concat(sources));
+    const involvedTypes = new Set(visitTypes(schema, typesToVisit, rootFields));
+    return {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: schema.definitions.filter((def) => {
+            var _a, _b;
+            if (isNamedTypeDefinition(def)) {
+                const typeName = def.name.value;
+                if (!involvedTypes.has(def.name.value)) {
+                    return false;
+                }
+                if ((_a = rootFields[typeName]) === null || _a === void 0 ? void 0 : _a.length) {
+                    const rootType = def;
+                    if ((_b = rootType.fields) === null || _b === void 0 ? void 0 : _b.every((field) => !rootFields[typeName].includes(field.name.value))) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }),
+    };
+}
+function isNamedTypeDefinition(def) {
+    return (!!def &&
+        def.kind !== graphql_1.Kind.SCHEMA_DEFINITION &&
+        def.kind !== graphql_1.Kind.SCHEMA_EXTENSION);
+}
+function visitTypes(schema, types, rootFields) {
+    const visitedTypes = [];
+    const scalars = schema.definitions
+        .filter((def) => def.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+        def.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION)
+        .map((def) => def.name.value);
+    for (const typeName of types) {
+        collectType(typeName);
+    }
+    return visitedTypes;
+    function collectField(field, parentTypeName) {
+        var _a;
+        if (parentTypeName &&
+            isRootType(parentTypeName) &&
+            ((_a = rootFields[parentTypeName]) === null || _a === void 0 ? void 0 : _a.length) &&
+            !rootFields[parentTypeName].includes(field.name.value)) {
+            return;
+        }
+        collectType(resolveType(field.type));
+        if (field.arguments) {
+            field.arguments.forEach((arg) => {
+                collectType(resolveType(arg.type));
+            });
+        }
+        if (field.directives) {
+            field.directives.forEach((directive) => {
+                collectType(directive.name.value);
+            });
+        }
+    }
+    function collectType(typeName) {
+        if (visitedTypes.includes(typeName)) {
+            return;
+        }
+        if (isScalar(typeName)) {
+            visitedTypes.push(typeName);
+            return;
+        }
+        const types = findTypes(typeName);
+        visitedTypes.push(typeName);
+        types.forEach((type) => {
+            if (hasFields(type)) {
+                type.fields.forEach((field) => {
+                    collectField(field, typeName);
+                });
+            }
+            if (hasTypes(type)) {
+                type.types.forEach((t) => {
+                    collectType(resolveType(t));
+                });
+            }
+            if (hasInterfaces(type)) {
+                type.interfaces.forEach((i) => {
+                    collectType(resolveType(i));
+                });
+            }
+        });
+    }
+    function resolveType(type) {
+        if (type.kind === 'ListType') {
+            return resolveType(type.type);
+        }
+        if (type.kind === 'NonNullType') {
+            return resolveType(type.type);
+        }
+        return type.name.value;
+    }
+    function isScalar(name) {
+        return scalars
+            .concat(['String', 'Boolean', 'Int', 'ID', 'Float'])
+            .includes(name);
+    }
+    function findTypes(typeName) {
+        const types = schema.definitions.filter((def) => isNamedTypeDefinition(def) && def.name.value === typeName);
+        if (!types.length) {
+            throw new Error(`Missing type "${typeName}"`);
+        }
+        return types;
+    }
+}
+function hasInterfaces(def) {
+    return (hasPropValue(def, 'interfaces') &&
+        [
+            graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+            graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+            graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+            graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+        ].includes(def.kind));
+}
+function hasTypes(def) {
+    return ([graphql_1.Kind.UNION_TYPE_DEFINITION, graphql_1.Kind.UNION_TYPE_EXTENSION].includes(def.kind) && hasPropValue(def, 'types'));
+}
+function hasFields(def) {
+    return ([
+        graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+        graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+        graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+        graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+        graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    ].includes(def.kind) && hasPropValue(def, 'fields'));
+}
+function hasPropValue(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop) && obj[prop];
+}
+function isRootType(typeName) {
+    return (typeName === 'Query' ||
+        typeName === 'Mutation' ||
+        typeName === 'Subscription');
+}