graphql-modules 2.1.1-alpha-20230315172414-5cdc10bb → 2.1.2-alpha-20230322123421-666fe713

package/application/application.d.ts

@@ -1,7 +1,7 @@
 import { ResolvedModule } from '../module/factory';
 import { ID } from '../shared/types';
 import { ApplicationConfig, Application } from './types';
-export declare type ModulesMap = Map<ID, ResolvedModule>;
+export type ModulesMap = Map<ID, ResolvedModule>;
 /**
  * @internal
  */

package/application/context.d.ts

@@ -1,7 +1,7 @@
 import { Injector, ReflectiveInjector } from '../di';
 import { ResolvedProvider } from '../di/resolution';
 import type { InternalAppContext, ModulesMap } from './application';
-export declare type ExecutionContextBuilder<TContext extends {
+export type ExecutionContextBuilder<TContext extends {
     [key: string]: any;
 } = {}> = (context: TContext) => {
     context: InternalAppContext;

package/application/types.d.ts

@@ -5,9 +5,9 @@ import type { MiddlewareMap } from '../shared/middleware';
 import type { ApolloRequestContext } from './apollo';
 import type { Single } from '../shared/types';
 import type { InternalAppContext } from './application';
-declare type Execution = typeof execute;
-declare type Subscription = typeof subscribe;
-export declare type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
+type Execution = typeof execute;
+type Subscription = typeof subscribe;
+export type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
 export interface MockedApplication extends Application {
     replaceModule(mockedModule: MockedModule): MockedApplication;
     addProviders(providers: ApplicationConfig['providers']): MockedApplication;

package/di/decorators.d.ts

@@ -1,9 +1,11 @@
 import { Type, ProviderOptions, InjectionToken } from './providers';
 import { Injector } from './injector';
 export declare function Injectable(options?: ProviderOptions): ClassDecorator;
+type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
 export declare function Optional(): ParameterDecorator;
 export declare function Inject(type: Type<any> | InjectionToken<any>): ParameterDecorator;
-export declare type ExecutionContext = {
+export type ExecutionContext = {
     injector: Injector;
 } & GraphQLModules.ModuleContext;
 export declare function ExecutionContext(): PropertyDecorator;
+export {};

package/di/forward-ref.d.ts

@@ -1,5 +1,5 @@
 import { Type } from './providers';
-export declare type ForwardRefFn<T> = () => T;
+export type ForwardRefFn<T> = () => T;
 /**
  * Useful in "circular dependencies of modules" situation
  */

package/di/injector.d.ts

@@ -2,7 +2,7 @@ import { Type, InjectionToken, Provider } from './providers';
 import { ResolvedProvider, GlobalProviderMap } from './resolution';
 import { Key } from './registry';
 import { ExecutionContext } from './decorators';
-declare type ExecutionContextGetter = () => ExecutionContext | never;
+type ExecutionContextGetter = () => ExecutionContext | never;
 export declare abstract class Injector {
     abstract get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: any): T;
 }

package/di/providers.d.ts

@@ -18,7 +18,7 @@ export interface ValueProvider<T> extends BaseProvider<T> {
 export interface ClassProvider<T> extends BaseProvider<T> {
     useClass: Type<T>;
 }
-export declare type Factory<T> = (...args: any[]) => T;
+export type Factory<T> = (...args: any[]) => T;
 export interface FactoryProvider<T> extends BaseProvider<T> {
     useFactory: Factory<T>;
     deps?: any[];
@@ -28,7 +28,7 @@ export interface BaseProvider<T> extends ProviderOptions {
 }
 export interface TypeProvider<T> extends Type<T> {
 }
-export declare type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
 export interface ProviderOptions {
     scope?: Scope;
     executionContextIn?: Array<string | symbol>;

package/di/resolution.d.ts

@@ -1,8 +1,8 @@
 import { Provider, ValueProvider, ClassProvider, FactoryProvider } from './providers';
 import { Key } from './registry';
 import { ReflectiveInjector } from './injector';
-export declare type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
-export declare type GlobalProviderMap = {
+export type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type GlobalProviderMap = {
     has(key: Key['id']): boolean;
     get(key: Key['id']): ReflectiveInjector;
 };

package/module/factory.d.ts

@@ -3,13 +3,13 @@ import { ReflectiveInjector } from '../di';
 import { ResolvedProvider } from './../di/resolution';
 import { MiddlewareMap } from '../shared/middleware';
 import { Single } from '../shared/types';
-export declare type ResolvedModule = {
+export type ResolvedModule = {
     injector: ReflectiveInjector;
     singletonProviders: Array<ResolvedProvider>;
     operationProviders: Array<ResolvedProvider>;
     resolvers?: Single<Resolvers>;
 } & Omit<Module, 'factory'>;
-export declare type ModuleFactory = (app: {
+export type ModuleFactory = (app: {
     injector: ReflectiveInjector;
     middlewares: MiddlewareMap;
 }) => ResolvedModule;

package/module/metadata.d.ts

@@ -1,7 +1,7 @@
 import { DocumentNode } from 'graphql';
 import { ModuleConfig } from './types';
 import { ID } from '../shared/types';
-export declare type Registry = Record<string, string[]>;
+export type Registry = Record<string, string[]>;
 export interface ModuleMetadata {
     id: ID;
     typeDefs: DocumentNode[];

package/module/types.d.ts

@@ -5,8 +5,8 @@ import { ModuleMetadata } from './metadata';
 import { Provider } from '../di';
 import { MiddlewareMap } from '../shared/middleware';
 import { ResolvedProvider } from '../di/resolution';
-export declare type TypeDefs = Plural<DocumentNode>;
-export declare type Resolvers = Plural<Record<string, any>>;
+export type TypeDefs = Plural<DocumentNode>;
+export type Resolvers = Plural<Record<string, any>>;
 /**
  * @api
  * Module's configuration object. Represents the first argument of `createModule` function.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-modules",
-  "version": "2.1.1-alpha-20230315172414-5cdc10bb",
+  "version": "2.1.2-alpha-20230322123421-666fe713",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {

package/shared/middleware.d.ts

@@ -1,7 +1,7 @@
 import { GraphQLResolveInfo } from 'graphql';
 import { ModuleMetadata } from './../module/metadata';
-export declare type Next<T = any> = () => Promise<T>;
-export declare type Middleware<TContext = MiddlewareContext> = (context: TContext, next: Next) => Promise<any>;
+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;
@@ -11,7 +11,7 @@ export interface MiddlewareContext {
     context: GraphQLModules.ModuleContext;
     info: GraphQLResolveInfo;
 }
-export declare type MiddlewareMap = {
+export type MiddlewareMap = {
     [type: string]: {
         [field: string]: Middleware[];
     };

package/shared/types.d.ts

@@ -1,13 +1,13 @@
 import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql';
 import { Injector } from '../di';
-export declare type ID = string;
-export declare type Nil = undefined | null;
-export declare type Maybe<T> = T | Nil;
-export declare type Plural<T> = T | T[];
-export declare type Single<T> = T extends Array<infer R> ? R : T;
-export declare type ValueOrPromise<T> = T | Promise<T>;
-export declare type ResolveFn<TContext = GraphQLModules.Context> = GraphQLFieldResolver<any, TContext, Record<string, any>>;
-export declare type ResolveTypeFn<TContext = GraphQLModules.Context> = GraphQLTypeResolver<any, TContext>;
+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 = {

package/testing/test-module.d.ts

@@ -1,10 +1,10 @@
 import { ApplicationConfig } from '../application/types';
 import { MockedModule, Module, ModuleConfig } from '../module/types';
-declare type TestModuleConfig = {
+type TestModuleConfig = {
     replaceExtensions?: boolean;
     inheritTypeDefs?: Module[];
 } & Partial<Pick<ApplicationConfig, 'providers' | 'modules' | 'middlewares' | 'schemaBuilder'>> & Partial<Pick<ModuleConfig, 'typeDefs' | 'resolvers'>>;
-declare type MockModuleConfig = Partial<Pick<ModuleConfig, 'providers'>>;
+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 {};