@graphql-inspector/core 4.0.2 → 4.0.3

package/typings/diff/changes/field.d.cts

@@ -0,0 +1,15 @@
+import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function fieldRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>): Change;
+export declare function fieldAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>): Change;
+export declare function fieldDescriptionChanged(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any>, newField: GraphQLField<any, any>): Change;
+export declare function fieldDescriptionAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldDescriptionRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldDeprecationAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldDeprecationRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldDeprecationReasonChanged(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any>, newField: GraphQLField<any, any>): Change;
+export declare function fieldDeprecationReasonAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldDeprecationReasonRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any>): Change;
+export declare function fieldTypeChanged(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any, any>, newField: GraphQLField<any, any, any>): Change;
+export declare function fieldArgumentAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, arg: GraphQLArgument): Change;
+export declare function fieldArgumentRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, arg: GraphQLArgument): Change;

package/{diff → typings/diff}/changes/field.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function fieldRemoved(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>): Change;
 export declare function fieldAdded(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>): Change;
 export declare function fieldDescriptionChanged(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any>, newField: GraphQLField<any, any>): Change;

package/typings/diff/changes/input.d.cts

@@ -0,0 +1,9 @@
+import { GraphQLInputField, GraphQLInputObjectType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function inputFieldRemoved(input: GraphQLInputObjectType, field: GraphQLInputField): Change;
+export declare function inputFieldAdded(input: GraphQLInputObjectType, field: GraphQLInputField): Change;
+export declare function inputFieldDescriptionAdded(type: GraphQLInputObjectType, field: GraphQLInputField): Change;
+export declare function inputFieldDescriptionRemoved(type: GraphQLInputObjectType, field: GraphQLInputField): Change;
+export declare function inputFieldDescriptionChanged(input: GraphQLInputObjectType, oldField: GraphQLInputField, newField: GraphQLInputField): Change;
+export declare function inputFieldDefaultValueChanged(input: GraphQLInputObjectType, oldField: GraphQLInputField, newField: GraphQLInputField): Change;
+export declare function inputFieldTypeChanged(input: GraphQLInputObjectType, oldField: GraphQLInputField, newField: GraphQLInputField): Change;

package/{diff → typings/diff}/changes/input.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLInputField, GraphQLInputObjectType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function inputFieldRemoved(input: GraphQLInputObjectType, field: GraphQLInputField): Change;
 export declare function inputFieldAdded(input: GraphQLInputObjectType, field: GraphQLInputField): Change;
 export declare function inputFieldDescriptionAdded(type: GraphQLInputObjectType, field: GraphQLInputField): Change;

package/typings/diff/changes/object.d.cts

@@ -0,0 +1,4 @@
+import { GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function objectTypeInterfaceAdded(iface: GraphQLInterfaceType, type: GraphQLObjectType): Change;
+export declare function objectTypeInterfaceRemoved(iface: GraphQLInterfaceType, type: GraphQLObjectType): Change;

package/{diff → typings/diff}/changes/object.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function objectTypeInterfaceAdded(iface: GraphQLInterfaceType, type: GraphQLObjectType): Change;
 export declare function objectTypeInterfaceRemoved(iface: GraphQLInterfaceType, type: GraphQLObjectType): Change;

package/typings/diff/changes/schema.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLSchema } from 'graphql';
+import { Change } from './change.cjs';
+export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;
+export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;
+export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;

package/{diff → typings/diff}/changes/schema.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;
 export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;
 export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change;

package/typings/diff/changes/type.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLNamedType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function typeRemoved(type: GraphQLNamedType): Change;
+export declare function typeAdded(type: GraphQLNamedType): Change;
+export declare function typeKindChanged(oldType: GraphQLNamedType, newType: GraphQLNamedType): Change;
+export declare function typeDescriptionChanged(oldType: GraphQLNamedType, newType: GraphQLNamedType): Change;
+export declare function typeDescriptionRemoved(type: GraphQLNamedType): Change;
+export declare function typeDescriptionAdded(type: GraphQLNamedType): Change;

package/{diff → typings/diff}/changes/type.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLNamedType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function typeRemoved(type: GraphQLNamedType): Change;
 export declare function typeAdded(type: GraphQLNamedType): Change;
 export declare function typeKindChanged(oldType: GraphQLNamedType, newType: GraphQLNamedType): Change;

package/typings/diff/changes/union.d.cts

@@ -0,0 +1,4 @@
+import { GraphQLObjectType, GraphQLUnionType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function unionMemberRemoved(union: GraphQLUnionType, type: GraphQLObjectType): Change;
+export declare function unionMemberAdded(union: GraphQLUnionType, type: GraphQLObjectType): Change;

package/{diff → typings/diff}/changes/union.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLObjectType, GraphQLUnionType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function unionMemberRemoved(union: GraphQLUnionType, type: GraphQLObjectType): Change;
 export declare function unionMemberAdded(union: GraphQLUnionType, type: GraphQLObjectType): Change;

package/typings/diff/directive.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLDirective } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInDirective(oldDirective: GraphQLDirective, newDirective: GraphQLDirective, addChange: AddChange): void;

package/{diff → typings/diff}/directive.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLDirective } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInDirective(oldDirective: GraphQLDirective, newDirective: GraphQLDirective, addChange: AddChange): void;

