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

package/typings/shared/errors.d.ts

@@ -0,0 +1,36 @@
+import { ID } from './types';
+declare const ModuleNonUniqueIdError_base: ErrorConstructor;
+export declare class ModuleNonUniqueIdError extends ModuleNonUniqueIdError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ModuleDuplicatedError_base: ErrorConstructor;
+export declare class ModuleDuplicatedError extends ModuleDuplicatedError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ExtraResolverError_base: ErrorConstructor;
+export declare class ExtraResolverError extends ExtraResolverError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ExtraMiddlewareError_base: ErrorConstructor;
+export declare class ExtraMiddlewareError extends ExtraMiddlewareError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ResolverDuplicatedError_base: ErrorConstructor;
+export declare class ResolverDuplicatedError extends ResolverDuplicatedError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const ResolverInvalidError_base: ErrorConstructor;
+export declare class ResolverInvalidError extends ResolverInvalidError_base {
+    constructor(message: string, ...rest: string[]);
+}
+declare const NonDocumentNodeError_base: ErrorConstructor;
+export declare class NonDocumentNodeError extends NonDocumentNodeError_base {
+    constructor(message: string, ...rest: string[]);
+}
+export declare function useLocation({ dirname, id }: {
+    id: ID;
+    dirname?: string;
+}): string;
+export declare function ExtendableBuiltin<T extends Function>(cls: T): T;
+export declare function composeMessage(...lines: string[]): string;
+export {};

package/typings/shared/gql.d.ts

@@ -0,0 +1,2 @@
+import { DocumentNode } from 'graphql';
+export declare function gql(literals: ReadonlyArray<string> | Readonly<string>): DocumentNode;

package/typings/shared/middleware.d.ts

@@ -0,0 +1,21 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { ModuleMetadata } from './../module/metadata';
+export type Next<T = any> = () => Promise<T>;
+export type Middleware<TContext = MiddlewareContext> = (context: TContext, next: Next) => Promise<any>;
+export declare function compose<TContext>(middleware: Array<Middleware<TContext>>): (context: TContext, next: Next) => Promise<any>;
+export interface MiddlewareContext {
+    root: any;
+    args: {
+        [argName: string]: any;
+    };
+    context: GraphQLModules.ModuleContext;
+    info: GraphQLResolveInfo;
+}
+export type MiddlewareMap = {
+    [type: string]: {
+        [field: string]: Middleware[];
+    };
+};
+export declare function createMiddleware(path: string[], middlewareMap?: MiddlewareMap): (context: MiddlewareContext, next: Next) => Promise<any>;
+export declare function mergeMiddlewareMaps(app: MiddlewareMap, mod: MiddlewareMap): MiddlewareMap;
+export declare function validateMiddlewareMap(middlewareMap: MiddlewareMap, metadata: ModuleMetadata): void;

package/typings/shared/types.d.ts

@@ -0,0 +1,22 @@
+import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql';
+import { Injector } from '../di';
+export type ID = string;
+export type Nil = undefined | null;
+export type Maybe<T> = T | Nil;
+export type Plural<T> = T | T[];
+export type Single<T> = T extends Array<infer R> ? R : T;
+export type ValueOrPromise<T> = T | Promise<T>;
+export type ResolveFn<TContext = GraphQLModules.Context> = GraphQLFieldResolver<any, TContext, Record<string, any>>;
+export type ResolveTypeFn<TContext = GraphQLModules.Context> = GraphQLTypeResolver<any, TContext>;
+declare global {
+    namespace GraphQLModules {
+        type ModuleContext = {
+            injector: Injector;
+            moduleId: ID;
+        } & GlobalContext;
+        type AppContext = Omit<ModuleContext, 'moduleId'>;
+        type Context = ModuleContext;
+        interface GlobalContext {
+        }
+    }
+}

package/typings/shared/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function flatten<T>(arr: T[]): T extends (infer A)[] ? A[] : T[];
+export declare function isDefined<T>(val: T | null | undefined): val is T;
+export declare function isNil<T>(val: T | null | undefined): val is null | undefined;
+export declare function isObject(val: any): boolean;
+export declare function isPrimitive(val: any): val is number | string | boolean | symbol | bigint;
+export declare function isAsyncIterable(obj: any): obj is AsyncIterableIterator<any>;
+export declare function tapAsyncIterator<T, TAsyncIterableIterator extends AsyncIterableIterator<T>>(iterable: TAsyncIterableIterator, doneCallback: () => void): TAsyncIterableIterator;
+export declare function once(cb: () => void): () => void;
+export declare function share<T, A>(factory: (arg?: A) => T): (arg?: A) => T;
+export declare function uniqueId(isNotUsed: (id: string) => boolean): string;
+export declare function isNotSchema<T>(obj: any): obj is T;
+export declare function merge<S extends object, T extends object>(source: S, target: T): S & T;

package/typings/testing/di.d.ts

@@ -0,0 +1,2 @@
+import { ValueProvider } from './../di/providers';
+export declare function provideEmpty<T = any>(token: ValueProvider<T>['provide']): ValueProvider<T>;

package/typings/testing/graphql.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentNode, ExecutionArgs, ExecutionResult } from 'graphql';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { Application, OperationController } from '../application/types';
+import type { ValueOrPromise } from '../shared/types';
+export declare function execute<TResult = {
+    [key: string]: any;
+}, TVariables = {
+    [key: string]: any;
+}>(app: Application, inputs: Omit<ExecutionArgs, 'schema'> & {
+    document: DocumentNode | TypedDocumentNode<TResult, TVariables>;
+    variableValues?: TVariables;
+}, options?: {
+    controller?: OperationController;
+}): ValueOrPromise<ExecutionResult<TResult>>;

package/typings/testing/index.d.ts

@@ -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 declare const testkit: {
+    mockApplication: typeof mockApplication;
+    mockModule: typeof mockModule;
+    testModule: typeof testModule;
+    testInjector: typeof testInjector;
+    readProviderOptions: typeof readProviderOptions;
+    provideEmpty: typeof provideEmpty;
+    execute: typeof execute;
+};

package/typings/testing/test-application.d.ts

@@ -0,0 +1,2 @@
+import { Application, MockedApplication } from '../application/types';
+export declare function mockApplication(app: Application): MockedApplication;

package/typings/testing/test-injector.d.ts

@@ -0,0 +1,4 @@
+import { Injector } from '../di/injector';
+import { Provider, TypeProvider } from '../di/providers';
+export declare function testInjector(providers: Provider[]): Injector;
+export declare function readProviderOptions<T>(provider: TypeProvider<T>): import("../di/providers").ProviderOptions | undefined;

package/typings/testing/test-module.d.ts

@@ -0,0 +1,10 @@
+import { ApplicationConfig } from '../application/types';
+import { MockedModule, Module, ModuleConfig } from '../module/types';
+type TestModuleConfig = {
+    replaceExtensions?: boolean;
+    inheritTypeDefs?: Module[];
+} & Partial<Pick<ApplicationConfig, 'providers' | 'modules' | 'middlewares' | 'schemaBuilder'>> & Partial<Pick<ModuleConfig, 'typeDefs' | 'resolvers'>>;
+type MockModuleConfig = Partial<Pick<ModuleConfig, 'providers'>>;
+export declare function mockModule(testedModule: Module, overrideConfig: MockModuleConfig): MockedModule;
+export declare function testModule(testedModule: Module, config?: TestModuleConfig): import("../application/types").Application;
+export {};

package/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 Uri Goldshtein
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.