graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121025807-95ab4fb1994c3cf68c88a7cf234efd8f99f92ed1

package/cjs/shared/errors.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonDocumentNodeError = exports.ResolverInvalidError = exports.ResolverDuplicatedError = exports.ExtraMiddlewareError = exports.ExtraResolverError = exports.ModuleDuplicatedError = exports.ModuleNonUniqueIdError = void 0;
+exports.useLocation = useLocation;
+exports.ExtendableBuiltin = ExtendableBuiltin;
+exports.composeMessage = composeMessage;
+class ModuleNonUniqueIdError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ModuleNonUniqueIdError = ModuleNonUniqueIdError;
+class ModuleDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ModuleDuplicatedError = ModuleDuplicatedError;
+class ExtraResolverError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ExtraResolverError = ExtraResolverError;
+class ExtraMiddlewareError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ExtraMiddlewareError = ExtraMiddlewareError;
+class ResolverDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ResolverDuplicatedError = ResolverDuplicatedError;
+class ResolverInvalidError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.ResolverInvalidError = ResolverInvalidError;
+class NonDocumentNodeError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+exports.NonDocumentNodeError = NonDocumentNodeError;
+// helpers
+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');
+}
+function ExtendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+        cls.apply(this, arguments);
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype);
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+    return ExtendableBuiltin;
+}
+function composeMessage(...lines) {
+    return lines.join('\n');
+}

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;
+}