@graphql-eslint/eslint-plugin 3.19.3-alpha-20230702093957-98f7783 → 3.20.0-alpha-20230703154330-0d51273

package/{typings/rules/strict-id-in-types.d.cts → esm/rules/strict-id-in-types.d.mts}

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.cjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -52,6 +59,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/strict-id-in-types.js

@@ -1,58 +1,66 @@
-import { Kind } from 'graphql';
-import { ARRAY_DEFAULT_OPTIONS, displayNodeName, englishJoinWords, requireGraphQLSchemaFromContext, truthy, } from '../utils.js';
-const RULE_ID = 'strict-id-in-types';
+import { Kind } from "graphql";
+import {
+  ARRAY_DEFAULT_OPTIONS,
+  displayNodeName,
+  englishJoinWords,
+  requireGraphQLSchemaFromContext,
+  truthy
+} from "../utils.js";
+const RULE_ID = "strict-id-in-types";
 const schema = {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      acceptedIdNames: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        default: ["id"]
+      },
+      acceptedIdTypes: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        default: ["ID"]
+      },
+      exceptions: {
+        type: "object",
         additionalProperties: false,
         properties: {
-            acceptedIdNames: {
-                ...ARRAY_DEFAULT_OPTIONS,
-                default: ['id'],
-            },
-            acceptedIdTypes: {
-                ...ARRAY_DEFAULT_OPTIONS,
-                default: ['ID'],
-            },
-            exceptions: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    types: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        description: 'This is used to exclude types with names that match one of the specified values.',
-                    },
-                    suffixes: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
-                    },
-                },
-            },
-        },
-    },
+          types: {
+            ...ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names that match one of the specified values."
+          },
+          suffixes: {
+            ...ARRAY_DEFAULT_OPTIONS,
+            description: "This is used to exclude types with names with suffixes that match one of the specified values."
+          }
+        }
+      }
+    }
+  }
 };
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.',
-            category: 'Schema',
-            recommended: true,
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [
-                        {
-                            acceptedIdNames: ['id', '_id'],
-                            acceptedIdTypes: ['ID'],
-                            exceptions: { suffixes: ['Payload'] },
-                        },
-                    ],
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.",
+      category: "Schema",
+      recommended: true,
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [
+            {
+              acceptedIdNames: ["id", "_id"],
+              acceptedIdTypes: ["ID"],
+              exceptions: { suffixes: ["Payload"] }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
             # Incorrect field name
             type InvalidFieldName {
               key: ID!
@@ -73,18 +81,21 @@ export const rule = {
               id: ID!
               _id: ID!
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    usage: [
-                        {
-                            acceptedIdNames: ['id', '_id'],
-                            acceptedIdTypes: ['ID'],
-                            exceptions: { types: ['Error'], suffixes: ['Payload'] },
-                        },
-                    ],
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [
+            {
+              acceptedIdNames: ["id", "_id"],
+              acceptedIdTypes: ["ID"],
+              exceptions: { types: ["Error"], suffixes: ["Payload"] }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
             }
@@ -100,62 +111,57 @@ export const rule = {
             type Error {
               message: String!
             }
-          `,
-                },
-            ],
-        },
-        schema,
+          `
+          )
+        }
+      ]
     },
-    create(context) {
-        const options = {
-            acceptedIdNames: ['id'],
-            acceptedIdTypes: ['ID'],
-            exceptions: {},
-            ...context.options[0],
-        };
-        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-        const rootTypeNames = [
-            schema.getQueryType(),
-            schema.getMutationType(),
-            schema.getSubscriptionType(),
-        ]
-            .filter(truthy)
-            .map(type => type.name);
-        const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join('|')})$/]`;
-        return {
-            [selector](node) {
-                var _a, _b, _c;
-                const typeName = node.name.value;
-                const shouldIgnoreNode = ((_a = options.exceptions.types) === null || _a === void 0 ? void 0 : _a.includes(typeName)) ||
-                    ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
-                if (shouldIgnoreNode) {
-                    return;
-                }
-                const validIds = (_c = node.fields) === null || _c === void 0 ? void 0 : _c.filter(field => {
-                    const fieldNode = field.rawNode();
-                    const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
-                    // To be a valid type, it must be non-null and one of the accepted types.
-                    let isValidIdType = false;
-                    if (fieldNode.type.kind === Kind.NON_NULL_TYPE &&
-                        fieldNode.type.type.kind === Kind.NAMED_TYPE) {
-                        isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
-                    }
-                    return isValidIdName && isValidIdType;
-                });
-                // Usually, there should be only one unique identifier field per type.
-                // Some clients allow multiple fields to be used. If more people need this,
-                // we can extend this rule later.
-                if ((validIds === null || validIds === void 0 ? void 0 : validIds.length) !== 1) {
-                    const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? 's' : '';
-                    const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? 's' : '';
-                    context.report({
-                        node: node.name,
-                        message: `${displayNodeName(node)} must have exactly one non-nullable unique identifier.
+    schema
+  },
+  create(context) {
+    const options = {
+      acceptedIdNames: ["id"],
+      acceptedIdTypes: ["ID"],
+      exceptions: {},
+      ...context.options[0]
+    };
+    const schema2 = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const rootTypeNames = [
+      schema2.getQueryType(),
+      schema2.getMutationType(),
+      schema2.getSubscriptionType()
+    ].filter(truthy).map((type) => type.name);
+    const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join("|")})$/]`;
+    return {
+      [selector](node) {
+        const typeName = node.name.value;
+        const shouldIgnoreNode = options.exceptions.types?.includes(typeName) || options.exceptions.suffixes?.some((suffix) => typeName.endsWith(suffix));
+        if (shouldIgnoreNode) {
+          return;
+        }
+        const validIds = node.fields?.filter((field) => {
+          const fieldNode = field.rawNode();
+          const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
+          let isValidIdType = false;
+          if (fieldNode.type.kind === Kind.NON_NULL_TYPE && fieldNode.type.type.kind === Kind.NAMED_TYPE) {
+            isValidIdType = options.acceptedIdTypes.includes(fieldNode.type.type.name.value);
+          }
+          return isValidIdName && isValidIdType;
+        });
+        if (validIds?.length !== 1) {
+          const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? "s" : "";
+          const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? "s" : "";
+          context.report({
+            node: node.name,
+            message: `${displayNodeName(node)} must have exactly one non-nullable unique identifier.
 Accepted name${pluralNamesSuffix}: ${englishJoinWords(options.acceptedIdNames)}.