package/typings/diff/enum.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLEnumType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInEnum(oldEnum: GraphQLEnumType, newEnum: GraphQLEnumType, addChange: AddChange): void;

package/{diff → typings/diff}/enum.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLEnumType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInEnum(oldEnum: GraphQLEnumType, newEnum: GraphQLEnumType, addChange: AddChange): void;

package/typings/diff/field.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInField(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any>, newField: GraphQLField<any, any>, addChange: AddChange): void;

package/{diff → typings/diff}/field.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInField(type: GraphQLObjectType | GraphQLInterfaceType, oldField: GraphQLField<any, any>, newField: GraphQLField<any, any>, addChange: AddChange): void;

package/typings/diff/index.d.cts

@@ -0,0 +1,9 @@
+import { GraphQLSchema } from 'graphql';
+import { Change } from './changes/change.cjs';
+import * as rules from './rules/index.cjs';
+import { Rule } from './rules/types.cjs';
+export * from './rules/types.cjs';
+export declare const DiffRule: typeof rules;
+export * from './onComplete/types.cjs';
+export type { UsageHandler } from './rules/consider-usage.cjs';
+export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[], config?: rules.ConsiderUsageConfig): Promise<Change[]>;

package/typings/diff/index.d.ts

@@ -0,0 +1,9 @@
+import { GraphQLSchema } from 'graphql';
+import { Change } from './changes/change.js';
+import * as rules from './rules/index.js';
+import { Rule } from './rules/types.js';
+export * from './rules/types.js';
+export declare const DiffRule: typeof rules;
+export * from './onComplete/types.js';
+export type { UsageHandler } from './rules/consider-usage.js';
+export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[], config?: rules.ConsiderUsageConfig): Promise<Change[]>;

package/typings/diff/input.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLInputObjectType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInInputObject(oldInput: GraphQLInputObjectType, newInput: GraphQLInputObjectType, addChange: AddChange): void;

package/{diff → typings/diff}/input.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLInputObjectType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInInputObject(oldInput: GraphQLInputObjectType, newInput: GraphQLInputObjectType, addChange: AddChange): void;

package/typings/diff/interface.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLInterfaceType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInInterface(oldInterface: GraphQLInterfaceType, newInterface: GraphQLInterfaceType, addChange: AddChange): void;

package/{diff → typings/diff}/interface.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLInterfaceType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInInterface(oldInterface: GraphQLInterfaceType, newInterface: GraphQLInterfaceType, addChange: AddChange): void;

package/typings/diff/object.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLObjectType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInObject(oldType: GraphQLObjectType, newType: GraphQLObjectType, addChange: AddChange): void;

package/{diff → typings/diff}/object.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLObjectType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInObject(oldType: GraphQLObjectType, newType: GraphQLObjectType, addChange: AddChange): void;

package/typings/diff/onComplete/types.d.cts

@@ -0,0 +1,7 @@
+import { Change } from '../changes/change.cjs';
+export type CompletionArgs = {
+    breakingChanges: Change[];
+    dangerousChanges: Change[];
+    nonBreakingChanges: Change[];
+};
+export type CompletionHandler = (args: CompletionArgs) => void;

package/typings/diff/onComplete/types.d.ts

@@ -0,0 +1,7 @@
+import { Change } from '../changes/change.js';
+export type CompletionArgs = {
+    breakingChanges: Change[];
+    dangerousChanges: Change[];
+    nonBreakingChanges: Change[];
+};
+export type CompletionHandler = (args: CompletionArgs) => void;

package/typings/diff/rules/config.d.cts

@@ -0,0 +1,2 @@
+import { ConsiderUsageConfig } from './consider-usage.cjs';
+export type Config = ConsiderUsageConfig;

