@graphql-eslint/eslint-plugin 3.14.0-alpha-20221220004017-f1f0904 → 3.14.0-alpha-20221220160018-ba4832c

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

@@ -1,8 +1,31 @@
 import type { GraphQLESLintRule } from '../types';
-export type EdgeTypesConfig = {
-    withEdgeSuffix?: boolean;
-    shouldImplementNode?: boolean;
-    listTypeCanWrapOnlyEdgeType?: boolean;
+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.";
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[EdgeTypesConfig], true>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

package/rules/relay-page-info.d.ts

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

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

@@ -1,5 +1,18 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule<[{
-    argumentName?: string;
-}]>;
-export default rule;
+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/rules/require-deprecation-reason.d.ts

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

package/rules/require-description.d.ts

@@ -2,10 +2,13 @@ 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 RequireDescriptionRuleConfig = {
-    types?: boolean;
-} & {
-    [key in AllowedKind]?: boolean;
-};
-declare const rule: GraphQLESLintRule<[RequireDescriptionRuleConfig]>;
-export default rule;
+export type RuleOptions = [
+    {
+        types?: boolean;
+        rootField?: boolean;
+    } & {
+        [key in AllowedKind]?: boolean;
+    }
+];
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

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

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

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

@@ -1,6 +1,36 @@
 import { GraphQLESLintRule } from '../types';
-export type RequireIdWhenAvailableRuleConfig = {
-    fieldName: string | string[];
+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";
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[RequireIdWhenAvailableRuleConfig], true>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

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

@@ -1,7 +1,28 @@
 import { GraphQLESLintRule } from '../types';
-export type SelectionSetDepthRuleConfig = {
-    maxDepth: number;
-    ignore?: string[];
+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";
+                };
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[SelectionSetDepthRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

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

@@ -1,11 +1,57 @@
 import { GraphQLESLintRule } from '../types';
-export type StrictIdInTypesRuleConfig = {
-    acceptedIdNames?: string[];
-    acceptedIdTypes?: string[];
-    exceptions?: {
-        types?: string[];
-        suffixes?: string[];
+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";
+                        };
+                    };
+                };
+            };
+        };
     };
 };
-declare const rule: GraphQLESLintRule<[StrictIdInTypesRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

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

@@ -2,5 +2,4 @@ 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;
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

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

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

package/testkit.d.ts

@@ -7,7 +7,7 @@ export type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = {
 } & Record<string, any>;
 export type GraphQLValidTestCase<Options> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
     options?: Options;
-    parserOptions?: ParserOptions;
+    parserOptions?: Omit<ParserOptions, 'filePath'>;
 };
 export type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
     errors: number | (RuleTester.TestCaseError | string)[];

package/types.d.ts

@@ -5,6 +5,7 @@ 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 {
@@ -64,8 +65,9 @@ export type RuleDocsInfo<T> = Omit<Rule.RuleMetaData['docs'], 'category' | 'sugg
 };
 export type GraphQLESLintRule<Options = any[], WithTypeInfo extends boolean = false> = {
     create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
-    meta: Omit<Rule.RuleMetaData, 'docs'> & {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
         docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
     };
 };
 export type ValueOf<T> = T[keyof T];

package/utils.d.ts

@@ -15,6 +15,7 @@ export declare const CWD: string;
 export declare const getTypeName: (node: any) => string;
 export declare const TYPES_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];
 export type CaseStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE' | 'kebab-case';
+export declare const pascalCase: (str: string) => string;
 export declare const camelCase: (str: string) => string;
 export declare const convertCase: (style: CaseStyle, str: string) => string;
 export declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;