@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211539-5e993f5 → 3.14.0-alpha-20221223011700-eed94bd

package/esm/rules/relay-arguments.js

@@ -0,0 +1,118 @@
+import { isScalarType, Kind } from 'graphql';
+import { requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'relay-arguments';
+const MISSING_ARGUMENTS = 'MISSING_ARGUMENTS';
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            includeBoth: {
+                type: 'boolean',
+                default: true,
+                description: 'Enforce including both forward and backward pagination arguments',
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            category: 'Schema',
+            description: [
+                'Set of rules to follow Relay specification for Arguments.',
+                '',
+                '- A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both',
+                '',
+                'Forward pagination arguments',
+                '',
+                '- `first` takes a non-negative integer',
+                '- `after` takes the Cursor type',
+                '',
+                'Backward pagination arguments',
+                '',
+                '- `last` takes a non-negative integer',
+                '- `before` takes the Cursor type',
+            ].join('\n'),
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              posts: PostConnection
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              posts(after: String, first: Int, before: String, last: Int): PostConnection
+            }
+          `,
+                },
+            ],
+            isDisabledForAllConfig: true,
+        },
+        messages: {
+            [MISSING_ARGUMENTS]: 'A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both.',
+        },
+        schema,
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        const { includeBoth = true } = context.options[0] || {};
+        return {
+            'FieldDefinition > .gqlType Name[value=/Connection$/]'(node) {
+                let fieldNode = node.parent;
+                while (fieldNode.kind !== Kind.FIELD_DEFINITION) {
+                    fieldNode = fieldNode.parent;
+                }
+                const args = Object.fromEntries(fieldNode.arguments.map(argument => [argument.name.value, argument]));
+                const hasForwardPagination = Boolean(args.first && args.after);
+                const hasBackwardPagination = Boolean(args.last && args.before);
+                if (!hasForwardPagination && !hasBackwardPagination) {
+                    context.report({
+                        node: fieldNode.name,
+                        messageId: MISSING_ARGUMENTS,
+                    });
+                    return;
+                }
+                function checkField(typeName, argumentName) {
+                    const argument = args[argumentName];
+                    const hasArgument = Boolean(argument);
+                    let type = argument;
+                    if (hasArgument && type.gqlType.kind === Kind.NON_NULL_TYPE) {
+                        type = type.gqlType;
+                    }
+                    const isAllowedNonNullType = hasArgument &&
+                        type.gqlType.kind === Kind.NAMED_TYPE &&
+                        (type.gqlType.name.value === typeName ||
+                            (typeName === 'String' && isScalarType(schema.getType(type.gqlType.name.value))));
+                    if (!isAllowedNonNullType) {
+                        const returnType = typeName === 'String' ? 'String or Scalar' : typeName;
+                        context.report({
+                            node: (argument || fieldNode).name,
+                            message: hasArgument
+                                ? `Argument \`${argumentName}\` must return ${returnType}.`
+                                : `Field \`${fieldNode.name.value}\` must contain an argument \`${argumentName}\`, that return ${returnType}.`,
+                        });
+                    }
+                }
+                if (includeBoth || args.first || args.after) {
+                    checkField('Int', 'first');
+                    checkField('String', 'after');
+                }
+                if (includeBoth || args.last || args.before) {
+                    checkField('Int', 'last');
+                    checkField('String', 'before');
+                }
+            },
+        };
+    },
+};

package/esm/rules/relay-connection-types.js

