@graphql-tools/utils - npm Package Compare versions

Comparing version 5.0.1-alpha-5b99152.0 to 5.0.1-alpha-623711a.0

filterSchema.d.ts

@@ -1,8 +0,8 @@
-import { GraphQLType } from 'graphql';
-import { GraphQLSchemaWithTransforms, RootFieldFilter } from './Interfaces';
+import { GraphQLType, GraphQLSchema } from 'graphql';
+import { RootFieldFilter } from './Interfaces';
 export declare function filterSchema({ schema, rootFieldFilter, typeFilter, fieldFilter, }: {
-    schema: GraphQLSchemaWithTransforms;
+    schema: GraphQLSchema;
     rootFieldFilter?: RootFieldFilter;
     typeFilter?: (typeName: string, type: GraphQLType) => boolean;
     fieldFilter?: (typeName: string, fieldName: string) => boolean;
-}): GraphQLSchemaWithTransforms;
+}): GraphQLSchema;

helpers.d.ts

 import { ASTNode } from 'graphql';
 export declare const asArray: <T>(fns: T | T[]) => T[];
-export declare function chainFunctions(funcs: any[]): any;
 export declare function isEqual<T>(a: T, b: T): boolean;
@@ -8,6 +7,4 @@ export declare function isNotEqual<T>(a: T, b: T): boolean;
 export declare function isValidPath(str: string): boolean;
-export declare function resolveBuiltinModule<Module>(moduleName: string, option?: Module | string): Promise<Module>;
-export declare function resolveBuiltinModuleSync<Module>(moduleName: string, option?: Module | string): Module;
 export declare function compareStrings<A, B>(a: A, b: B): 0 | 1 | -1;
 export declare function nodeToString(a: ASTNode): string;
 export declare function compareNodes(a: ASTNode, b: ASTNode, customFn?: (a: any, b: any) => number): number;

index.d.ts

@@ -12,3 +12,2 @@ export * from './loaders';
 export * from './validate-documents';
-export * from './resolvers-composition';
 export * from './fix-schema-ast';
@@ -31,6 +30,6 @@ export * from './parse-graphql-json';
 export * from './map';
+export * from './rewire';
 export * from './mergeDeep';
 export * from './Interfaces';
 export * from './fieldNodes';
-export * from './resolveFromParentTypename';
 export * from './stub';
@@ -47,1 +46,3 @@ export * from './fragments';
 export * from './implementsAbstractType';
+export * from './errors';
+export * from './toConfig';

Interfaces.d.ts

@@ -1,5 +0,3 @@
-import { GraphQLSchema, GraphQLField, GraphQLInputType, GraphQLNamedType, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLIsTypeOfFn, GraphQLTypeResolver, GraphQLScalarType, DocumentNode, FieldNode, GraphQLEnumValue, GraphQLEnumType, GraphQLUnionType, GraphQLArgument, GraphQLInputField, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, InlineFragmentNode, GraphQLOutputType, SelectionSetNode, GraphQLDirective, GraphQLFieldConfig, FragmentDefinitionNode, SelectionNode, VariableDefinitionNode, OperationDefinitionNode, GraphQLError, ExecutionResult as GraphQLExecutionResult, BuildSchemaOptions } from 'graphql';
+import { GraphQLSchema, GraphQLField, GraphQLInputType, GraphQLNamedType, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLScalarType, DocumentNode, FieldNode, GraphQLEnumValue, GraphQLEnumType, GraphQLUnionType, GraphQLArgument, GraphQLInputField, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, SelectionSetNode, GraphQLDirective, FragmentDefinitionNode, SelectionNode, VariableDefinitionNode, OperationDefinitionNode, GraphQLError, ExecutionResult as GraphQLExecutionResult, GraphQLOutputType, FieldDefinitionNode } from 'graphql';
 import { SchemaVisitor } from './SchemaVisitor';
-import { SchemaDirectiveVisitor } from './SchemaDirectiveVisitor';
-export declare type SchemaDirectiveVisitorClass = typeof SchemaDirectiveVisitor;
 export interface ExecutionResult<TData = Record<string, any>> extends GraphQLExecutionResult {
@@ -34,9 +32,2 @@ data?: TData | null;
 }
-export interface IAddResolveFunctionsToSchemaOptions {
-    schema: GraphQLSchema;
-    resolvers: IResolvers;
-    defaultFieldResolver: IFieldResolver<any, any>;
-    resolverValidationOptions: IResolverValidationOptions;
-    inheritResolversFromInterfaces: boolean;
-}
 export interface IAddResolversToSchemaOptions {
@@ -49,9 +40,33 @@ schema: GraphQLSchema;
 }
