@graphql-eslint/eslint-plugin 3.12.0 → 3.13.0-alpha-20221024000319-1089aa0

package/cache.d.ts

@@ -0,0 +1,10 @@
+export declare class ModuleCache<T, K = any> {
+    map: Map<K, {
+        lastSeen: [number, number];
+        result: T;
+    }>;
+    set(cacheKey: K, result: T): void;
+    get(cacheKey: any, settings?: {
+        lifetime: number;
+    }): void | T;
+}

package/{sibling-operations.d.ts → documents.d.ts}

@@ -18,4 +18,4 @@ export declare type SiblingOperations = {
     getOperations(): OperationSource[];
     getOperationByType(operationType: OperationTypeNode): OperationSource[];
 };
-export declare function getSiblingOperations(project: GraphQLProjectConfig): SiblingOperations;
+export declare function getDocuments(project: GraphQLProjectConfig): SiblingOperations;

package/index.js

@@ -12,12 +12,12 @@ const graphqlConfig = require('graphql-config');
 const codeFileLoader = require('@graphql-tools/code-file-loader');
 const graphql = require('graphql');
 const validate = require('graphql/validation/validate');
-const fs = require('fs');
 const lowerCase = _interopDefault(require('lodash.lowercase'));
 const chalk = _interopDefault(require('chalk'));
+const fs = require('fs');
 const valueFromASTUntyped = require('graphql/utilities/valueFromASTUntyped');
 const depthLimit = _interopDefault(require('graphql-depth-limit'));
-const fastGlob = _interopDefault(require('fast-glob'));
+const fg = _interopDefault(require('fast-glob'));
 const eslint = require('eslint');
 const codeFrame = require('@babel/code-frame');
 
@@ -164,26 +164,8 @@ const logger = {
     warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
 };
 const normalizePath = (path) => (path || '').replace(/\\/g, '/');
