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

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-20260121025807-95ab4fb1994c3cf68c88a7cf234efd8f99f92ed1",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {
@@ -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;

package/typings/application/application.d.ts

@@ -0,0 +1,32 @@
+import { ResolvedModule } from '../module/factory';
+import { ID } from '../shared/types';
+import { ApplicationConfig, Application } from './types';
+export type ModulesMap = Map<ID, ResolvedModule>;
+/**
+ * @internal
+ */
+export interface InternalAppContext {
+    ɵgetModuleContext(moduleId: ID, context: GraphQLModules.GlobalContext): GraphQLModules.ModuleContext;
+}
+/**
+ * @api
+ * Creates Application out of Modules. Accepts `ApplicationConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createApplication } from 'graphql-modules';
+ * import { usersModule } from './users';
+ * import { postsModule } from './posts';
+ * import { commentsModule } from './comments';
+ *
+ * const app = createApplication({
+ *   modules: [
+ *     usersModule,
+ *     postsModule,
+ *     commentsModule
+ *   ]
+ * })
+ * ```
+ */
+export declare function createApplication(applicationConfig: ApplicationConfig): Application;

package/typings/application/context.d.ts

@@ -0,0 +1,24 @@
+import { Injector, ReflectiveInjector } from '../di';
+import { ResolvedProvider } from '../di/resolution';
+import type { InternalAppContext, ModulesMap } from './application';
+export type ExecutionContextBuilder<TContext extends {
+    [key: string]: any;
+} = {}> = (context: TContext) => ExecutionContextEnv & {
+    runWithContext<TReturn = any>(cb: (env: ExecutionContextEnv) => TReturn): TReturn;
+};
+export type ExecutionContextEnv = {
+    context: InternalAppContext;
+    ɵdestroy(): void;
+    ɵinjector: Injector;
+};
+export declare function createContextBuilder({ appInjector, modulesMap, appLevelOperationProviders, singletonGlobalProvidersMap, operationGlobalProvidersMap, }: {
+    appInjector: ReflectiveInjector;
+    appLevelOperationProviders: ResolvedProvider[];
+    singletonGlobalProvidersMap: {
+        [key: string]: string;
+    };
+    operationGlobalProvidersMap: {
+        [key: string]: string;
+    };
+    modulesMap: ModulesMap;
+}): ExecutionContextBuilder<GraphQLModules.GlobalContext>;

package/typings/application/di.d.ts

@@ -0,0 +1,22 @@
+import { ModulesMap } from './application';
+import { ResolvedModule } from '../module/factory';
+import { ReflectiveInjector, Scope } from '../di';
+import { ResolvedProvider } from '../di/resolution';
+export declare function instantiateSingletonProviders({ appInjector, modulesMap, }: {
+    appInjector: ReflectiveInjector;
+    modulesMap: ModulesMap;
+}): void;
+export declare function createGlobalProvidersMap({ modules, scope, }: {
+    modules: ResolvedModule[];
+    scope: Scope;
+}): {
+    [key: string]: string;
+};
+export declare function attachGlobalProvidersMap({ injector, globalProvidersMap, moduleInjectorGetter, }: {
+    injector: ReflectiveInjector;
+    globalProvidersMap: {
+        [key: string]: string;
+    };
+    moduleInjectorGetter: (moduleId: string) => ReflectiveInjector;
+}): void;
+export declare function duplicatedGlobalTokenError(provider: ResolvedProvider, modules: [string, string]): Error;

package/typings/application/execution.d.ts

@@ -0,0 +1,8 @@
+import { execute } from 'graphql';
+import { ExecutionContextBuilder } from './context';
+export declare function executionCreator({ contextBuilder, }: {
+    contextBuilder: ExecutionContextBuilder;
+}): (options?: {
+    execute?: typeof execute;
+    controller?: import("./types").OperationController;
+}) => typeof execute;

package/typings/application/operation-controller.d.ts

@@ -0,0 +1,5 @@
+import type { Application } from './types';
+import type { ExecutionContextBuilder } from './context';
+export declare function operationControllerCreator(options: {
+    contextBuilder: ExecutionContextBuilder<GraphQLModules.GlobalContext>;
+}): Application['createOperationController'];

package/typings/application/subscription.d.ts

@@ -0,0 +1,8 @@
+import { subscribe } from 'graphql';
+import { ExecutionContextBuilder } from './context';
+export declare function subscriptionCreator({ contextBuilder, }: {
+    contextBuilder: ExecutionContextBuilder;
+}): (options?: {
+    subscribe?: typeof subscribe;
+    controller?: import("./types").OperationController;
+}) => typeof subscribe;

package/typings/application/tokens.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `CONTEXT` is an InjectionToken representing the provided `GraphQLModules.GlobalContext`
+ *
+ * @example
+ *
+ * ```typescript
+ * import { CONTEXT, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(CONTEXT) private context: GraphQLModules.GlobalContext) {}
+ * }
+ * ```
+ */
+export declare const CONTEXT: InjectionToken<any>;