@@ -0,0 +1,104 @@
+import { Kind } from 'graphql';
+const MUST_BE_OBJECT_TYPE = 'MUST_BE_OBJECT_TYPE';
+const MUST_CONTAIN_FIELD_EDGES = 'MUST_CONTAIN_FIELD_EDGES';
+const MUST_CONTAIN_FIELD_PAGE_INFO = 'MUST_CONTAIN_FIELD_PAGE_INFO';
+const MUST_HAVE_CONNECTION_SUFFIX = 'MUST_HAVE_CONNECTION_SUFFIX';
+const EDGES_FIELD_MUST_RETURN_LIST_TYPE = 'EDGES_FIELD_MUST_RETURN_LIST_TYPE';
+const PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = 'PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE';
+export const NON_OBJECT_TYPES = [
+    Kind.SCALAR_TYPE_DEFINITION,
+    Kind.UNION_TYPE_DEFINITION,
+    Kind.UNION_TYPE_EXTENSION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    Kind.ENUM_TYPE_DEFINITION,
+    Kind.ENUM_TYPE_EXTENSION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_EXTENSION,
+];
+const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
+const hasEdgesField = (node) => node.fields.some(field => field.name.value === 'edges');
+const hasPageInfoField = (node) => node.fields.some(field => field.name.value === 'pageInfo');
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            category: 'Schema',
+            description: [
+                'Set of rules to follow Relay specification for Connection types.',
+                '',
+                '- Any type whose name ends in "Connection" is considered by spec to be a `Connection type`',
+                '- Connection type must be an Object type',
+                '- Connection type must contain a field `edges` that return a list type that wraps an edge type',
+                '- Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type',
+            ].join('\n'),
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/relay-connection-types.md',
+            isDisabledForAllConfig: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type UserPayload { # should be an Object type with \`Connection\` suffix
+              edges: UserEdge! # should return a list type
+              pageInfo: PageInfo # should return a non-null \`PageInfo\` Object type
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type UserConnection {
+              edges: [UserEdge]
+              pageInfo: PageInfo!
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            // Connection types
+            [MUST_BE_OBJECT_TYPE]: 'Connection type must be an Object type.',
+            [MUST_HAVE_CONNECTION_SUFFIX]: 'Connection type must have `Connection` suffix.',
+            [MUST_CONTAIN_FIELD_EDGES]: 'Connection type must contain a field `edges` that return a list type.',
+            [MUST_CONTAIN_FIELD_PAGE_INFO]: 'Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type.',
+            [EDGES_FIELD_MUST_RETURN_LIST_TYPE]: '`edges` field must return a list type.',
+            [PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE]: '`pageInfo` field must return a non-null `PageInfo` Object type.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            [notConnectionTypesSelector](node) {
+                context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
+            },
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]'(node) {
+                if (hasEdgesField(node) && hasPageInfoField(node)) {
+                    context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+                }
+            },
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]'(node) {
+                if (!hasEdgesField(node)) {
+                    context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES });
+                }
+                if (!hasPageInfoField(node)) {
+                    context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+                }
+            },
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType'(node) {
+                const isListType = node.kind === Kind.LIST_TYPE ||
+                    (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE);
+                if (!isListType) {
+                    context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+                }
+            },
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType'(node) {
+                const isNonNullPageInfoType = node.kind === Kind.NON_NULL_TYPE &&
+                    node.gqlType.kind === Kind.NAMED_TYPE &&
+                    node.gqlType.name.value === 'PageInfo';
+                if (!isNonNullPageInfoType) {
+                    context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+                }
+            },
+        };
+    },
+};

package/esm/rules/relay-edge-types.js

