@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221142641-4e1a924 → 3.14.0-alpha-20221222124206-b82954b

package/typings/rules/match-document-filename.d.ts

@@ -0,0 +1,72 @@
+import { CaseStyle as _CaseStyle } from '../utils';
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+type CaseStyle = _CaseStyle | 'matchDocumentStyle';
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly enum: CaseStyle[];
+            readonly description: `One of: ${string}`;
+        };
+        readonly asObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly minProperties: 1;
+            readonly properties: {
+                readonly style: {
+                    readonly enum: CaseStyle[];
+                };
+                readonly suffix: {
+                    readonly type: "string";
+                };
+                readonly prefix: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly fileExtension: {
+                readonly enum: readonly [".gql", ".graphql"];
+            };
+            readonly query: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly mutation: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly subscription: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly fragment: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/naming-convention.d.ts

@@ -0,0 +1,83 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+type AllowedStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly enum: AllowedStyle[];
+            readonly description: `One of: ${string}`;
+        };
+        readonly asObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly style: {
+                    readonly enum: AllowedStyle[];
+                };
+                readonly prefix: {
+                    readonly type: "string";
+                };
+                readonly suffix: {
+                    readonly type: "string";
+                };
+                readonly forbiddenPrefixes: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly forbiddenSuffixes: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly ignorePattern: {
+                    readonly type: "string";
+                    readonly description: "Option to skip validation of some words, e.g. acronyms";
+                };
+            };
+        };
+    };
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly allowLeadingUnderscore: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly allowTrailingUnderscore: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly types: {
+                readonly description: `Includes:\n${string}`;
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+        readonly patternProperties: {
+            readonly [x: string]: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+        readonly description: string;
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/no-deprecated.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLESLintRule } from '../types';
+export declare const rule: GraphQLESLintRule<[], true>;

package/typings/rules/no-root-type.d.ts

@@ -0,0 +1,25 @@
+import type { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["disallow"];
+        readonly properties: {
+            readonly disallow: {
+                readonly items: {
+                    readonly enum: readonly ["mutation", "subscription"];
+                };
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/no-typename-prefix.d.cts

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

package/typings/rules/no-typename-prefix.d.ts

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

package/typings/rules/no-unreachable-types.d.cts

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

package/typings/rules/no-unreachable-types.d.ts

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

package/typings/rules/no-unused-fields.d.cts

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

package/typings/rules/no-unused-fields.d.ts

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

package/typings/rules/relay-arguments.d.ts

@@ -0,0 +1,21 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly includeBoth: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Enforce including both forward and backward pagination arguments";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

package/typings/rules/relay-connection-types.d.ts

@@ -0,0 +1,4 @@
+import { Kind } from 'graphql';
+import type { GraphQLESLintRule } from '../types';
+export declare const NON_OBJECT_TYPES: Kind[];
+export declare const rule: GraphQLESLintRule;

package/typings/rules/relay-edge-types.d.ts

@@ -0,0 +1,31 @@
+import type { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly withEdgeSuffix: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Edge type name must end in \"Edge\".";
+            };
+            readonly shouldImplementNode: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Edge type's field `node` must implement `Node` interface.";
+            };
+            readonly listTypeCanWrapOnlyEdgeType: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "A list type should only wrap an edge type.";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

package/typings/rules/require-deprecation-date.d.ts

@@ -0,0 +1,18 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly argumentName: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/require-deprecation-reason.d.cts

@@ -0,0 +1,2 @@
+import type { GraphQLESLintRule } from '../types';
+export declare const rule: GraphQLESLintRule;

package/typings/rules/require-deprecation-reason.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLESLintRule } from '../types';
+export declare const rule: GraphQLESLintRule;

package/typings/rules/require-description.d.ts

@@ -0,0 +1,14 @@
+import { Kind } from 'graphql';
+import type { GraphQLESLintRule } from '../types';
+declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.DIRECTIVE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.OPERATION_DEFINITION];
+type AllowedKind = typeof ALLOWED_KINDS[number];
+export type RuleOptions = [
+    {
+        types?: boolean;
+        rootField?: boolean;
+    } & {
+        [key in AllowedKind]?: boolean;
+    }
+];
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/require-field-of-type-query-in-mutation-result.d.cts

@@ -0,0 +1,2 @@
+import type { GraphQLESLintRule } from '../types';
+export declare const rule: GraphQLESLintRule;

package/typings/rules/require-field-of-type-query-in-mutation-result.d.ts

@@ -0,0 +1,2 @@
+import type { GraphQLESLintRule } from '../types';
+export declare const rule: GraphQLESLintRule;

package/typings/rules/require-id-when-available.d.ts

@@ -0,0 +1,36 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly type: "string";
+        };
+        readonly asArray: {
+            readonly type: "array";
+            readonly uniqueItems: true;
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly fieldName: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asArray";
+                }];
+                readonly default: "id";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