-export interface IResolverOptions<TSource = any, TContext = any, TArgs = any> {
-    fragment?: string;
+interface ScalarTypeToResolverMap {
+    name: '__name';
+    description: '__description';
+    serialize: '__serialize';
+    parseValue: '__parseValue';
+    parseLiteral: '__parseLiteral';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
+}
+export declare type IScalarTypeResolver = GraphQLScalarType & Rename<GraphQLScalarType, ScalarTypeToResolverMap>;
+interface EnumTypeToResolverMap {
+    name: '__name';
+    description?: '__description';
+    values: '__values';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
+}
+export declare type IEnumTypeResolver = Record<string, any> & Rename<GraphQLEnumType, EnumTypeToResolverMap>;
+export interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
+    name?: string;
+    description?: string;
+    type?: GraphQLOutputType;
+    args?: Array<GraphQLArgument>;
     resolve?: IFieldResolver<TSource, TContext, TArgs>;
     subscribe?: IFieldResolver<TSource, TContext, TArgs>;
+    isDeprecated?: boolean;
+    deprecationReason?: string;
     extensions?: Record<string, any>;
-    __resolveType?: GraphQLTypeResolver<TSource, TContext>;
-    __isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
+    astNode?: FieldDefinitionNode;
 }
@@ -63,11 +78,4 @@ export interface Transform {
 }
-export declare type FieldTransformer = (typeName: string, fieldName: string, field: GraphQLField<any, any>) => GraphQLFieldConfig<any, any> | RenamedFieldConfig | null | undefined;
-export declare type RootFieldTransformer = (operation: 'Query' | 'Mutation' | 'Subscription', fieldName: string, field: GraphQLField<any, any>) => GraphQLFieldConfig<any, any> | RenamedFieldConfig | null | undefined;
-export declare type FieldNodeTransformer = (typeName: string, fieldName: string, fieldNode: FieldNode, fragments: Record<string, FragmentDefinitionNode>) => SelectionNode | Array<SelectionNode>;
 export declare type FieldNodeMapper = (fieldNode: FieldNode, fragments: Record<string, FragmentDefinitionNode>) => SelectionNode | Array<SelectionNode>;
 export declare type FieldNodeMappers = Record<string, Record<string, FieldNodeMapper>>;
-export interface RenamedFieldConfig {
-    name: string;
-    field?: GraphQLFieldConfig<any, any>;
-}
 export declare type FieldFilter = (typeName?: string, fieldName?: string, field?: GraphQLField<any, any>) => boolean;
@@ -79,89 +87,2 @@ export declare type RootFieldFilter = (operation?: 'Query' | 'Mutation' | 'Subscription', rootFieldName?: string, field?: GraphQLField<any, any>) => boolean;
 };
