@mo36924/graphql-plugin 1.6.2 → 5.0.69

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/LICENSE +1 -1
  2. package/dist/index.cjs +180 -255
  3. package/dist/index.d.ts +2 -2
  4. package/dist/index.js +180 -255
  5. package/package.json +24 -24
  6. package/dist/index.cjs.map +0 -1
  7. package/dist/index.js.map +0 -1
  8. package/dist/index.mjs +0 -296
  9. package/dist/index.mjs.map +0 -1
package/LICENSE CHANGED
@@ -1,6 +1,6 @@
1
1
  MIT License
2
2
 
3
- Copyright (c) 2021 mo36924
3
+ Copyright (c) 2023 mo36924
4
4
 
5
5
  Permission is hereby granted, free of charge, to any person obtaining a copy
6
6
  of this software and associated documentation files (the "Software"), to deal
package/dist/index.cjs CHANGED
@@ -1,127 +1,90 @@
1
1
  'use strict';
2
2
 
3
- const fs = require('fs');
4
- const path = require('path');
5
- const graphqlSchema = require('@mo36924/graphql-schema');
6
- const graphql = require('graphql');
7
- const graphqlLanguageServiceInterface = require('graphql-language-service-interface');
8
- const graphqlLanguageServiceUtils = require('graphql-language-service-utils');
9
- const vscodeLanguageserverTypes = require('vscode-languageserver-types');
3
+ var graphql = require('@mo36924/graphql');
4
+ var graphql$1 = require('graphql');
5
+ var graphqlLanguageService = require('graphql-language-service');
10
6
 