-/**
- * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
- * Given a filepath, get the nearest path that is a regular file.
- * The filepath provided by eslint may be a virtual filepath rather than a file
- * on disk. This attempts to transform a virtual path into an on-disk path
- */
-const getOnDiskFilepath = (filepath) => {
-    try {
-        if (fs.statSync(filepath).isFile()) {
-            return filepath;
-        }
-    }
-    catch (err) {
-        // https://github.com/eslint/eslint/issues/11989
-        if (err.code === 'ENOTDIR') {
-            return getOnDiskFilepath(path.dirname(filepath));
-        }
-    }
-    return filepath;
-};
+const VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
+const CWD = process.cwd();
 const getTypeName = (node) => 'type' in node ? getTypeName(node.type) : node.name.value;
 const TYPES_KINDS = [
     graphql.Kind.OBJECT_TYPE_DEFINITION,
@@ -4114,7 +4096,7 @@ const checkNode = (context, node, ruleId) => {
             data: {
                 documentName,
                 summary: conflictingDocuments
-                    .map(f => `\t${path.relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
+                    .map(f => `\t${path.relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ''))}`)
                     .join('\n'),
             },
             node: node.name,
@@ -4275,36 +4257,59 @@ const rules = {
     'unique-operation-name': rule$r,
 };
 
-const schemaCache = new Map();
+// Based on the `eslint-plugin-import`'s cache
+const log = debugFactory('graphql-eslint:ModuleCache');
+class ModuleCache {
+    constructor() {
+        this.map = new Map();
+    }
+    set(cacheKey, result) {
+        this.map.set(cacheKey, { lastSeen: process.hrtime(), result });
+        log('setting entry for', cacheKey);
+    }
+    get(cacheKey, settings = { lifetime: 10 /* seconds */ }) {
+        if (!this.map.has(cacheKey)) {
+            log('cache miss for', cacheKey);
+            return;
+        }
+        const { lastSeen, result } = this.map.get(cacheKey);
+        // check freshness
+        if (process.hrtime(lastSeen)[0] < settings.lifetime) {
+            return result;
+        }
+    }
+}
+
+const schemaCache = new ModuleCache();
 const debug$1 = debugFactory('graphql-eslint:schema');
-function getSchema(project, options = {}) {
-    const schemaKey = utils.asArray(project.schema).sort().join(',');
+function getSchema(project, schemaOptions) {
+    const schemaKey = project.schema;
     if (!schemaKey) {
         return null;
     }
-    if (schemaCache.has(schemaKey)) {
-        return schemaCache.get(schemaKey);
+    const cache = schemaCache.get(schemaKey);
+    if (cache) {
+        return cache;
     }
     let schema;
     try {
         debug$1('Loading schema from %o', project.schema);
         schema = project.loadSchemaSync(project.schema, 'GraphQLSchema', {
-            ...options.schemaOptions,
+            ...schemaOptions,
             pluckConfig: project.extensions.pluckConfig,
         });
         if (debug$1.enabled) {
             debug$1('Schema loaded: %o', schema instanceof graphql.GraphQLSchema);
-            const schemaPaths = fastGlob.sync(project.schema, {
-                absolute: true,
-            });
+            const schemaPaths = fg.sync(project.schema, { absolute: true });
             debug$1('Schema pointers %O', schemaPaths);
         }
+        // Do not set error to cache, since cache reload will be done after some `lifetime` seconds
+        schemaCache.set(schemaKey, schema);
     }
     catch (error) {
         error.message = chalk.red(`Error while loading schema: ${error.message}`);
         schema = error;
     }
-    schemaCache.set(schemaKey, schema);
     return schema;
 }
 
@@ -4325,10 +4330,10 @@ const handleVirtualPath = (documents) => {
         };
     });
 };
-const operationsCache = new Map();
+const operationsCache = new ModuleCache();
 const siblingOperationsCache = new Map();
 const getSiblings = (project) => {
-    const documentsKey = utils.asArray(project.documents).sort().join(',');
+    const documentsKey = project.documents;
     if (!documentsKey) {
         return [];
     }
@@ -4341,9 +4346,7 @@ const getSiblings = (project) => {
         });
         if (debug$2.enabled) {
             debug$2('Loaded %d operations', documents.length);
-            const operationsPaths = fastGlob.sync(project.documents, {
-                absolute: true,
-            });
+            const operationsPaths = fg.sync(project.documents, { absolute: true });
             debug$2('Operations pointers %O', operationsPaths);
         }
         siblings = handleVirtualPath(documents);
@@ -4351,7 +4354,7 @@ const getSiblings = (project) => {
     }
     return siblings;
 };
-function getSiblingOperations(project) {
+function getDocuments(project) {
     const siblings = getSiblings(project);
     if (siblings.length === 0) {
         let printed = false;
@@ -4450,32 +4453,29 @@ function getSiblingOperations(project) {
 }
 
 const debug$3 = debugFactory('graphql-eslint:parser');
-debug$3('cwd %o', process.cwd());
+debug$3('cwd %o', CWD);
 function parseForESLint(code, options) {
     try {
         const { filePath } = options;
-        const realFilepath = getOnDiskFilepath(filePath);
-        const gqlConfig = loadGraphQLConfig(options);
-        const projectForFile = realFilepath
-            ? gqlConfig.getProjectForFile(realFilepath)
-            : gqlConfig.getDefault();
-        const schema = getSchema(projectForFile, options);
-        const siblingOperations = getSiblingOperations(projectForFile);
+        // First parse code from file, in case of syntax error do not try load schema,
+        // documents or even graphql-config instance
         const { document } = utils.parseGraphQLSDL(filePath, code, {
             ...options.graphQLParserOptions,
             noLocation: false,
         });
-        const comments = extractComments(document.loc);
-        const tokens = extractTokens(filePath, code);
+        const gqlConfig = loadGraphQLConfig(options);
+        const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, '');
+        const project = gqlConfig.getProjectForFile(realFilepath);
+        const schema = getSchema(project, options.schemaOptions);
         const rootTree = convertToESTree(document, schema instanceof graphql.GraphQLSchema ? schema : null);
         return {
             services: {
                 schema,
-                siblingOperations,
+                siblingOperations: getDocuments(project),
             },
             ast: {
-                comments,
-                tokens,
+                comments: extractComments(document.loc),
+                tokens: extractTokens(filePath, code),
                 loc: rootTree.loc,
                 range: rootTree.range,
                 type: 'Program',

package/index.mjs

@@ -6,12 +6,12 @@ import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { Kind, visit, validate, TokenKind, isScalarType, DirectiveLocation, isInterfaceType, TypeInfo, visitWithTypeInfo, isObjectType as isObjectType$1, Source, isNonNullType, isListType, GraphQLObjectType, GraphQLInterfaceType, GraphQLSchema, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
-import { statSync, existsSync, readFileSync } from 'fs';
 import lowerCase from 'lodash.lowercase';
 import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
 import { valueFromASTUntyped } from 'graphql/utilities/valueFromASTUntyped';
 import depthLimit from 'graphql-depth-limit';
-import fastGlob from 'fast-glob';
+import fg from 'fast-glob';
 import { RuleTester, Linter } from 'eslint';
 import { codeFrameColumns } from '@babel/code-frame';
 
@@ -158,26 +158,8 @@ const logger = {
     warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
 };
 const normalizePath = (path) => (path || '').replace(/\\/g, '/');
-/**
- * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
- * Given a filepath, get the nearest path that is a regular file.
- * The filepath provided by eslint may be a virtual filepath rather than a file
- * on disk. This attempts to transform a virtual path into an on-disk path
- */
-const getOnDiskFilepath = (filepath) => {
-    try {
-        if (statSync(filepath).isFile()) {
-            return filepath;
-        }
-    }
-    catch (err) {
-        // https://github.com/eslint/eslint/issues/11989
-        if (err.code === 'ENOTDIR') {
-            return getOnDiskFilepath(dirname(filepath));
-        }
-    }
-    return filepath;
-};
+const VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
+const CWD = process.cwd();
 const getTypeName = (node) => 'type' in node ? getTypeName(node.type) : node.name.value;
 const TYPES_KINDS = [
     Kind.OBJECT_TYPE_DEFINITION,
@@ -4108,7 +4090,7 @@ const checkNode = (context, node, ruleId) => {
             data: {
                 documentName,
                 summary: conflictingDocuments
-                    .map(f => `\t${relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
+                    .map(f => `\t${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ''))}`)
                     .join('\n'),
             },
             node: node.name,
@@ -4269,36 +4251,59 @@ const rules = {
     'unique-operation-name': rule$r,
 };
 
-const schemaCache = new Map();
+// Based on the `eslint-plugin-import`'s cache
+const log = debugFactory('graphql-eslint:ModuleCache');
+class ModuleCache {
+    constructor() {
+        this.map = new Map();
+    }
+    set(cacheKey, result) {
+        this.map.set(cacheKey, { lastSeen: process.hrtime(), result });
+        log('setting entry for', cacheKey);
+    }
+    get(cacheKey, settings = { lifetime: 10 /* seconds */ }) {
+        if (!this.map.has(cacheKey)) {
+            log('cache miss for', cacheKey);
+            return;
+        }
+        const { lastSeen, result } = this.map.get(cacheKey);
+        // check freshness
+        if (process.hrtime(lastSeen)[0] < settings.lifetime) {
+            return result;
+        }
+    }
+}
+
+const schemaCache = new ModuleCache();
 const debug$1 = debugFactory('graphql-eslint:schema');
-function getSchema(project, options = {}) {
-    const schemaKey = asArray(project.schema).sort().join(',');
+function getSchema(project, schemaOptions) {
+    const schemaKey = project.schema;
     if (!schemaKey) {
         return null;
     }
-    if (schemaCache.has(schemaKey)) {
-        return schemaCache.get(schemaKey);
+    const cache = schemaCache.get(schemaKey);
+    if (cache) {
+        return cache;
     }
     let schema;
     try {
         debug$1('Loading schema from %o', project.schema);
         schema = project.loadSchemaSync(project.schema, 'GraphQLSchema', {
-            ...options.schemaOptions,
+            ...schemaOptions,
             pluckConfig: project.extensions.pluckConfig,
         });
         if (debug$1.enabled) {
             debug$1('Schema loaded: %o', schema instanceof GraphQLSchema);
-            const schemaPaths = fastGlob.sync(project.schema, {
-                absolute: true,
-            });
+            const schemaPaths = fg.sync(project.schema, { absolute: true });
             debug$1('Schema pointers %O', schemaPaths);
         }
+        // Do not set error to cache, since cache reload will be done after some `lifetime` seconds
+        schemaCache.set(schemaKey, schema);
     }
     catch (error) {
         error.message = chalk.red(`Error while loading schema: ${error.message}`);
         schema = error;
     }
-    schemaCache.set(schemaKey, schema);
     return schema;
 }
 
@@ -4319,10 +4324,10 @@ const handleVirtualPath = (documents) => {
         };
     });
 };
-const operationsCache = new Map();
+const operationsCache = new ModuleCache();
 const siblingOperationsCache = new Map();
 const getSiblings = (project) => {
-    const documentsKey = asArray(project.documents).sort().join(',');
+    const documentsKey = project.documents;
     if (!documentsKey) {
         return [];
     }
@@ -4335,9 +4340,7 @@ const getSiblings = (project) => {
         });
         if (debug$2.enabled) {
             debug$2('Loaded %d operations', documents.length);
-            const operationsPaths = fastGlob.sync(project.documents, {
-                absolute: true,
-            });
+            const operationsPaths = fg.sync(project.documents, { absolute: true });
             debug$2('Operations pointers %O', operationsPaths);
         }
         siblings = handleVirtualPath(documents);
@@ -4345,7 +4348,7 @@ const getSiblings = (project) => {
     }
     return siblings;
 };