@@ -0,0 +1,186 @@
+import { visit, isObjectType, Kind, isScalarType, } from 'graphql';
+import { getDocumentNodeFromSchema } from '@graphql-tools/utils';
+import { getTypeName, requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'relay-edge-types';
+const MESSAGE_MUST_BE_OBJECT_TYPE = 'MESSAGE_MUST_BE_OBJECT_TYPE';
+const MESSAGE_MISSING_EDGE_SUFFIX = 'MESSAGE_MISSING_EDGE_SUFFIX';
+const MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = 'MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE';
+const MESSAGE_SHOULD_IMPLEMENTS_NODE = 'MESSAGE_SHOULD_IMPLEMENTS_NODE';
+let edgeTypesCache;
+function getEdgeTypes(schema) {
+    // We don't want cache edgeTypes on test environment
+    // Otherwise edgeTypes will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && edgeTypesCache) {
+        return edgeTypesCache;
+    }
+    const edgeTypes = new Set();
+    const visitor = {
+        ObjectTypeDefinition(node) {
+            const typeName = node.name.value;
+            const hasConnectionSuffix = typeName.endsWith('Connection');
+            if (!hasConnectionSuffix) {
+                return;
+            }
+            const edges = node.fields.find(field => field.name.value === 'edges');
+            if (edges) {
+                const edgesTypeName = getTypeName(edges);
+                const edgesType = schema.getType(edgesTypeName);
+                if (isObjectType(edgesType)) {
+                    edgeTypes.add(edgesTypeName);
+                }
+            }
+        },
+    };
+    const astNode = getDocumentNodeFromSchema(schema); // Transforms the schema into ASTNode
+    visit(astNode, visitor);
+    edgeTypesCache = edgeTypes;
+    return edgeTypesCache;
+}
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            withEdgeSuffix: {
+                type: 'boolean',
+                default: true,
+                description: 'Edge type name must end in "Edge".',
+            },
+            shouldImplementNode: {
+                type: 'boolean',
+                default: true,
+                description: "Edge type's field `node` must implement `Node` interface.",
+            },
+            listTypeCanWrapOnlyEdgeType: {
+                type: 'boolean',
+                default: true,
+                description: 'A list type should only wrap an edge type.',
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            category: 'Schema',
+            description: [
+                'Set of rules to follow Relay specification for Edge types.',
+                '',
+                "- A type that is returned in list form by a connection type's `edges` field is considered by this spec to be an Edge type",
+                '- Edge type must be an Object type',
+                '- Edge type must contain a field `node` that return either Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types. Notably, this field cannot return a list',
+                '- Edge type must contain a field `cursor` that return either String, Scalar, or a non-null wrapper around one of those types',
+                '- Edge type name must end in "Edge" _(optional)_',
+                "- Edge type's field `node` must implement `Node` interface _(optional)_",
+                '- A list type should only wrap an edge type _(optional)_',
+            ].join('\n'),
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            isDisabledForAllConfig: true,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type UserConnection {
+              edges: [UserEdge]
+              pageInfo: PageInfo!
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [MESSAGE_MUST_BE_OBJECT_TYPE]: 'Edge type must be an Object type.',
+            [MESSAGE_MISSING_EDGE_SUFFIX]: 'Edge type must have "Edge" suffix.',
+            [MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE]: 'A list type should only wrap an edge type.',
+            [MESSAGE_SHOULD_IMPLEMENTS_NODE]: "Edge type's field `node` must implement `Node` interface.",
+        },
+        schema,
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        const edgeTypes = getEdgeTypes(schema);
+        const options = {
+            withEdgeSuffix: true,
+            shouldImplementNode: true,
+            listTypeCanWrapOnlyEdgeType: true,
+            ...context.options[0],
+        };
+        const isNamedOrNonNullNamed = (node) => node.kind === Kind.NAMED_TYPE ||
+            (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.NAMED_TYPE);
+        const checkNodeField = (node) => {
+            const nodeField = node.fields.find(field => field.name.value === 'node');
+            const message = 'return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.';
+            if (!nodeField) {
+                context.report({
+                    node: node.name,
+                    message: `Edge type must contain a field \`node\` that ${message}`,
+                });
+            }
+            else if (!isNamedOrNonNullNamed(nodeField.gqlType)) {
+                context.report({ node: nodeField.name, message: `Field \`node\` must ${message}` });
+            }
+            else if (options.shouldImplementNode) {
+                const nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode());
+                const type = schema.getType(nodeReturnTypeName);
+                if (!isObjectType(type)) {
+                    return;
+                }
+                const implementsNode = type.astNode.interfaces.some(n => n.name.value === 'Node');
+                if (!implementsNode) {
+                    context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
+                }
+            }
+        };
+        const checkCursorField = (node) => {
+            const cursorField = node.fields.find(field => field.name.value === 'cursor');
+            const message = 'return either a String, Scalar, or a non-null wrapper wrapper around one of those types.';
+            if (!cursorField) {
+                context.report({
+                    node: node.name,
+                    message: `Edge type must contain a field \`cursor\` that ${message}`,
+                });
+                return;
+            }
+            const typeName = getTypeName(cursorField.rawNode());
+            if (!isNamedOrNonNullNamed(cursorField.gqlType) ||
+                (typeName !== 'String' && !isScalarType(schema.getType(typeName)))) {
+                context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
+            }
+        };
+        const listeners = {
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType Name'(node) {
+                const type = schema.getType(node.value);
+                if (!isObjectType(type)) {
+                    context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+                }
+            },
+            ':matches(ObjectTypeDefinition, ObjectTypeExtension)'(node) {
+                const typeName = node.name.value;
+                if (edgeTypes.has(typeName)) {
+                    checkNodeField(node);
+                    checkCursorField(node);
+                    if (options.withEdgeSuffix && !typeName.endsWith('Edge')) {
+                        context.report({ node: node.name, messageId: MESSAGE_MISSING_EDGE_SUFFIX });
+                    }
+                }
+            },
+        };
+        if (options.listTypeCanWrapOnlyEdgeType) {
+            listeners['FieldDefinition > .gqlType'] = (node) => {
+                if (node.kind === Kind.LIST_TYPE ||
+                    (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE)) {
+                    const typeName = getTypeName(node.rawNode());
+                    if (!edgeTypes.has(typeName)) {
+                        context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
+                    }
+                }
+            };
+        }
+        return listeners;
+    },
+};

