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

package/esm/shared/middleware.js

@@ -0,0 +1,103 @@
+import { mergeDeepWith } from 'ramda';
+import { isDefined } from './utils';
+import { ExtraMiddlewareError, useLocation } from './errors';
+export 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);
+    };
+}
+export function createMiddleware(path, middlewareMap) {
+    const middlewares = middlewareMap ? pickMiddlewares(path, middlewareMap) : [];
+    return compose(middlewares);
+}
+export function mergeMiddlewareMaps(app, mod) {
+    const merge = (left, right) => {
+        return 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(isDefined);
+}
+export 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 ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}" type`, 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 ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}.${fieldName}" type.field`, 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 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 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/esm/shared/utils.js

@@ -0,0 +1,101 @@
+import { GraphQLSchema } from 'graphql';
+export function flatten(arr) {
+    return Array.prototype.concat(...arr);
+}
+export function isDefined(val) {
+    return !isNil(val);
+}
+export function isNil(val) {
+    return val === null || typeof val === 'undefined';
+}
+export function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+export function isPrimitive(val) {
+    return ['number', 'string', 'boolean', 'symbol', 'bigint'].includes(typeof val);
+}
+export function isAsyncIterable(obj) {
+    return obj && typeof obj[Symbol.asyncIterator] === 'function';
+}
+export 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;
+        },
+    };
+}
+export function once(cb) {
+    let called = false;
+    return () => {
+        if (!called) {
+            called = true;
+            cb();
+        }
+    };
+}
+export function share(factory) {
+    let cached = null;
+    return (arg) => {
+        if (!cached) {
+            cached = factory(arg);
+        }
+        return cached;
+    };
+}
+export function uniqueId(isNotUsed) {
+    let id;
+    while (!isNotUsed((id = Math.random().toString(16).substr(2)))) { }
+    return id;
+}
+export function isNotSchema(obj) {
+    return obj instanceof GraphQLSchema === false;
+}
+export 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/esm/testing/di.js

@@ -0,0 +1,6 @@
+export function provideEmpty(token) {
+    return {
+        provide: token,
+        useValue: {},
+    };
+}

package/esm/testing/graphql.js

@@ -0,0 +1,7 @@
+export function execute(app, inputs, options) {
+    const executor = app.createExecution(options);
+    return executor({
+        schema: app.schema,
+        ...inputs,
+    });
+}

package/esm/testing/index.js

@@ -0,0 +1,14 @@
+import { mockApplication } from './test-application';
+import { testModule, mockModule } from './test-module';
+import { testInjector, readProviderOptions } from './test-injector';
+import { execute } from './graphql';
+import { provideEmpty } from './di';
+export const testkit = {
+    mockApplication,
+    mockModule,
+    testModule,
+    testInjector,
+    readProviderOptions,
+    provideEmpty,
+    execute,
+};

package/esm/testing/test-application.js

@@ -0,0 +1,62 @@
+import { share } from '../shared/utils';
+export function mockApplication(app) {
+    function mockedFactory(newConfig) {
+        const sharedFactory = 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/esm/testing/test-injector.js

@@ -0,0 +1,18 @@
+import { ReflectiveInjector } from '../di/injector';
+import { CONTEXT } from '../application/tokens';
+import { readInjectableMetadata } from '../di/metadata';
+export function testInjector(providers) {
+    const resolvedProviders = ReflectiveInjector.resolve([
+        { provide: CONTEXT, useValue: {} },
+        ...providers,
+    ]);
+    const injector = ReflectiveInjector.createFromResolved({
+        name: 'test',
+        providers: resolvedProviders,
+    });
+    injector.instantiateAll();
+    return injector;
+}
+export function readProviderOptions(provider) {
+    return readInjectableMetadata(provider, true).options;
+}

package/esm/testing/test-module.js

@@ -0,0 +1,266 @@
+import { visit, Kind, concatAST, } from 'graphql';
+import { moduleFactory } from '../module/factory';
+import { createApplication } from '../application/application';
+import { createModule } from '../module/module';
+export 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 = createModule({
+        ...testedModule.config,
+        providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+    });
+    newModule['ɵoriginalModule'] = testedModule;
+    return newModule;
+}
+export 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 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) => moduleFactory({
+            ...m.config,
+            typeDefs: replaceExtensions(m.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.typeDefs) {
+        transforms.push((m) => moduleFactory({
+            ...m.config,
+            typeDefs: m.typeDefs.concat(config.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.inheritTypeDefs) {
+        transforms.push((m) => 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 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 moduleFactory({
+                ...m.config,
+                providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+            });
+        });
+    }
+    if (transforms) {
+        return transforms.reduce((m, transform) => transform(m), mod);
+    }
+    return mod;
+}
+function inheritTypeDefs(originalTypeDefs, modules) {
+    const original = 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) => {
+        visit(doc, {
+            ObjectTypeDefinition(node) {
+                types.push(node.name.value);
+            },
+        });
+    });
+    // turn object type extensions into object types
+    return typeDefs.map((doc) => {
+        return 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: 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 = concatAST([originalSource].concat(sources));
+    const involvedTypes = new Set(visitTypes(schema, typesToVisit, rootFields));
+    return {
+        kind: 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 !== Kind.SCHEMA_DEFINITION &&
+        def.kind !== Kind.SCHEMA_EXTENSION);
+}
+function visitTypes(schema, types, rootFields) {
+    const visitedTypes = [];
+    const scalars = schema.definitions
+        .filter((def) => def.kind === Kind.SCALAR_TYPE_DEFINITION ||
+        def.kind === 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') &&
+        [
+            Kind.OBJECT_TYPE_DEFINITION,
+            Kind.OBJECT_TYPE_EXTENSION,
+            Kind.INTERFACE_TYPE_DEFINITION,
+            Kind.INTERFACE_TYPE_EXTENSION,
+        ].includes(def.kind));
+}
+function hasTypes(def) {
+    return ([Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION].includes(def.kind) && hasPropValue(def, 'types'));
+}
+function hasFields(def) {
+    return ([
+        Kind.OBJECT_TYPE_DEFINITION,
+        Kind.OBJECT_TYPE_EXTENSION,
+        Kind.INTERFACE_TYPE_DEFINITION,
+        Kind.INTERFACE_TYPE_EXTENSION,
+        Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        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');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-modules",
-  "version": "3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056",
+  "version": "3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {
@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@graphql-tools/schema": "^10.0.0",
-    "@graphql-tools/wrap": "^11.0.0",
+    "@graphql-tools/wrap": "^10.0.0",
     "@graphql-typed-document-node/core": "^3.1.0",
     "ramda": "^0.31.0"
   },
@@ -21,20 +21,40 @@
   ],
   "author": "Kamil Kisiela",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "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": "./*.js",
-      "import": "./*.mjs"
+      "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"
   },

package/typings/application/apollo.d.ts

@@ -0,0 +1,22 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import { ExecutionContextBuilder } from './context';
+import { Application } from './types';
+export interface ApolloRequestContext {
+    document: DocumentNode;
+    operationName?: string | null;
+    context?: any;
+    schema: GraphQLSchema;
+    request: {
+        variables?: {
+            [name: string]: any;
+        } | null;
+    };
+}
+export declare function apolloExecutorCreator({ createExecution, }: {
+    createExecution: Application['createExecution'];
+}): Application['createApolloExecutor'];
+export declare function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }: {
+    createSubscription: Application['createSubscription'];
+    contextBuilder: ExecutionContextBuilder;
+    schema: GraphQLSchema;
+}): () => GraphQLSchema;