-declare module 'graphql' {
-    interface GraphQLResolveInfo {
-        mergeInfo?: MergeInfo;
-    }
-}
-export interface ExecutionParams<TArgs = Record<string, any>, TContext = any> {
-    document: DocumentNode;
-    variables?: TArgs;
-    context?: TContext;
-    info?: GraphQLResolveInfo;
-}
-export declare type AsyncExecutor = <TReturn = Record<string, any>, TArgs = Record<string, any>, TContext = Record<string, any>>(params: ExecutionParams<TArgs, TContext>) => Promise<ExecutionResult<TReturn>>;
-export declare type SyncExecutor = <TReturn = Record<string, any>, TArgs = Record<string, any>, TContext = Record<string, any>>(params: ExecutionParams<TArgs, TContext>) => ExecutionResult<TReturn>;
-export declare type Executor = AsyncExecutor | SyncExecutor;
-export declare type Subscriber = <TReturn = Record<string, any>, TArgs = Record<string, any>, TContext = Record<string, any>>(params: ExecutionParams<TArgs, TContext>) => Promise<AsyncIterator<ExecutionResult<TReturn>> | ExecutionResult<TReturn>>;
-export interface SubschemaConfig {
-    schema: GraphQLSchema;
-    rootValue?: Record<string, any>;
-    executor?: Executor;
-    subscriber?: Subscriber;
-    createProxyingResolver?: CreateProxyingResolverFn;
-    transforms?: Array<Transform>;
-    merge?: Record<string, MergedTypeConfig>;
-}
-export interface MergedTypeConfig {
-    selectionSet?: string;
-    fieldName?: string;
-    args?: (originalResult: any) => Record<string, any>;
-    resolve?: MergedTypeResolver;
-}
-export declare type MergedTypeResolver = (originalResult: any, context: Record<string, any>, info: GraphQLResolveInfo, subschema: GraphQLSchema | SubschemaConfig, selectionSet: SelectionSetNode) => any;
-export interface GraphQLSchemaWithTransforms extends GraphQLSchema {
-    transforms?: Array<Transform>;
-}
-export declare type MergeTypeCandidate = {
-    type: GraphQLNamedType;
-    schema?: GraphQLSchema;
-    subschema?: GraphQLSchema | SubschemaConfig;
-    transformedSubschema?: GraphQLSchema;
-};
-export declare type MergeTypeFilter = (mergeTypeCandidates: Array<MergeTypeCandidate>, typeName: string) => boolean;
-export interface IMakeRemoteExecutableSchemaOptions {
-    schema: GraphQLSchema | string;
-    executor?: Executor;
-    subscriber?: Subscriber;
-    createResolver?: (executor: Executor, subscriber: Subscriber) => GraphQLFieldResolver<any, any>;
-    buildSchemaOptions?: BuildSchemaOptions;
-}
-export interface IStitchSchemasOptions {
-    subschemas?: Array<GraphQLSchema | SubschemaConfig>;
-    types?: Array<GraphQLNamedType>;
-    typeDefs?: string | DocumentNode;
-    schemas?: Array<SchemaLikeObject>;
-    onTypeConflict?: OnTypeConflict;
-    resolvers?: IResolversParameter;
-    schemaDirectives?: Record<string, SchemaDirectiveVisitorClass>;
-    inheritResolversFromInterfaces?: boolean;
-    mergeTypes?: boolean | Array<string> | MergeTypeFilter;
-    mergeDirectives?: boolean;
-    queryTypeName?: string;
-    mutationTypeName?: string;
-    subscriptionTypeName?: string;
-}
-export declare type SchemaLikeObject = SubschemaConfig | GraphQLSchema | string | DocumentNode | Array<GraphQLNamedType>;
-export declare function isSubschemaConfig(value: SchemaLikeObject): value is SubschemaConfig;
-export interface IDelegateToSchemaOptions<TContext = Record<string, any>, TArgs = Record<string, any>> {
-    schema: GraphQLSchema | SubschemaConfig;
-    operation?: Operation;
-    fieldName?: string;
-    returnType?: GraphQLOutputType;
-    args?: TArgs;
-    selectionSet?: SelectionSetNode;
-    fieldNodes?: ReadonlyArray<FieldNode>;
-    context?: TContext;
-    info: GraphQLResolveInfo;
-    rootValue?: Record<string, any>;
-    transforms?: Array<Transform>;
-    skipValidation?: boolean;
-    skipTypeMerging?: boolean;
-}
-export interface ICreateRequestFromInfo {
-    info: GraphQLResolveInfo;
-    operation: Operation;
-    fieldName: string;
-    selectionSet?: SelectionSetNode;
-    fieldNodes?: ReadonlyArray<FieldNode>;
-}
 export interface ICreateRequest {
@@ -179,58 +100,52 @@ sourceSchema?: GraphQLSchema;
 }
-export interface IDelegateRequestOptions extends IDelegateToSchemaOptions {
-    request: Request;
-}
-export interface MergeInfo {
-    delegate: (type: 'query' | 'mutation' | 'subscription', fieldName: string, args: Record<string, any>, context: Record<string, any>, info: GraphQLResolveInfo, transforms?: Array<Transform>) => any;
-    fragments: Array<{
-        field: string;
-        fragment: string;
-    }>;
-    replacementSelectionSets: ReplacementSelectionSetMapping;
-    replacementFragments: ReplacementFragmentMapping;
-    mergedTypes: Record<string, MergedTypeInfo>;
-    delegateToSchema<TContext, TArgs>(options: IDelegateToSchemaOptions<TContext, TArgs>): any;
-}
-export interface ReplacementSelectionSetMapping {
-    [typeName: string]: {
-        [fieldName: string]: SelectionSetNode;
-    };
-}
-export interface ReplacementFragmentMapping {
-    [typeName: string]: {
-        [fieldName: string]: InlineFragmentNode;
-    };
-}
-export interface MergedTypeInfo {
-    subschemas: Array<SubschemaConfig>;
-    selectionSet?: SelectionSetNode;
-    uniqueFields: Record<string, SubschemaConfig>;
-    nonUniqueFields: Record<string, Array<SubschemaConfig>>;
-    typeMaps: Map<SubschemaConfig, TypeMap>;
-    selectionSets: Map<SubschemaConfig, SelectionSetNode>;
-    containsSelectionSet: Map<SubschemaConfig, Map<SelectionSetNode, boolean>>;
-}
 export declare type IFieldResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TReturn;
 export declare type ITypedef = (() => Array<ITypedef>) | string | DocumentNode;
 export declare type ITypeDefinitions = ITypedef | Array<ITypedef>;