package/typings/rules/selection-set-depth.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["maxDepth"];
+        readonly properties: {
+            readonly maxDepth: {
+                readonly type: "number";
+            };
+            readonly ignore: {
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/strict-id-in-types.d.ts

@@ -0,0 +1,57 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly acceptedIdNames: {
+                readonly default: readonly ["id"];
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly acceptedIdTypes: {
+                readonly default: readonly ["ID"];
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly exceptions: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly types: {
+                        readonly description: "This is used to exclude types with names that match one of the specified values.";
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly suffixes: {
+                        readonly description: "This is used to exclude types with names with suffixes that match one of the specified values.";
+                        readonly type: "array";
+                        readonly uniqueItems: true;
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/unique-fragment-name.d.ts

@@ -0,0 +1,5 @@
+import { ExecutableDefinitionNode } from 'graphql';
+import { GraphQLESLintRule, GraphQLESLintRuleContext } from '../types';
+import { GraphQLESTreeNode } from '../estree-converter';
+export declare const checkNode: (context: GraphQLESLintRuleContext, node: GraphQLESTreeNode<ExecutableDefinitionNode>, ruleId: string) => void;
+export declare const rule: GraphQLESLintRule;

package/typings/rules/unique-operation-name.d.cts

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

package/typings/rules/unique-operation-name.d.ts

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

package/typings/schema.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLProjectConfig } from 'graphql-config';
+import { ParserOptions, Schema } from './types';
+export declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;

package/typings/testkit.d.ts

@@ -0,0 +1,27 @@
+import { RuleTester } from 'eslint';
+import type { ASTKindToNode } from 'graphql';
+import type { GraphQLESTreeNode } from './estree-converter';
+import type { GraphQLESLintRule, ParserOptions } from './types';
+export type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+} & Record<string, any>;
+export type GraphQLValidTestCase<Options> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
+    options?: Options;
+    parserOptions?: Omit<ParserOptions, 'filePath'>;
+};
+export type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
+    errors: number | (RuleTester.TestCaseError | string)[];
+    output?: string | null;
+};
+export declare class GraphQLRuleTester extends RuleTester {
+    config: {
+        parser: string;
+        parserOptions: Omit<ParserOptions, 'filePath'>;
+    };
+    constructor(parserOptions?: Omit<ParserOptions, 'filePath'>);
+    fromMockFile(path: string): string;
+    runGraphQLTests<Options, WithTypeInfo extends boolean = false>(ruleId: string, rule: GraphQLESLintRule<Options, WithTypeInfo>, tests: {
+        valid: (string | GraphQLValidTestCase<Options>)[];
+        invalid: GraphQLInvalidTestCase<Options>[];
+    }): void;
+}

package/typings/types.d.ts

@@ -0,0 +1,81 @@
+import { Rule, AST, Linter } from 'eslint';
+import * as ESTree from 'estree';
+import { GraphQLSchema } from 'graphql';
+import { IExtensions, IGraphQLProject } from 'graphql-config';
+import { GraphQLParseOptions } from '@graphql-tools/utils';
+import { GraphQLESLintRuleListener } from './testkit';
+import { SiblingOperations } from './documents';
+import { JSONSchema } from 'json-schema-to-ts';
+export type Schema = GraphQLSchema | Error | null;
+export type Pointer = string | string[];
+export interface ParserOptions {
+    schema?: Pointer | Record<string, {
+        headers: Record<string, string>;
+    }>;
+    documents?: Pointer;
+    operations?: Pointer;
+    extensions?: IExtensions;
+    include?: Pointer;
+    exclude?: Pointer;
+    projects?: Record<string, IGraphQLProject>;
+    schemaOptions?: Omit<GraphQLParseOptions, 'assumeValidSDL'> & {
+        headers: Record<string, string>;
+    };
+    graphQLParserOptions?: Omit<GraphQLParseOptions, 'noLocation'>;
+    skipGraphQLConfig?: boolean;
+    filePath: string;
+}
+export type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+export type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    node: {
+        loc: Location;
+    };
+} | {
+    loc: Location;
+};
+export type ReportDescriptor = Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions & ReportDescriptorLocation;
+export type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'parserServices' | 'report' | 'options'> & {
+    options: Options;
+    report(descriptor: ReportDescriptor): void;
+    parserServices?: ParserServices;
+};
+export type CategoryType = 'Schema' | 'Operations';
+export type RuleDocsInfo<T> = Omit<Rule.RuleMetaData['docs'], 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+export type GraphQLESLintRule<Options = any[], WithTypeInfo extends boolean = false> = {
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+};
+export type ValueOf<T> = T[keyof T];
+type Id<T> = {} & {
+    [P in keyof T]: T[P];
+};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+export type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+export {};