package/esm/rules/relay-page-info.js

@@ -0,0 +1,97 @@
+import { isScalarType, Kind } from 'graphql';
+import { NON_OBJECT_TYPES } from './relay-connection-types.js';
+import { REPORT_ON_FIRST_CHARACTER, requireGraphQLSchemaFromContext } from '../utils.js';
+const RULE_ID = 'relay-page-info';
+const MESSAGE_MUST_EXIST = 'MESSAGE_MUST_EXIST';
+const MESSAGE_MUST_BE_OBJECT_TYPE = 'MESSAGE_MUST_BE_OBJECT_TYPE';
+const notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`;
+let hasPageInfoChecked = false;
+export const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            category: 'Schema',
+            description: [
+                'Set of rules to follow Relay specification for `PageInfo` object.',
+                '',
+                '- `PageInfo` must be an Object type',
+                '- `PageInfo` must contain fields `hasPreviousPage` and `hasNextPage`, that return non-null Boolean',
+                '- `PageInfo` must contain fields `startCursor` and `endCursor`, that return either String or Scalar, which can be null if there are no results',
+            ].join('\n'),
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
+            examples: [
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type PageInfo {
+              hasPreviousPage: Boolean!
+              hasNextPage: Boolean!
+              startCursor: String
+              endCursor: String
+            }
+          `,
+                },
+            ],
+            isDisabledForAllConfig: true,
+            requiresSchema: true,
+        },
+        messages: {
+            [MESSAGE_MUST_EXIST]: 'The server must provide a `PageInfo` object.',
+            [MESSAGE_MUST_BE_OBJECT_TYPE]: '`PageInfo` must be an Object type.',
+        },
+        schema: [],
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+        if (process.env.NODE_ENV === 'test' || !hasPageInfoChecked) {
+            const pageInfoType = schema.getType('PageInfo');
+            if (!pageInfoType) {
+                context.report({
+                    loc: REPORT_ON_FIRST_CHARACTER,
+                    messageId: MESSAGE_MUST_EXIST,
+                });
+            }
+            hasPageInfoChecked = true;
+        }
+        return {
+            [notPageInfoTypesSelector](node) {
+                context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+            },
+            'ObjectTypeDefinition[name.value=PageInfo]'(node) {
+                const fieldMap = Object.fromEntries(node.fields.map(field => [field.name.value, field]));
+                const checkField = (fieldName, typeName) => {
+                    const field = fieldMap[fieldName];
+                    let isAllowedType = false;
+                    if (field) {
+                        const type = field.gqlType;
+                        if (typeName === 'Boolean') {
+                            isAllowedType =
+                                type.kind === Kind.NON_NULL_TYPE &&
+                                    type.gqlType.kind === Kind.NAMED_TYPE &&
+                                    type.gqlType.name.value === 'Boolean';
+                        }
+                        else if (type.kind === Kind.NAMED_TYPE) {
+                            isAllowedType =
+                                type.name.value === 'String' || isScalarType(schema.getType(type.name.value));
+                        }
+                    }
+                    if (!isAllowedType) {
+                        const returnType = typeName === 'Boolean'
+                            ? 'non-null Boolean'
+                            : 'either String or Scalar, which can be null if there are no results';
+                        context.report({
+                            node: field ? field.name : node.name,
+                            message: field
+                                ? `Field \`${fieldName}\` must return ${returnType}.`
+                                : `\`PageInfo\` must contain a field \`${fieldName}\`, that return ${returnType}.`,
+                        });
+                    }
+                };
+                checkField('hasPreviousPage', 'Boolean');
+                checkField('hasNextPage', 'Boolean');
+                checkField('startCursor', 'String');
+                checkField('endCursor', 'String');
+            },
+        };
+    },
+};

