fix(language-service): improve types, nullable member access

Author: forivall

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

@@ -379,14 +379,12 @@ export class GraphQLLanguageService {
       }
 
       output.push({
-        // @ts-ignore
         name: tree.representativeName ?? 'Anonymous',
         kind: getKind(tree),
         location: {
           uri: filePath,
           range: {
             start: tree.startPosition,
-            // @ts-ignore
             end: tree.endPosition,
           },
         },

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

@@ -66,7 +66,12 @@ import {
   LoaderNoResultError,
   ProjectNotFoundError,
 } from 'graphql-config';
-import type { LoadConfigOptions, LocateCommand } from './types';
+import type {
+  LoadConfigOptions,
+  LocateCommand,
+  VSCodeGraphQLConfigLoadSettings,
+  VSCodeGraphQLSettings,
+} from './types';
 import {
   DEFAULT_SUPPORTED_EXTENSIONS,
   SupportedExtensionsEnum,
@@ -89,6 +94,13 @@ function toPosition(position: VscodePosition): IPosition {
   return new Position(position.line, position.character);
 }
 
+interface MessageProcessorSettings extends VSCodeGraphQLSettings {
+  load: VSCodeGraphQLConfigLoadSettings & {
+    fileName?: string;
+    [key: string]: unknown;
+  };
+}
+
 export class MessageProcessor {
   private _connection: Connection;
   private _graphQLCache!: GraphQLCache;
@@ -103,7 +115,7 @@ export class MessageProcessor {
   private _tmpDirBase: string;
   private _loadConfigOptions: LoadConfigOptions;
   private _rootPath: string = process.cwd();
-  private _settings: any;
+  private _settings: MessageProcessorSettings = { load: {} };
   private _providedConfig?: GraphQLConfig;
 
   constructor({
@@ -210,7 +222,7 @@ export class MessageProcessor {
     // TODO: eventually we will instantiate an instance of this per workspace,
     // so rootDir should become that workspace's rootDir
     this._settings = { ...settings, ...vscodeSettings };
-    const rootDir = this._settings?.load?.rootDir.length
+    const rootDir = this._settings?.load?.rootDir?.length
       ? this._settings?.load?.rootDir
       : this._rootPath;
     if (settings?.dotEnvPath) {

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

@@ -115,3 +115,45 @@ export interface ServerOptions {
    */
   debug?: true;
 }
+
+export interface VSCodeGraphQLSettings {
+  /**
+   * Enable debug logs and node debugger for client
+   */
+  debug?: boolean | null;
+  /**
+   * Use a cached file output of your graphql-config schema result for definition lookups, symbols, outline, etc. Enabled by default when one or more schema entry is not a local file with SDL in it. Disable if you want to use SDL with a generated schema.
+   */
+  cacheSchemaFileForLookup?: boolean;
+  /**
+   * Disables outlining and other expensive operations for files larger than this threshold (in bytes). Defaults to 1000000 (one million).
+   */
+  largeFileThreshold?: number;
+  /**
+   * Fail the request on invalid certificate
+   */
+  rejectUnauthorized?: boolean;
+  /**
+   * Schema cache ttl in milliseconds - the interval before requesting a fresh schema when caching the local schema file is enabled. Defaults to 30000 (30 seconds).
+   */
+  schemaCacheTTL?: number;
+}
+
+export interface VSCodeGraphQLConfigLoadSettings {
+  /**
+   * Base dir for graphql config loadConfig(), to look for config files or package.json
+   */
+  rootDir?: string;
+  /**
+   * exact filePath for a `graphql-config` file `loadConfig()`
+   */
+  filePath?: string;
+  /**
+   * optional <configName>.config.{js,ts,toml,yaml,json} & <configName>rc* instead of default `graphql`
+   */
+  configName?: string;
+  /**
+   * legacy mode for graphql config v2 config
+   */
+  legacy?: boolean;
+}

packages/graphql-language-service/src/interface/getOutline.ts

@@ -19,7 +19,9 @@ import {
   Kind,
   parse,
   visit,
+  ASTNode,
   FieldNode,
+  ArgumentNode,
   InlineFragmentNode,
   DocumentNode,
   FragmentSpreadNode,
@@ -35,7 +37,9 @@ import {
   InputValueDefinitionNode,
   FieldDefinitionNode,
   EnumValueDefinitionNode,
+  InputObjectTypeDefinitionNode,
 } from 'graphql';
+import type { ASTReducer } from 'graphql/language/visitor';
 
 import { offsetToPosition } from '../utils';
 
@@ -59,27 +63,47 @@ const OUTLINEABLE_KINDS = {
   FieldDefinition: true,
 };
 
-export type OutlineableKinds = keyof typeof OUTLINEABLE_KINDS;
-
-// type OutlineableNodes = FieldNode | OperationDefinitionNode | DocumentNode | SelectionSetNode | NameNode | FragmentDefinitionNode | FragmentSpreadNode |InlineFragmentNode | ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode
+type LiteralToEnum<Literal, Enum> = Enum extends never
+  ? never
+  : { 0: Enum }[Enum extends Literal ? 0 : never];
+
+export type OutlineableKinds = LiteralToEnum<
+  keyof typeof OUTLINEABLE_KINDS,
+  Kind
+>;
+
+type OutlineableNode = Extract<ASTNode, { kind: OutlineableKinds }>;
+type AllKeys<T> = T extends unknown ? keyof T : never;
+type ExclusiveUnion<T, K extends PropertyKey = AllKeys<T>> = T extends never
+  ? never
+  : T & Partial<Record<Exclude<K, keyof T>, never>>;
+
+type OutlineTreeResultMeta = {
+  representativeName?: string | NameNode;
+  startPosition: IPosition;
+  endPosition: IPosition;
+  kind: OutlineableKinds;
+  children:
+    | SelectionSetNode
+    | readonly ArgumentNode[]
+    | readonly FieldDefinitionNode[]
+    | readonly EnumValueDefinitionNode[]
+    | readonly InputValueDefinitionNode[];
+};
 
 type OutlineTreeResult =
-  | {
-      representativeName: string;
-      startPosition: IPosition;
-      endPosition: IPosition;
-      children: SelectionSetNode[] | [];
-      tokenizedText: TextToken[];
-    }
+  | (OutlineTreeResultMeta & { tokenizedText: TextToken[] })
   | string
   | readonly DefinitionNode[]
   | readonly SelectionNode[]
   | FieldNode[]
   | SelectionSetNode;
 
-type OutlineTreeConverterType = Partial<{
-  [key in OutlineableKinds]: (node: any) => OutlineTreeResult;
-}>;
+type OutlineTreeConverterType = {
+  [key in OutlineableKinds]: (
+    node: Extract<OutlineableNode, { kind: key }>,
+  ) => OutlineTreeResult;
+};
 
 export function getOutline(documentText: string): Outline | null {
   let ast;
@@ -89,28 +113,30 @@ export function getOutline(documentText: string): Outline | null {
     return null;
   }
 
-  const visitorFns = outlineTreeConverter(documentText);
+  type VisitorFns = Record<Kind, (node: ASTNode) => OutlineTreeResult>;
+  const visitorFns = outlineTreeConverter(documentText) as VisitorFns;
   const outlineTrees = visit(ast, {
-    leave(node) {
-      if (visitorFns !== undefined && node.kind in visitorFns) {
-        // @ts-ignore
+    leave(node: ASTNode) {
+      if (node.kind in visitorFns) {
         return visitorFns[node.kind](node);
       }
       return null;
     },
-  }) as unknown as OutlineTree[];
+  } as ASTReducer<OutlineTreeResult>) as OutlineTree[];
 
   return { outlineTrees };
 }
 
 function outlineTreeConverter(docText: string): OutlineTreeConverterType {
-  // TODO: couldn't find a type that would work for all cases here,
-  // however the inference is not broken by this at least
-  const meta = (node: any) => {
+  type MetaNode = Exclude<
+    OutlineableNode,
+    DocumentNode | SelectionSetNode | NameNode | InlineFragmentNode
+  >;
+  const meta = (node: ExclusiveUnion<MetaNode>): OutlineTreeResultMeta => {
     return {
       representativeName: node.name,
-      startPosition: offsetToPosition(docText, node.loc.start),
-      endPosition: offsetToPosition(docText, node.loc.end),
+      startPosition: offsetToPosition(docText, node.loc!.start),
+      endPosition: offsetToPosition(docText, node.loc!.end),
       kind: node.kind,
       children:
         node.selectionSet || node.fields || node.values || node.arguments || [],
@@ -176,7 +202,7 @@ function outlineTreeConverter(docText: string): OutlineTreeConverterType {
       ],
       ...meta(node),
     }),
-    InputObjectTypeDefinition: (node: ObjectTypeDefinitionNode) => ({
+    InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => ({
       tokenizedText: [
         buildToken('keyword', 'input'),
         buildToken('whitespace', ' '),

packages/graphql-language-service/src/types.ts

@@ -217,7 +217,7 @@ export type OutlineTree = {
   representativeName?: string;
   kind: string;
   startPosition: IPosition;
-  endPosition?: IPosition;
+  endPosition: IPosition;
   children: OutlineTree[];
 };