11
- const init = ({ typescript: ts }) => {
12
- return {
13
- create(info) {
14
- const languageService = info.languageService;
15
- const config = info.config;
16
- const cwd = info.project.getCurrentDirectory();
17
- const modelPath = config.model && path.resolve(cwd, config.model);
18
- const schemaPath = config.schema && path.resolve(cwd, config.schema);
19
- const watchPath = modelPath || schemaPath;
20
- let schema = graphql.buildSchema("scalar Unknown");
21
- const addScalarUnknownType = (schemaCode) => schemaCode.includes("scalar Unknown") ? schemaCode : `${schemaCode}\nscalar Unknown`;
22
- const changeModel = () => {
23
- schema = graphql.buildSchema(addScalarUnknownType(graphqlSchema.printSchemaModel(fs.readFileSync(modelPath, "utf8"))));
24
- };
25
- const changeSchema = () => {
26
- schema = graphql.buildSchema(addScalarUnknownType(fs.readFileSync(schemaPath, "utf8")));
27
- };
28
- const update = modelPath ? changeModel : changeSchema;
29
- const listener = () => {
30
- try {
31
- update();
32
- }
33
- catch { }
34
- };
35
- try {
36
- update();
37
- fs.watch(watchPath, listener);
7
+ const init = ({ typescript: ts })=>{
8
+ const isQueryTag = (node)=>ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.escapedText === "gql";
9
+ const getScriptElementKind = (completionItemKind)=>{
10
+ switch(completionItemKind){
11
+ case graphqlLanguageService.CompletionItemKind.Function:
12
+ case graphqlLanguageService.CompletionItemKind.Constructor:
13
+ return ts.ScriptElementKind.functionElement;
14
+ case graphqlLanguageService.CompletionItemKind.Field:
15
+ case graphqlLanguageService.CompletionItemKind.Variable:
16
+ return ts.ScriptElementKind.memberVariableElement;
17
+ default:
18
+ return ts.ScriptElementKind.unknown;
19
+ }
20
+ };
21
+ const getDiagnosticCategory = (diagnosticSeverity)=>{
22
+ switch(diagnosticSeverity){
23
+ case graphqlLanguageService.DIAGNOSTIC_SEVERITY.Warning:
24
+ return ts.DiagnosticCategory.Warning;
25
+ case graphqlLanguageService.DIAGNOSTIC_SEVERITY.Information:
26
+ return ts.DiagnosticCategory.Message;
27
+ case graphqlLanguageService.DIAGNOSTIC_SEVERITY.Hint:
28
+ return ts.DiagnosticCategory.Suggestion;
29
+ default:
30
+ return ts.DiagnosticCategory.Error;
31
+ }
32
+ };
33
+ const getHoverQueryTag = (sourceFile, position)=>{
34
+ const tag = ts.forEachChild(sourceFile, function visitor(node) {
35
+ if (position < node.pos) {
36
+ return true;
38
37
  }
39
- catch {
40
- fs.watchFile(watchPath, () => {
41
- try {
42
- update();
43
- fs.watch(watchPath, listener);
44
- fs.unwatchFile(watchPath);
45
- }
46
- catch { }
47
- });
38
+ if (position >= node.end) {
39
+ return;
48
40
  }
49
- const getSourceFile = (fileName) => languageService.getProgram()?.getSourceFile(fileName);
50
- const isGraphqlTag = (tag) => {
51
- switch (tag) {
52
- case "query":
53
- case "mutation":
54
- case "subscription":
55
- return true;
56
- default:
57
- return false;
58
- }
59
- };
60
- const getDiagnosticCategory = (severity) => {
61
- switch (severity) {
62
- case vscodeLanguageserverTypes.DiagnosticSeverity.Error:
63
- return ts.DiagnosticCategory.Error;
64
- case vscodeLanguageserverTypes.DiagnosticSeverity.Warning:
65
- return ts.DiagnosticCategory.Warning;
66
- case vscodeLanguageserverTypes.DiagnosticSeverity.Information:
67
- return ts.DiagnosticCategory.Message;
68
- case vscodeLanguageserverTypes.DiagnosticSeverity.Hint:
69
- return ts.DiagnosticCategory.Suggestion;
70
- default:
71
- return ts.DiagnosticCategory.Error;
72
- }
73
- };
74
- const hover = (sourceFile, position) => {
75
- const tag = ts.forEachChild(sourceFile, function visitor(node) {
76
- if (position < node.pos) {
77
- return true;
41
+ if (isQueryTag(node)) {
42
+ const template = node.template;
43
+ if (ts.isNoSubstitutionTemplateLiteral(template)) {
44
+ if (position >= template.getStart() + 1 && position < template.getEnd() - 1) {
45
+ return node;
78
46
  }
79
- if (position >= node.end) {
80
- return;
47
+ } else {
48
+ const head = template.head;
49
+ if (position >= head.getStart() + 1 && position < head.getEnd() - 2) {
50
+ return node;
81
51
  }
82
- if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isGraphqlTag(node.tag.getText())) {
83
- const template = node.template;
84
- if (ts.isNoSubstitutionTemplateLiteral(template)) {
85
- if (position >= template.getStart() + 1 && position < template.getEnd() - 1) {
86
- return node;
87
- }
88
- }
89
- else {
90
- const head = template.head;
91
- if (position >= head.getStart() + 1 && position < head.getEnd() - 2) {
92
- return node;
93
- }
94
- for (const { literal } of template.templateSpans) {
95
- if (position >= literal.getStart() + 1 &&
96
- position < literal.getEnd() - (ts.isTemplateMiddle(literal) ? 2 : 1)) {
97
- return node;
98
- }
99
- }
52
+ for (const { literal } of template.templateSpans){
53
+ if (position >= literal.getStart() + 1 && position < literal.getEnd() - (ts.isTemplateMiddle(literal) ? 2 : 1)) {
54
+ return node;
100
55
  }
101
56
  }
102
- return ts.forEachChild(node, visitor);
103
- });
104
- if (tag === true) {
105
- return;
106
57
  }
107
- return tag;
108
- };
109
- const fix = (node) => {
58
+ }
59
+ return ts.forEachChild(node, visitor);
60
+ });
61
+ if (tag === true) {
62
+ return;
63
+ }
64
+ return tag;
65
+ };
66
+ return {
67
+ create (info) {
68
+ const { path, schema } = graphql.getConfig();
69
+ const languageService = info.languageService;
70
+ if (!path) {
71
+ return languageService;
72
+ }
73
+ const getSourceFile = (fileName)=>languageService.getProgram()?.getSourceFile(fileName);
74
+ const normalizeQuery = (node)=>{
110
75
  const template = node.template;
111
76
  let query = "";
112
- let variables = "";
113
77
  if (ts.isNoSubstitutionTemplateLiteral(template)) {
114
- // 2 ``
78
+ // 2 \`\`
115
79
  const templateWidth = template.getWidth() - 2;
116
80
  query = template.text.padStart(templateWidth);
117
- }
118
- else {
81
+ } else {
119
82
  const head = template.head;
120
83
  const templateSpans = template.templateSpans;
121
- // 3 `...${
84
+ // 3 \`...\${
122
85
  const templateWidth = head.getWidth() - 3;
123
86
  query = head.text.padStart(templateWidth);
124
- templateSpans.forEach((span, i) => {
87
+ templateSpans.forEach((span, i)=>{
125
88
  const spanWidth = span.getFullWidth();
126
89
  const literal = span.literal;
127
90
  const literalWidth = literal.getWidth();
@@ -131,168 +94,130 @@ const init = ({ typescript: ts }) => {
131
94
  const templateWidth = literalWidth - (ts.isTemplateTail(literal) ? 2 : 3);
132
95
  const template = literal.text.padStart(templateWidth);
133
96
  query += variable + template;
134
- variables += variableName + ":Unknown";
135
97
  });
136
98
  }
137
- const tag = node.tag.getText();
138
- let offset = template.getStart() + 1;
139
- query = query.replace(/\n|\r/g, " ");
140
- if (variables) {
141
- query = `${tag}(${variables}){${query}}`;
142
- offset -= tag.length + variables.length + 3;
143
- }
144
- else if (tag === "query") {
145
- query = `{${query}}`;
146
- offset -= 1;
147
- }
148
- else {
149
- query = `${tag}{${query}}`;
150
- offset -= tag.length + 1;
151
- }
152
- const documentNode = graphql.parse(query);
153
- const errors = graphql.validate(schema, documentNode);
154
- for (const error of errors) {
155
- const match = error.message.match(/^Variable ".*?" of type "Unknown" used in position expecting type "(.*?)"\.$/);
156
- if (match) {
157
- query = query.replace("Unknown", match[1]);
158
- offset += 7 - match[1].length;
159
- }
160
- }
99
+ const field = query.match(/\w+/)?.[0] ?? "";
100
+ const isMutation = !!schema.getMutationType()?.getFields()[field];
101
+ const operation = isMutation ? "mutation" : "query";
102
+ query = operation + query.replace(/\n|\r/g, " ");
103
+ const offset = -operation.length + template.getStart() + 1;
161
104
  return {
162
105
  query,
163
- offset,
106
+ offset
164
107
  };
165
108
  };
166
- const proxy = Object.create(null);
167
- for (const [key, value] of Object.entries(languageService)) {
168
- proxy[key] = value.bind(languageService);
169
- }
170
- proxy.getQuickInfoAtPosition = (fileName, position) => {
171
- const sourceFile = getSourceFile(fileName);
172
- if (!sourceFile) {
173
- return undefined;
174
- }
175
- const tag = hover(sourceFile, position);
176
- if (!tag) {
177
- return languageService.getQuickInfoAtPosition(fileName, position);
178
- }
179
- let result;
180
- try {
181
- result = fix(tag);
182
- }
183
- catch {
184
- return languageService.getQuickInfoAtPosition(fileName, position);
185
- }
186
- const { query, offset } = result;
187
- const cursor = new graphqlLanguageServiceUtils.Position(0, position - offset + 1);
188
- const token = graphqlLanguageServiceInterface.getTokenAtPosition(query, cursor);
189
- const marked = graphqlLanguageServiceInterface.getHoverInformation(schema, query, cursor, token);
190
- if (marked === "" || typeof marked !== "string") {
191
- return;
192
- }
193
- return {
194
- kind: ts.ScriptElementKind.string,
195
- textSpan: {
196
- start: offset + token.start,
197
- length: token.end - token.start,
198
- },
199
- kindModifiers: "",
200
- displayParts: [{ text: marked, kind: "" }],
201
- };
202
- };
203
- proxy.getCompletionsAtPosition = (fileName, position, options) => {
204
- const sourceFile = getSourceFile(fileName);
205
- if (!sourceFile) {
206
- return undefined;
207
- }
208
- const tag = hover(sourceFile, position);
209
- if (!tag) {
210
- return languageService.getCompletionsAtPosition(fileName, position, options);
211
- }
212
- let result;
213
- try {
214
- result = fix(tag);
215
- }
216
- catch {
217
- return languageService.getCompletionsAtPosition(fileName, position, options);
218
- }
219
- const { query, offset } = result;
220
- const cursor = new graphqlLanguageServiceUtils.Position(0, position - offset);
221
- const items = graphqlLanguageServiceInterface.getAutocompleteSuggestions(schema, query, cursor);
222
- if (!items.length) {
223
- return;
224
- }
225
- return {
226
- isGlobalCompletion: false,
227
- isMemberCompletion: false,
228
- isNewIdentifierLocation: false,
229
- entries: items.map((item) => {
230
- let kind;
231
- switch (item.kind) {
232
- case vscodeLanguageserverTypes.CompletionItemKind.Function:
233
- case vscodeLanguageserverTypes.CompletionItemKind.Constructor:
234
- kind = ts.ScriptElementKind.functionElement;
235
- break;
236
- case vscodeLanguageserverTypes.CompletionItemKind.Field:
237
- case vscodeLanguageserverTypes.CompletionItemKind.Variable:
238
- kind = ts.ScriptElementKind.memberVariableElement;
239
- break;
240
- default:
241
- kind = ts.ScriptElementKind.unknown;
242
- break;
243
- }
244
- return {
245
- name: item.label,
246
- kindModifiers: "",
247
- kind,
248
- sortText: "",
249
- };
250
- }),
251
- };
252
- };
253
- proxy.getSemanticDiagnostics = (fileName) => {
254
- const diagnostics = languageService.getSemanticDiagnostics(fileName);
255
- const sourceFile = getSourceFile(fileName);
256
- if (!sourceFile) {
257
- return diagnostics;
258
- }
259
- ts.forEachChild(sourceFile, function visitor(node) {
260
- if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isGraphqlTag(node.tag.getText())) {
261
- try {
262
- const { query, offset } = fix(node);
263
- const _diagnostics = graphqlLanguageServiceInterface.getDiagnostics(query, schema);
264
- for (const { range: { start, end }, severity, message, } of _diagnostics) {
265
- diagnostics.push({
266
- category: getDiagnosticCategory(severity),
267
- code: 9999,
268
- messageText: message,
269
- file: sourceFile,
270
- start: start.character + offset,
271
- length: end.character - start.character,
272
- });
109
+ const proxy = {
110
+ ...languageService,
111
+ getQuickInfoAtPosition (fileName, position) {
112
+ const sourceFile = getSourceFile(fileName);
113
+ if (!sourceFile) {
114
+ return;
115
+ }
116
+ const tag = getHoverQueryTag(sourceFile, position);
117
+ if (!tag) {
118
+ return languageService.getQuickInfoAtPosition(fileName, position);
119
+ }
120
+ const { query, offset } = normalizeQuery(tag);
121
+ const cursor = new graphqlLanguageService.Position(0, position - offset);
122
+ const token = graphqlLanguageService.getTokenAtPosition(query, cursor);
123
+ const marked = graphqlLanguageService.getHoverInformation(schema, query, cursor, token);
124
+ if (marked === "" || typeof marked !== "string") {
125
+ return;
126
+ }
127
+ return {
128
+ kind: ts.ScriptElementKind.string,
129
+ textSpan: {
130
+ start: offset + token.start,
131
+ length: token.end - token.start
132
+ },
133
+ kindModifiers: "",
134
+ displayParts: [
135
+ {
136
+ text: marked,
137
+ kind: ""
273
138
  }
274
- }
275
- catch (error) {
276
- if (error instanceof graphql.GraphQLError) {
277
- diagnostics.push({
278
- category: ts.DiagnosticCategory.Error,
279
- code: 9999,
280
- messageText: error.message,
281
- file: sourceFile,
282
- start: node.template.getStart() + 1,
283
- length: node.template.getWidth() - 2,
284
- });
139
+ ]
140
+ };
141
+ },
142
+ getCompletionsAtPosition (fileName, position, options) {
143
+ const sourceFile = getSourceFile(fileName);
144
+ if (!sourceFile) {
145
+ return;
146
+ }
147
+ const tag = getHoverQueryTag(sourceFile, position);
148
+ if (!tag) {
149
+ return languageService.getCompletionsAtPosition(fileName, position, options);
150
+ }
151
+ const { query, offset } = normalizeQuery(tag);
152
+ const cursor = new graphqlLanguageService.Position(0, position - offset);
153
+ const items = graphqlLanguageService.getAutocompleteSuggestions(schema, query, cursor);
154
+ if (/^\s*\{\s*\}\s*$/.test(query)) {
155
+ const operation = "mutation";
156
+ const cursor = new graphqlLanguageService.Position(0, operation.length + position - offset);
157
+ const labels = new Set(items.map((item)=>item.label));
158
+ const mutationItems = graphqlLanguageService.getAutocompleteSuggestions(schema, operation + query, cursor).filter((item)=>!labels.has(item.label));
159
+ items.push(...mutationItems);
160
+ }
161
+ if (!items.length) {
162
+ return;
163
+ }
164
+ return {
165
+ isGlobalCompletion: false,
166
+ isMemberCompletion: false,
167
+ isNewIdentifierLocation: false,
168
+ entries: items.map((item)=>({
169
+ name: item.label,
170
+ kindModifiers: "",
171
+ kind: getScriptElementKind(item.kind),
172
+ sortText: ""
173
+ }))
174
+ };
175
+ },
176
+ getSemanticDiagnostics (fileName) {
177
+ const diagnostics = languageService.getSemanticDiagnostics(fileName);
178
+ const sourceFile = getSourceFile(fileName);
179
+ if (!sourceFile) {
180
+ return diagnostics;
181
+ }
182
+ ts.forEachChild(sourceFile, function visitor(node) {
183
+ if (isQueryTag(node)) {
184
+ try {
185
+ const { query, offset } = normalizeQuery(node);
186
+ const _diagnostics = graphqlLanguageService.getDiagnostics(query, schema);
187
+ for (const { range: { start, end }, severity, message } of _diagnostics){
188
+ if (/Variable "\$.*?" is not defined/.test(message)) {
189
+ continue;
190
+ }
191
+ diagnostics.push({
192
+ category: getDiagnosticCategory(severity),
193
+ code: 9999,
194
+ messageText: message,
195
+ file: sourceFile,
196
+ start: start.character + offset,
197
+ length: end.character - start.character
198
+ });
199
+ }
200
+ } catch (error) {
201
+ if (error instanceof graphql$1.GraphQLError) {
202
+ diagnostics.push({
203
+ category: ts.DiagnosticCategory.Error,
204
+ code: 9999,
205
+ messageText: error.message,
206
+ file: sourceFile,
207
+ start: node.template.getStart() + 1,
208
+ length: node.template.getWidth() - 2
209
+ });
210
+ }
285
211
  }
286
212
  }
287
- }
288
- ts.forEachChild(node, visitor);
289
- });
290
- return diagnostics;
213
+ ts.forEachChild(node, visitor);
214
+ });
215
+ return diagnostics;
216
+ }
291
217
  };
292
218
  return proxy;
293
- },
219
+ }
294
220
  };
295
221
  };
296
222
 
297
223
  module.exports = init;
298
- //# sourceMappingURL=index.cjs.map
package/dist/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
- import { server } from 'typescript/lib/tsserverlibrary';
1
+ import ts__default from 'typescript';
2
2
 
3
- declare const init: server.PluginModuleFactory;
3
+ declare const init: ts__default.server.PluginModuleFactory;
4
4
 
5
5
  export { init as default };