package/esm/rules/require-deprecation-date.js

@@ -0,0 +1,120 @@
+import { valueFromNode } from '../estree-converter/index.js';
+// eslint-disable-next-line unicorn/better-regex
+const DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
+const MESSAGE_REQUIRE_DATE = 'MESSAGE_REQUIRE_DATE';
+const MESSAGE_INVALID_FORMAT = 'MESSAGE_INVALID_FORMAT';
+const MESSAGE_INVALID_DATE = 'MESSAGE_INVALID_DATE';
+const MESSAGE_CAN_BE_REMOVED = 'MESSAGE_CAN_BE_REMOVED';
+const schema = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            argumentName: {
+                type: 'string',
+            },
+        },
+    },
+};
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            category: 'Schema',
+            description: 'Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/require-deprecation-date.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String @deprecated
+              firstName: String
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String @deprecated(reason: "Use 'firstName' instead")
+              firstName: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String
+                @deprecated(reason: "Use 'firstName' instead", deletionDate: "25/12/2022")
+              firstName: String
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [MESSAGE_REQUIRE_DATE]: 'Directive "@deprecated" must have a deletion date',
+            [MESSAGE_INVALID_FORMAT]: 'Deletion date must be in format "DD/MM/YYYY"',
+            [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date',
+            [MESSAGE_CAN_BE_REMOVED]: '"{{ nodeName }}" сan be removed',
+        },
+        schema,
+    },
+    create(context) {
+        return {
+            'Directive[name.value=deprecated]'(node) {
+                var _a;
+                const argName = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.argumentName) || 'deletionDate';
+                const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
+                if (!deletionDateNode) {
+                    context.report({
+                        node: node.name,
+                        messageId: MESSAGE_REQUIRE_DATE,
+                    });
+                    return;
+                }
+                const deletionDate = valueFromNode(deletionDateNode.value);
+                const isValidDate = DATE_REGEX.test(deletionDate);
+                if (!isValidDate) {
+                    context.report({ node: deletionDateNode.value, messageId: MESSAGE_INVALID_FORMAT });
+                    return;
+                }
+                let [day, month, year] = deletionDate.split('/');
+                day = day.padStart(2, '0');
+                month = month.padStart(2, '0');
+                const deletionDateInMS = Date.parse(`${year}-${month}-${day}`);
+                if (Number.isNaN(deletionDateInMS)) {
+                    context.report({
+                        node: deletionDateNode.value,
+                        messageId: MESSAGE_INVALID_DATE,
+                        data: {
+                            deletionDate,
+                        },
+                    });
+                    return;
+                }
+                const canRemove = Date.now() > deletionDateInMS;
+                if (canRemove) {
+                    const { parent } = node;
+                    const nodeName = parent.name.value;
+                    context.report({
+                        node: parent.name,
+                        messageId: MESSAGE_CAN_BE_REMOVED,
+                        data: { nodeName },
+                        suggest: [
+                            {
+                                desc: `Remove \`${nodeName}\``,
+                                fix: fixer => fixer.remove(parent),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+};

package/esm/rules/require-deprecation-reason.js

@@ -0,0 +1,53 @@
+import { valueFromNode } from '../estree-converter/index.js';
+export const rule = {
+    meta: {
+        docs: {
+            description: 'Require all deprecation directives to specify a reason.',
+            category: 'Schema',
+            url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/require-deprecation-reason.md',
+            recommended: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated(reason: "")
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type MyType {
+              name: String @deprecated(reason: "no longer relevant, please use fullName field")
+            }
+          `,
+                },
+            ],
+        },
+        type: 'suggestion',
+        schema: [],
+    },
+    create(context) {
+        return {
+            'Directive[name.value=deprecated]'(node) {
+                const reasonArgument = node.arguments.find(arg => arg.name.value === 'reason');
+                const value = reasonArgument && String(valueFromNode(reasonArgument.value)).trim();
+                if (!value) {
+                    context.report({
+                        node: node.name,
+                        message: 'Directive "@deprecated" must have a reason!',
+                    });
+                }
+            },
+        };
+    },
+};