-function getSiblingOperations(project) {
+function getDocuments(project) {
     const siblings = getSiblings(project);
     if (siblings.length === 0) {
         let printed = false;
@@ -4444,32 +4447,29 @@ function getSiblingOperations(project) {
 }
 
 const debug$3 = debugFactory('graphql-eslint:parser');
-debug$3('cwd %o', process.cwd());
+debug$3('cwd %o', CWD);
 function parseForESLint(code, options) {
     try {
         const { filePath } = options;
-        const realFilepath = getOnDiskFilepath(filePath);
-        const gqlConfig = loadGraphQLConfig(options);
-        const projectForFile = realFilepath
-            ? gqlConfig.getProjectForFile(realFilepath)
-            : gqlConfig.getDefault();
-        const schema = getSchema(projectForFile, options);
-        const siblingOperations = getSiblingOperations(projectForFile);
+        // First parse code from file, in case of syntax error do not try load schema,
+        // documents or even graphql-config instance
         const { document } = parseGraphQLSDL(filePath, code, {
             ...options.graphQLParserOptions,
             noLocation: false,
         });
-        const comments = extractComments(document.loc);
-        const tokens = extractTokens(filePath, code);
+        const gqlConfig = loadGraphQLConfig(options);
+        const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, '');
+        const project = gqlConfig.getProjectForFile(realFilepath);
+        const schema = getSchema(project, options.schemaOptions);
         const rootTree = convertToESTree(document, schema instanceof GraphQLSchema ? schema : null);
         return {
             services: {
                 schema,
-                siblingOperations,
+                siblingOperations: getDocuments(project),
             },
             ast: {
-                comments,
-                tokens,
+                comments: extractComments(document.loc),
+                tokens: extractTokens(filePath, code),
                 loc: rootTree.loc,
                 range: rootTree.range,
                 type: 'Program',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.12.0",
+  "version": "3.13.0-alpha-20221024000319-1089aa0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {

package/schema.d.ts

@@ -1,3 +1,6 @@
+import { GraphQLSchema } from 'graphql';
 import { GraphQLProjectConfig } from 'graphql-config';
-import type { ParserOptions, Schema } from './types';
-export declare function getSchema(project: GraphQLProjectConfig, options?: Omit<ParserOptions, 'filePath'>): Schema;
+import { ParserOptions, Schema } from './types';
+import { ModuleCache } from './cache';
+export declare const schemaCache: ModuleCache<Error | GraphQLSchema, any>;
+export declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;

package/types.d.ts

@@ -1,10 +1,10 @@
-import type { Rule, AST, Linter } from 'eslint';
-import type * as ESTree from 'estree';
-import type { GraphQLSchema } from 'graphql';
-import type { IExtensions, IGraphQLProject } from 'graphql-config';
-import type { GraphQLParseOptions } from '@graphql-tools/utils';
-import type { GraphQLESLintRuleListener } from './testkit';
-import type { SiblingOperations } from './sibling-operations';
+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';
 export declare type Schema = GraphQLSchema | Error | null;
 export declare type Pointer = string | string[];
 export interface ParserOptions {

package/utils.d.ts

@@ -1,9 +1,8 @@
-import type { GraphQLSchema } from 'graphql';
-import { Kind } from 'graphql';
-import type { AST } from 'eslint';
-import type { Position } from 'estree';
-import type { GraphQLESLintRuleContext } from './types';
-import type { SiblingOperations } from './sibling-operations';
+import { GraphQLSchema, Kind } from 'graphql';
+import { AST } from 'eslint';
+import { Position } from 'estree';
+import { GraphQLESLintRuleContext } from './types';
+import { SiblingOperations } from './documents';
 export declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
 export declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
 export declare const logger: {
@@ -11,13 +10,8 @@ export declare const logger: {
     warn: (...args: any[]) => void;
 };
 export declare const normalizePath: (path: string) => string;
-/**
- * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
- * Given a filepath, get the nearest path that is a regular file.
- * The filepath provided by eslint may be a virtual filepath rather than a file
- * on disk. This attempts to transform a virtual path into an on-disk path
- */
-export declare const getOnDiskFilepath: (filepath: string) => string;
+export declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
+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 declare type CaseStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE' | 'kebab-case';