package/typings/diff/rules/config.d.ts

@@ -0,0 +1,2 @@
+import { ConsiderUsageConfig } from './consider-usage.js';
+export type Config = ConsiderUsageConfig;

package/typings/diff/rules/consider-usage.d.cts

@@ -0,0 +1,29 @@
+import { Rule } from './types.cjs';
+export type UsageHandler = (input: Array<{
+    type: string;
+    field?: string;
+    argument?: string;
+}>) => Promise<boolean[]>;
+export interface ConsiderUsageConfig {
+    /**
+     * Checks if it's safe to introduce a breaking change on a field
+     *
+     * Because the function is async and resolves to a boolean value
+     * you can add pretty much anything here, many different conditions or
+     * even any source of data.
+     *
+     * In the CLI we use a GraphQL endpoint with a query
+     * that checks the usage and returns stats like:
+     * min/max count and min/max precentage
+     * So we know when to allow for a breaking change.
+     *
+     * Because it returns a boolean,
+     * we can't attach any data or even customize a message of an api change.
+     * This is the first iteration, we're going to improve it soon.
+     *
+     * true - NON_BREAKING
+     * false - BREAKING
+     */
+    checkUsage?: UsageHandler;
+}
+export declare const considerUsage: Rule<ConsiderUsageConfig>;

package/{diff → typings/diff}/rules/consider-usage.d.ts