-Accepted type${pluralTypesSuffix}: ${englishJoinWords(options.acceptedIdTypes)}.`,
-                    });
-                }
-            },
-        };
-    },
+Accepted type${pluralTypesSuffix}: ${englishJoinWords(options.acceptedIdTypes)}.`
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/esm/rules/unique-fragment-name.d.mts

@@ -0,0 +1,13 @@
+import { ExecutableDefinitionNode } from 'graphql';
+import { GraphQLESTreeNode } from '../estree-converter/types.mjs';
+import { g as GraphQLESLintRuleContext, i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import 'eslint';
+import 'estree';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';
+
+declare const checkNode: (context: GraphQLESLintRuleContext, node: GraphQLESTreeNode<ExecutableDefinitionNode>, ruleId: string) => void;
+declare const rule: GraphQLESLintRule;
+
+export { checkNode, rule };

package/esm/rules/unique-fragment-name.js

@@ -1,46 +1,43 @@
-import { relative } from 'path';
-import { Kind } from 'graphql';
-import { CWD, normalizePath, requireSiblingsOperations, VIRTUAL_DOCUMENT_REGEX } from '../utils.js';
-const RULE_ID = 'unique-fragment-name';
-export const checkNode = (context, node, ruleId) => {
-    const documentName = node.name.value;
-    const siblings = requireSiblingsOperations(ruleId, context);
-    const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION
-        ? siblings.getFragment(documentName)
-        : siblings.getOperation(documentName);
-    const filepath = context.getFilename();
-    const conflictingDocuments = siblingDocuments.filter(f => {
-        var _a;
-        const isSameName = ((_a = f.document.name) === null || _a === void 0 ? void 0 : _a.value) === documentName;
-        const isSamePath = normalizePath(f.filePath) === normalizePath(filepath);
-        return isSameName && !isSamePath;
+import { relative } from "path";
+import { Kind } from "graphql";
+import { CWD, normalizePath, requireSiblingsOperations, VIRTUAL_DOCUMENT_REGEX } from "../utils.js";
+const RULE_ID = "unique-fragment-name";
+const checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value;
+  const siblings = requireSiblingsOperations(ruleId, context);
+  const siblingDocuments = node.kind === Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
+  const filepath = context.getFilename();
+  const conflictingDocuments = siblingDocuments.filter((f) => {
+    const isSameName = f.document.name?.value === documentName;
+    const isSamePath = normalizePath(f.filePath) === normalizePath(filepath);
+    return isSameName && !isSamePath;
+  });
+  if (conflictingDocuments.length > 0) {
+    context.report({
+      messageId: ruleId,
+      data: {
+        documentName,
+        summary: conflictingDocuments.map((f) => `	${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ""))}`).join("\n")
+      },
+      // @ts-expect-error name will exist
+      node: node.name
     });
-    if (conflictingDocuments.length > 0) {
-        context.report({
-            messageId: ruleId,
-            data: {
-                documentName,
-                summary: conflictingDocuments
-                    .map(f => `\t${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ''))}`)
-                    .join('\n'),
-            },
-            // @ts-expect-error name will exist
-            node: node.name,
-        });
-    }
+  }
 };
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            category: 'Operations',
-            description: 'Enforce unique fragment names across your project.',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSiblings: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Enforce unique fragment names across your project.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             # user.fragment.graphql
             fragment UserFields on User {
               id
@@ -52,11 +49,14 @@ export const rule = {
             fragment UserFields on User {
               id
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             # user.fragment.graphql
             fragment AllUserFields on User {
               id
@@ -68,20 +68,25 @@ export const rule = {
             fragment UserFields on User {
               id
             }
-          `,
-                },
-            ],
-        },
-        messages: {
-            [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
-        },
-        schema: [],
+          `
+          )
+        }
+      ]
     },
-    create(context) {
-        return {
-            FragmentDefinition(node) {
-                checkNode(context, node, RULE_ID);
-            },
-        };
+    messages: {
+      [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
+    schema: []
+  },
+  create(context) {
+    return {
+      FragmentDefinition(node) {
+        checkNode(context, node, RULE_ID);
+      }
+    };
+  }
+};
+export {
+  checkNode,
+  rule
 };

package/esm/rules/unique-operation-name.d.mts

@@ -0,0 +1,12 @@
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/esm/rules/unique-operation-name.js

@@ -1,17 +1,19 @@
-import { checkNode } from './unique-fragment-name.js';
-const RULE_ID = 'unique-operation-name';
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            category: 'Operations',
-            description: 'Enforce unique operation names across your project.',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSiblings: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+import { checkNode } from "./unique-fragment-name.js";
+const RULE_ID = "unique-operation-name";
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Enforce unique operation names across your project.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             # foo.query.graphql
             query user {
               user {
@@ -25,11 +27,14 @@ export const rule = {
                 id
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             # foo.query.graphql
             query user {
               user {
@@ -43,20 +48,24 @@ export const rule = {
                 id
               }
             }
-          `,
-                },
-            ],
-        },
-        messages: {
-            [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
-        },
-        schema: [],
+          `
+          )
+        }
+      ]
     },
-    create(context) {
-        return {
-            'OperationDefinition[name!=undefined]'(node) {
-                checkNode(context, node, RULE_ID);
-            },
-        };
+    messages: {
+      [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
     },
+    schema: []
+  },
+  create(context) {
+    return {
+      "OperationDefinition[name!=undefined]"(node) {
+        checkNode(context, node, RULE_ID);
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/esm/schema.d.mts

@@ -0,0 +1,12 @@
+import { GraphQLProjectConfig } from 'graphql-config';
+import { P as ParserOptions, S as Schema } from './types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import './estree-converter/types.mjs';
+
+declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;
+
+export { getSchema };

package/esm/schema.js

@@ -1,28 +1,31 @@
-import debugFactory from 'debug';
-import fg from 'fast-glob';
-import { GraphQLSchema } from 'graphql';
-import { ModuleCache } from './cache.js';
+import debugFactory from "debug";
+import fg from "fast-glob";
+import { GraphQLSchema } from "graphql";
+import { ModuleCache } from "./cache.js";
 const schemaCache = new ModuleCache();
-const debug = debugFactory('graphql-eslint:schema');
-export function getSchema(project, schemaOptions) {
-    const schemaKey = project.schema;
-    if (!schemaKey) {
-        return null;
-    }
-    const cache = schemaCache.get(schemaKey);
-    if (cache) {
-        return cache;
-    }
-    debug('Loading schema from %o', project.schema);
-    const schema = project.loadSchemaSync(project.schema, 'GraphQLSchema', {
-        ...schemaOptions,
-        pluckConfig: project.extensions.pluckConfig,
-    });
-    if (debug.enabled) {
-        debug('Schema loaded: %o', schema instanceof GraphQLSchema);
-        const schemaPaths = fg.sync(project.schema, { absolute: true });
-        debug('Schema pointers %O', schemaPaths);
-    }
-    schemaCache.set(schemaKey, schema);
-    return schema;
+const debug = debugFactory("graphql-eslint:schema");
+function getSchema(project, schemaOptions) {
+  const schemaKey = project.schema;
+  if (!schemaKey) {
+    return null;
+  }
+  const cache = schemaCache.get(schemaKey);
+  if (cache) {
+    return cache;
+  }
+  debug("Loading schema from %o", project.schema);
+  const schema = project.loadSchemaSync(project.schema, "GraphQLSchema", {
+    ...schemaOptions,
+    pluckConfig: project.extensions.pluckConfig
+  });
+  if (debug.enabled) {
+    debug("Schema loaded: %o", schema instanceof GraphQLSchema);
+    const schemaPaths = fg.sync(project.schema, { absolute: true });
+    debug("Schema pointers %O", schemaPaths);
+  }
+  schemaCache.set(schemaKey, schema);
+  return schema;
 }
+export {
+  getSchema
+};

package/esm/siblings.d.mts

@@ -0,0 +1,8 @@
+import 'graphql';
+import 'graphql-config';
+export { F as FragmentSource, k as OperationSource, j as SiblingOperations, l as getSiblings } from './types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'json-schema-to-ts';
+import './estree-converter/types.mjs';