-export interface IResolverObject<TSource = any, TContext = any, TArgs = any> {
-    [key: string]: IFieldResolver<TSource, TContext, TArgs> | IResolverOptions<TSource, TContext> | IResolverObject<TSource, TContext>;
+interface ObjectTypeToResolverMap {
+    name: '__name';
+    description: '__description';
+    interfaces: '__interfaces';
+    fields: '__fields';
+    isTypeOf: '__isTypeOf';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
 }
-export declare type IEnumResolver = Record<string, string | number>;
-export declare type IResolvers<TSource = any, TContext = any> = Record<string, (() => any) | IResolverObject<TSource, TContext> | IResolverOptions<TSource, TContext> | GraphQLScalarType | IEnumResolver>;
-export declare type IResolversParameter = Array<IResolvers | ((mergeInfo: MergeInfo) => IResolvers)> | IResolvers | ((mergeInfo: MergeInfo) => IResolvers);
-export interface ILogger {
-    log: (error: Error) => void;
+export declare type IObjectTypeResolver<TSource = any, TContext = any, TArgs = any> = {
+    [key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
+} & Rename<GraphQLObjectType<any, any>, ObjectTypeToResolverMap>;
+interface InterfaceTypeToResolverMap {
+    name: '__name';
+    description: '__description';
+    interfaces: '__interfaces';
+    fields: '__fields';
+    resolveType: '__resolveType';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
 }
-export interface IExecutableSchemaDefinition<TContext = any> {
-    typeDefs: ITypeDefinitions;
-    resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
-    logger?: ILogger;
-    allowUndefinedInResolve?: boolean;
-    resolverValidationOptions?: IResolverValidationOptions;
-    directiveResolvers?: IDirectiveResolvers<any, TContext>;
-    schemaDirectives?: Record<string, SchemaDirectiveVisitorClass>;
-    parseOptions?: GraphQLParseOptions;
-    inheritResolversFromInterfaces?: boolean;
+export declare type IInterfaceTypeResolver<TSource = any, TContext = any, TArgs = any> = {
+    [key: string]: IFieldResolver<TSource, TContext, TArgs> | IFieldResolverOptions<TSource, TContext>;
+} & Rename<GraphQLInterfaceType, InterfaceTypeToResolverMap>;
+interface UnionTypeToResolverMap {
+    name: '__name';
+    description: '__description';
+    types: '__types';
+    resolveType: '__resolveType';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
 }
+export declare type IUnionTypeResolver = Rename<GraphQLUnionType, UnionTypeToResolverMap>;
+export interface InputObjectTypeToResolverMap {
+    name: '__name';
+    description: '__description';
+    fields: '__fields';
+    extensions: '__extensions';
+    astNode: '__astNode';
+    extensionASTNodes: '__extensionASTNodes';
+}
+export declare type IInputObjectTypeResolver = Rename<GraphQLInputObjectType, InputObjectTypeToResolverMap>;
+export declare type ISchemaLevelResolver<TSource, TContext, TArgs = Record<string, any>, TReturn = any> = IFieldResolver<TSource, TContext, TArgs, TReturn>;
+export declare type IResolvers<TSource = any, TContext = any, TArgs = Record<string, any>, TReturn = any> = Record<string, ISchemaLevelResolver<TSource, TContext, TArgs, TReturn> | IObjectTypeResolver<TSource, TContext> | IInterfaceTypeResolver<TSource, TContext> | IUnionTypeResolver | IScalarTypeResolver | IEnumTypeResolver | IInputObjectTypeResolver>;
 export declare type IFieldIteratorFn = (fieldDef: GraphQLField<any, any>, typeName: string, fieldName: string) => void;
@@ -245,10 +160,2 @@ export declare type IDefaultValueIteratorFn = (type: GraphQLInputType, value: any) => void;
 }
-export declare type OnTypeConflict = (left: GraphQLNamedType, right: GraphQLNamedType, info?: {
-    left: {
-        schema?: GraphQLSchema | SubschemaConfig;
-    };
-    right: {
-        schema?: GraphQLSchema | SubschemaConfig;
-    };
-}) => GraphQLNamedType;
 export declare type Operation = 'query' | 'mutation' | 'subscription';
@@ -260,3 +167,2 @@ export interface Request {
 }
-export declare type IndexedObject<V> = Record<string, V> | ReadonlyArray<V>;
 export declare type VisitableSchemaType = GraphQLSchema | GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType | GraphQLNamedType | GraphQLScalarType | GraphQLField<any, any> | GraphQLInputField | GraphQLArgument | GraphQLUnionType | GraphQLEnumType | GraphQLEnumValue;
@@ -345,2 +251,2 @@ export declare type VisitorSelector = (type: VisitableSchemaType, methodName: string) => Array<SchemaVisitor | SchemaVisitorMap>;
 export declare type DirectiveMapper = (directive: GraphQLDirective, schema: GraphQLSchema) => GraphQLDirective | null | undefined;
-export declare type CreateProxyingResolverFn = (schema: GraphQLSchema | SubschemaConfig, transforms: Array<Transform>, operation: Operation, fieldName: string) => GraphQLFieldResolver<any, any>;
+export {};

loaders.d.ts

 import { DocumentNode, GraphQLSchema, ParseOptions, BuildSchemaOptions } from 'graphql';
 import { GraphQLSchemaValidationOptions } from 'graphql/type/schema';
-export declare class Source {
+export interface Source {
     document?: DocumentNode;
@@ -8,7 +8,2 @@ schema?: GraphQLSchema;
     location?: string;
-    constructor({ document, location, schema }: {
-        document?: DocumentNode;
-        location?: string;
-        schema?: GraphQLSchema;
-    });
 }
@@ -15,0 +10,0 @@ export declare type SingleFileOptions = ParseOptions & GraphQLSchemaValidationOptions & BuildSchemaOptions & {

map.d.ts

@@ -1,7 +0,3 @@
-import { GraphQLDirective, GraphQLNamedType, GraphQLSchema } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { SchemaMapper } from './Interfaces';
 export declare function mapSchema(schema: GraphQLSchema, schemaMapper?: SchemaMapper): GraphQLSchema;
-export declare function rewireTypes(originalTypeMap: Record<string, GraphQLNamedType | null>, directives: ReadonlyArray<GraphQLDirective>): {
-    typeMap: Record<string, GraphQLNamedType>;
-    directives: Array<GraphQLDirective>;
-};

package.json

 {
   "name": "@graphql-tools/utils",
-  "version": "5.0.1-alpha-5b99152.0",
+  "version": "5.0.1-alpha-623711a.0",
   "description": "Common package containting utils and types for GraphQL tools",
@@ -9,5 +9,3 @@ "peerDependencies": {
   "dependencies": {
-    "aggregate-error": "3.0.1",
-    "camel-case": "4.1.1",
-    "lodash": "4.17.15"
+    "camel-case": "4.1.1"
   },
@@ -24,5 +22,5 @@ "repository": "[e-mail]:ardatan/graphql-tools.git",
   "devDependencies": {
-    "@types/aggregate-error": "1.0.1",
-    "graphql-scalars": "1.1.2",
-    "iterall": "1.3.0"
+    "@types/dateformat": "3.0.1",
+    "dateformat": "3.0.3",
+    "graphql-scalars": "1.1.2"
   },
@@ -29,0 +27,0 @@ "publishConfig": {

SchemaDirectiveVisitor.d.ts

 import { GraphQLDirective, GraphQLSchema } from 'graphql';
-import { VisitableSchemaType, SchemaDirectiveVisitorClass } from './Interfaces';
+import { VisitableSchemaType } from './Interfaces';
 import { SchemaVisitor } from './SchemaVisitor';
+export declare type SchemaDirectiveVisitorClass = typeof SchemaDirectiveVisitor;
 export declare class SchemaDirectiveVisitor<TArgs = any, TContext = any> extends SchemaVisitor {
@@ -5,0 +6,0 @@ name: string;

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Improved metrics

Dependency count

2

decreased by-50%

Number of package files

53

increased by1.92%

Number of low supply chain risk alerts

7

decreased by-46.15%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Total package byte prevSize

684848

decreased by-3.14%

Lines of code

6239

decreased by-4.18%

Published versions last year

147

decreased by-2.65%

Dependency changes

• - Removedaggregate-error@3.0.1

• - Removedlodash@4.17.15

• - Removedaggregate-error@3.0.1(transitive)

• - Removedclean-stack@2.2.0(transitive)

• - Removedindent-string@4.0.0(transitive)

• - Removedlodash@4.17.15(transitive)