add integration spec coverage for cacheing the schema file!

packages/graphql-language-service-server/src/MessageProcessor.ts

@@ -7,8 +7,7 @@
  *
  */
 
-import mkdirp from 'mkdirp';
-import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import * as path from 'node:path';
 import { URI } from 'vscode-uri';
@@ -147,7 +146,7 @@ export class MessageProcessor {
     }
 
     if (!existsSync(this._tmpDirBase)) {
-      void mkdirp(this._tmpDirBase);
+      mkdirSync(this._tmpDirBase);
     }
   }
   get connection(): Connection {
@@ -972,7 +971,9 @@ export class MessageProcessor {
     const basePath = path.join(this._tmpDirBase, workspaceName);
     let projectTmpPath = path.join(basePath, 'projects', project.name);
     if (!existsSync(projectTmpPath)) {
-      void mkdirp(projectTmpPath);
+      mkdirSync(projectTmpPath, {
+        recursive: true,
+      });
     }
     if (appendPath) {
       projectTmpPath = path.join(projectTmpPath, appendPath);

packages/graphql-language-service-server/src/__tests__/MessageProcessor.spec.ts

@@ -5,6 +5,8 @@ jest.mock('../Logger');
 import { NoopLogger } from '../Logger';
 import mockfs from 'mock-fs';
 import { join } from 'node:path';
+import { MockLogger, MockProject } from './__utils__/MockProject';
+import { readFileSync, readdirSync } from 'node:fs';
 
 describe('MessageProcessor with no config', () => {
   let messageProcessor: MessageProcessor;
@@ -165,3 +167,69 @@ describe('MessageProcessor with no config', () => {
     // );
   });
 });
+
+describe.only('project with simple config', () => {
+  afterEach(() => {
+    mockfs.restore();
+  });
+  it('caches files and schema with .graphql file config', async () => {
+    const project = new MockProject({
+      files: [
+        ['graphql.config.json', '{ "schema": "./schema.graphql" }'],
+        [
+          'schema.graphql',
+          'type Query { foo: Foo }\n\ntype Foo { bar: String }',
+        ],
+        ['query.graphql', 'query { bar }'],
+      ],
+    });
+    await project.lsp.handleInitializeRequest({
+      rootPath: project.root,
+      rootUri: project.root,
+      capabilities: {},
+      processId: 200,
+      workspaceFolders: null,
+    });
+    await project.lsp.handleDidOpenOrSaveNotification({
+      textDocument: { uri: project.uri('query.graphql') },
+    });
+    expect(project.lsp._logger.error).not.toHaveBeenCalled();
+    // console.log(project.lsp._graphQLCache.getSchema('schema.graphql'));
+    expect(await project.lsp._graphQLCache.getSchema()).toBeDefined();
+    expect(Array.from(project.lsp._textDocumentCache)).toEqual([]);
+  });
+  it('caches files and schema with a URL config', async () => {
+    const project = new MockProject({
+      files: [
+        [
+          'graphql.config.json',
+          '{ "schema": "https://rickandmortyapi.com/graphql" }',
+        ],
+        [
+          'schema.graphql',
+          'type Query { foo: Foo }\n\ntype Foo { bar: String }',
+        ],
+        ['query.graphql', 'query { bar }'],
+      ],
+    });
+    await project.lsp.handleInitializeRequest({
+      rootPath: project.root,
+      rootUri: project.root,
+      capabilities: {},
+      processId: 200,
+      workspaceFolders: null,
+    });
+    await project.lsp.handleDidOpenOrSaveNotification({
+      textDocument: { uri: project.uri('query.graphql') },
+    });
+    expect(project.lsp._logger.error).not.toHaveBeenCalled();
+    // console.log(project.lsp._graphQLCache.getSchema('schema.graphql'));
+    expect(await project.lsp._graphQLCache.getSchema()).toBeDefined();
+    const file = readFileSync(
+      join(
+        '/tmp/graphql-language-service/test/projects/default/generated-schema.graphql',
+      ),
+    );
+    expect(file.toString('utf-8').length).toBeGreaterThan(0);
+  });
+});

packages/graphql-language-service-server/src/__tests__/__utils__/MockProject.ts

@@ -0,0 +1,78 @@
+import mockfs from 'mock-fs';
+import { MessageProcessor } from '../../MessageProcessor';
+import { Logger as VSCodeLogger } from 'vscode-jsonrpc';
+import { URI } from 'vscode-uri';
+
+export class MockLogger implements VSCodeLogger {
+  error = jest.fn();
+  warn = jest.fn();
+  info = jest.fn();
+  log = jest.fn();
+}
+
+const defaultMocks = {
+  'node_modules/parse-json': mockfs.load('node_modules/parse-json'),
+  'node_modules/error-ex': mockfs.load('node_modules/error-ex'),
+  'node_modules/is-arrayish': mockfs.load('node_modules/is-arrayish'),
+  'node_modules/json-parse-even-better-errors': mockfs.load(
+    'node_modules/json-parse-even-better-errors',
+  ),
+  'node_modules/lines-and-columns': mockfs.load(
+    'node_modules/lines-and-columns',
+  ),
+  'node_modules/@babel/code-frame': mockfs.load(
+    'node_modules/@babel/code-frame',
+  ),
+  'node_modules/@babel/highlight': mockfs.load('node_modules/@babel/highlight'),
+  '/tmp/graphql-language-service/test/projects': mockfs.directory({
+    mode: 0o777,
+  }),
+};
+
+export class MockProject {
+  private root: string;
+  private messageProcessor: MessageProcessor;
+  constructor({
+    files = [],
+    root = '/tmp/test',
+    settings,
+  }: {
+    files: [filename: string, text: string][];
+    root?: string;
+    settings?: [name: string, vale: any][];
+  }) {
+    this.root = root;
+    const mockFiles = { ...defaultMocks };
+    files.map(([filename, text]) => {
+      mockFiles[this.filePath(filename)] = text;
+    });
+    mockfs(mockFiles);
+    this.messageProcessor = new MessageProcessor({
+      connection: {
+        get workspace() {
+          return {
+            async getConfiguration() {
+              return settings;
+            },
+          };
+        },
+      },
+      logger: new MockLogger(),
+      loadConfigOptions: { rootDir: root },
+    });
+  }
+  public filePath(filename: string) {
+    return `${this.root}/${filename}`;
+  }
+  public uri(filename: string) {
+    return URI.file(this.filePath(filename)).toString();
+  }
+  changeFile(filename: string, text: string) {
+    mockfs({
+      [this.filePath(filename)]: text,
+    });
+  }
+  get lsp() {
+    return this.messageProcessor;
+  }
+}