@@ -1,5 +1,5 @@
-import { Rule } from './types';
-export declare type UsageHandler = (input: Array<{
+import { Rule } from './types.js';
+export type UsageHandler = (input: Array<{
     type: string;
     field?: string;
     argument?: string;

package/typings/diff/rules/dangerous-breaking.d.cts

@@ -0,0 +1,2 @@
+import { Rule } from './types.cjs';
+export declare const dangerousBreaking: Rule;

package/{diff → typings/diff}/rules/dangerous-breaking.d.ts

@@ -1,2 +1,2 @@
-import { Rule } from './types';
+import { Rule } from './types.js';
 export declare const dangerousBreaking: Rule;

package/typings/diff/rules/ignore-description-changes.d.cts

@@ -0,0 +1,2 @@
+import { Rule } from './types.cjs';
+export declare const ignoreDescriptionChanges: Rule;

package/{diff → typings/diff}/rules/ignore-description-changes.d.ts

@@ -1,2 +1,2 @@
-import { Rule } from './types';
+import { Rule } from './types.js';
 export declare const ignoreDescriptionChanges: Rule;

package/typings/diff/rules/index.d.cts

@@ -0,0 +1,5 @@
+export * from './consider-usage.cjs';
+export * from './dangerous-breaking.cjs';
+export * from './ignore-description-changes.cjs';
+export * from './safe-unreachable.cjs';
+export * from './suppress-removal-of-deprecated-field.cjs';

package/typings/diff/rules/index.d.ts

@@ -0,0 +1,5 @@
+export * from './consider-usage.js';
+export * from './dangerous-breaking.js';
+export * from './ignore-description-changes.js';
+export * from './safe-unreachable.js';
+export * from './suppress-removal-of-deprecated-field.js';

package/typings/diff/rules/safe-unreachable.d.cts

@@ -0,0 +1,2 @@
+import { Rule } from './types.cjs';
+export declare const safeUnreachable: Rule;

package/{diff → typings/diff}/rules/safe-unreachable.d.ts

@@ -1,2 +1,2 @@
-import { Rule } from './types';
+import { Rule } from './types.js';
 export declare const safeUnreachable: Rule;

package/typings/diff/rules/suppress-removal-of-deprecated-field.d.cts

@@ -0,0 +1,2 @@
+import { Rule } from './types.cjs';
+export declare const suppressRemovalOfDeprecatedField: Rule;

package/{diff → typings/diff}/rules/suppress-removal-of-deprecated-field.d.ts

@@ -1,2 +1,2 @@
-import { Rule } from './types';
+import { Rule } from './types.js';
 export declare const suppressRemovalOfDeprecatedField: Rule;

package/typings/diff/rules/types.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLSchema } from 'graphql';
+import { Change } from '../changes/change.cjs';
+export type Rule<TConfig = any> = (input: {
+    changes: Change[];
+    oldSchema: GraphQLSchema;
+    newSchema: GraphQLSchema;
+    config: TConfig;
+}) => Change[] | Promise<Change[]>;

package/{diff → typings/diff}/rules/types.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLSchema } from 'graphql';
-import { Change } from '../changes/change';
-export declare type Rule<TConfig = any> = (input: {
+import { Change } from '../changes/change.js';
+export type Rule<TConfig = any> = (input: {
     changes: Change[];
     oldSchema: GraphQLSchema;
     newSchema: GraphQLSchema;

package/typings/diff/schema.d.cts

@@ -0,0 +1,4 @@
+import { GraphQLSchema } from 'graphql';
+import { Change } from './changes/change.cjs';
+export type AddChange = (change: Change) => void;
+export declare function diffSchema(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change[];

package/{diff → typings/diff}/schema.d.ts

@@ -1,4 +1,4 @@
 import { GraphQLSchema } from 'graphql';
-import { Change } from './changes/change';
-export declare type AddChange = (change: Change) => void;
+import { Change } from './changes/change.js';
+export type AddChange = (change: Change) => void;
 export declare function diffSchema(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change[];

package/typings/diff/union.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLUnionType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInUnion(oldUnion: GraphQLUnionType, newUnion: GraphQLUnionType, addChange: AddChange): void;

package/{diff → typings/diff}/union.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLUnionType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInUnion(oldUnion: GraphQLUnionType, newUnion: GraphQLUnionType, addChange: AddChange): void;

package/typings/index.d.cts

@@ -0,0 +1,12 @@
+export * from './coverage/index.cjs';
+export { CompletionArgs, CompletionHandler, diff, DiffRule, Rule, UsageHandler, } from './diff/index.cjs';
+export { Change, ChangeType, Criticality, CriticalityLevel } from './diff/changes/change.cjs';
+export { similar, SimilarMap } from './similar/index.cjs';
+export { getTypePrefix } from './utils/graphql.cjs';
+export { BestMatch, Rating, Target } from './utils/string.cjs';
+export { InvalidDocument, validate } from './validate/index.cjs';
+export { countAliases } from './validate/alias-count.cjs';
+export { calculateOperationComplexity, CalculateOperationComplexityConfig, } from './validate/complexity.cjs';
+export { countDirectives } from './validate/directive-count.cjs';
+export { countDepth } from './validate/query-depth.cjs';
+export { calculateTokenCount } from './validate/token-count.cjs';

package/typings/index.d.ts

@@ -0,0 +1,12 @@
+export * from './coverage/index.js';
+export { CompletionArgs, CompletionHandler, diff, DiffRule, Rule, UsageHandler, } from './diff/index.js';
+export { Change, ChangeType, Criticality, CriticalityLevel } from './diff/changes/change.js';
+export { similar, SimilarMap } from './similar/index.js';
+export { getTypePrefix } from './utils/graphql.js';
+export { BestMatch, Rating, Target } from './utils/string.js';
+export { InvalidDocument, validate } from './validate/index.js';
+export { countAliases } from './validate/alias-count.js';
+export { calculateOperationComplexity, CalculateOperationComplexityConfig, } from './validate/complexity.js';
+export { countDirectives } from './validate/directive-count.js';
+export { countDepth } from './validate/query-depth.js';
+export { calculateTokenCount } from './validate/token-count.js';

package/typings/similar/index.d.cts

@@ -0,0 +1,6 @@
+import { GraphQLSchema } from 'graphql';
+import { BestMatch } from '../utils/string.cjs';
+export interface SimilarMap {
+    [name: string]: BestMatch;
+}
+export declare function similar(schema: GraphQLSchema, typeName: string | undefined, threshold?: number): SimilarMap;

package/{similar → typings/similar}/index.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
-import { BestMatch } from '../utils/string';
+import { BestMatch } from '../utils/string.js';
 export interface SimilarMap {
     [name: string]: BestMatch;
 }

package/typings/utils/apollo.d.ts

@@ -0,0 +1,5 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+export declare function transformDocumentWithApollo(doc: DocumentNode, { keepClientFields }: {
+    keepClientFields: boolean;
+}): DocumentNode;
+export declare function transformSchemaWithApollo(schema: GraphQLSchema): GraphQLSchema;

package/typings/utils/compare.d.ts

@@ -0,0 +1,22 @@
+export declare function keyMap<T>(list: readonly T[], keyFn: (item: T) => string): Record<string, T>;
+export declare function isEqual<T>(a: T, b: T): boolean;
+export declare function isNotEqual<T>(a: T, b: T): boolean;
+export declare function isVoid<T>(a: T): boolean;
+export declare function diffArrays<T>(a: T[] | readonly T[], b: T[] | readonly T[]): T[];
+export declare function compareLists<T extends {
+    name: string;
+}>(oldList: readonly T[], newList: readonly T[], callbacks?: {
+    onAdded?(t: T): void;
+    onRemoved?(t: T): void;
+    onMutual?(t: {
+        newVersion: T;
+        oldVersion: T;
+    }): void;
+}): {
+    added: T[];
+    removed: T[];
+    mutual: {
+        newVersion: T;
+        oldVersion: T;
+    }[];
+};

package/typings/utils/graphql.d.ts

@@ -0,0 +1,11 @@
+import { DocumentNode, FieldNode, GraphQLError, GraphQLInputType, GraphQLNamedType, GraphQLOutputType, GraphQLSchema, KindEnum } from 'graphql';
+export declare function safeChangeForField(oldType: GraphQLOutputType, newType: GraphQLOutputType): boolean;
+export declare function safeChangeForInputValue(oldType: GraphQLInputType, newType: GraphQLInputType): boolean;
+export declare function getKind(type: GraphQLNamedType): KindEnum;
+export declare function getTypePrefix(type: GraphQLNamedType): string;
+export declare function isPrimitive(type: GraphQLNamedType | string): boolean;
+export declare function isForIntrospection(type: GraphQLNamedType | string): boolean;
+export declare function findDeprecatedUsages(schema: GraphQLSchema, ast: DocumentNode): Array<GraphQLError>;
+export declare function removeFieldIfDirectives(node: FieldNode, directiveNames: string[]): FieldNode | null;
+export declare function removeDirectives(node: FieldNode, directiveNames: string[]): FieldNode;
+export declare function getReachableTypes(schema: GraphQLSchema): Set<string>;

package/typings/utils/is-deprecated.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLEnumValue, GraphQLField, GraphQLInputField } from 'graphql';
+export declare function isDeprecated(fieldOrEnumValue: GraphQLField<any, any> | GraphQLEnumValue | GraphQLInputField): unknown;

package/{utils → typings/utils}/is-deprecated.d.ts

@@ -1,2 +1,2 @@
 import { GraphQLEnumValue, GraphQLField, GraphQLInputField } from 'graphql';
-export declare function isDeprecated(fieldOrEnumValue: GraphQLField<any, any> | GraphQLEnumValue | GraphQLInputField): boolean;
+export declare function isDeprecated(fieldOrEnumValue: GraphQLField<any, any> | GraphQLEnumValue | GraphQLInputField): unknown;

package/typings/utils/path.d.ts

@@ -0,0 +1 @@
+export declare function parsePath(path: string): string[];

package/typings/utils/string.d.ts

@@ -0,0 +1,14 @@
+export interface Target {
+    typeId: string;
+    value: string;
+}
+export interface Rating {
+    target: Target;
+    rating: number;
+}
+export interface BestMatch {
+    ratings: Rating[];
+    bestMatch: Rating;
+}
+export declare function findBestMatch(mainString: string, targetStrings: Target[]): BestMatch;
+export declare function safeString(obj: any): string;

package/typings/validate/alias-count.d.ts

@@ -0,0 +1,10 @@
+import { DepGraph } from 'dependency-graph';
+import type { DocumentNode, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode, OperationDefinitionNode, Source } from 'graphql';
+import { GraphQLError } from 'graphql';
+export declare function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph, }: {
+    source: Source;
+    doc: DocumentNode;
+    maxAliasCount: number;
+    fragmentGraph: DepGraph<FragmentDefinitionNode>;
+}): GraphQLError | void;
+export declare function countAliases(node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode | FragmentSpreadNode, getFragmentByName: (fragmentName: string) => FragmentDefinitionNode | undefined): number;

package/typings/validate/complexity.d.cts

@@ -0,0 +1,16 @@
+import { DepGraph } from 'dependency-graph';
+import type { DocumentNode, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode, OperationDefinitionNode, Source } from 'graphql';
+import { GraphQLError } from 'graphql';
+export type CalculateOperationComplexityConfig = {
+    scalarCost: number;
+    objectCost: number;
+    depthCostFactor: number;
+};
+export declare function validateComplexity({ source, doc, maxComplexityScore, config, fragmentGraph, }: {
+    source: Source;
+    doc: DocumentNode;
+    maxComplexityScore: number;
+    config: CalculateOperationComplexityConfig;
+    fragmentGraph: DepGraph<FragmentDefinitionNode>;
+}): GraphQLError | void;
+export declare function calculateOperationComplexity(node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode | FragmentSpreadNode, config: CalculateOperationComplexityConfig, getFragmentByName: (fragmentName: string) => FragmentDefinitionNode | undefined, depth?: number): number;

package/{validate → typings/validate}/complexity.d.ts

@@ -1,7 +1,7 @@
 import { DepGraph } from 'dependency-graph';
 import type { DocumentNode, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode, OperationDefinitionNode, Source } from 'graphql';
 import { GraphQLError } from 'graphql';
-export declare type CalculateOperationComplexityConfig = {
+export type CalculateOperationComplexityConfig = {
     scalarCost: number;
     objectCost: number;
     depthCostFactor: number;

package/typings/validate/directive-count.d.ts

@@ -0,0 +1,10 @@
+import { DepGraph } from 'dependency-graph';
+import type { DocumentNode, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode, OperationDefinitionNode, Source } from 'graphql';
+import { GraphQLError } from 'graphql';
+export declare function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmentGraph, }: {
+    source: Source;
+    doc: DocumentNode;
+    maxDirectiveCount: number;
+    fragmentGraph: DepGraph<FragmentDefinitionNode>;
+}): GraphQLError | void;
+export declare function countDirectives(node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode | FragmentSpreadNode, getFragmentByName: (fragmentName: string) => FragmentDefinitionNode | undefined): number;

package/typings/validate/index.d.ts

@@ -0,0 +1,49 @@
+import { GraphQLError, GraphQLSchema, Source } from 'graphql';
+export interface InvalidDocument {
+    source: Source;
+    errors: GraphQLError[];
+    deprecated: GraphQLError[];
+}
+export interface ValidateOptions {
+    /**
+     * Fails on duplicated fragment names
+     * @default true
+     */
+    strictFragments?: boolean;
+    /**
+     * Fails on deprecated usage
+     * @default true
+     */
+    strictDeprecated?: boolean;
+    /**
+     * Works only with combination of `apollo`
+     * @default false
+     */
+    keepClientFields?: boolean;
+    /**
+     * Supports Apollo directives (`@client` and `@connection`)
+     * @default false
+     */
+    apollo?: boolean;
+    /**
+     * Fails when operation depth exceeds maximum depth (including the referenced fragments).
+     * @default Infinity
+     */
+    maxDepth?: number;
+    /**
+     * Fails when alias count exceeds maximum count (including the referenced fragments).
+     * @default Infinity
+     */
+    maxAliasCount?: number;
+    /**
+     * Fails when the directive count exceeds maximum count for a single operation (including the referenced fragments).
+     * @default Infinity
+     */
+    maxDirectiveCount?: number;
+    /**
+     * Fails when the token count exceeds maximum count for a single operation (including the referenced fragments).
+     * @default Infinity
+     */
+    maxTokenCount?: number;
+}
+export declare function validate(schema: GraphQLSchema, sources: Source[], options?: ValidateOptions): InvalidDocument[];

package/typings/validate/query-depth.d.ts

@@ -0,0 +1,15 @@
+import { DepGraph } from 'dependency-graph';
+import { ASTNode, DocumentNode, FieldNode, FragmentDefinitionNode, FragmentSpreadNode, GraphQLError, InlineFragmentNode, OperationDefinitionNode, Source } from 'graphql';
+export declare function validateQueryDepth({ source, doc, maxDepth, fragmentGraph, }: {
+    source: Source;
+    doc: DocumentNode;
+    maxDepth: number;
+    fragmentGraph: DepGraph<FragmentDefinitionNode>;
+}): GraphQLError | void;
+export declare function calculateDepth({ node, currentDepth, maxDepth, getFragment, }: {
+    node: ASTNode;
+    currentDepth: number;
+    maxDepth?: number;
+    getFragment: (fragmentName: string) => FragmentDefinitionNode;
+}): number | never;
+export declare function countDepth(node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode | FragmentSpreadNode, parentDepth: number, getFragmentReference: (name: string) => FragmentDefinitionNode | undefined): number;

package/typings/validate/token-count.d.ts

@@ -0,0 +1,12 @@
+import type { Source } from 'graphql';
+import { DocumentNode, GraphQLError } from 'graphql';
+export declare function calculateTokenCount(args: {
+    source: Source | string;
+    getReferencedFragmentSource: (fragmentName: string) => Source | string | undefined;
+}): number;
+export declare function validateTokenCount(args: {
+    source: Source;
+    document: DocumentNode;
+    getReferencedFragmentSource: (fragmentName: string) => Source | string | undefined;
+    maxTokenCount: number;
+}): GraphQLError | void;