commit 474ca19d7a1247eabffdca3e3bf16a91184e4169 · kitten.sh/graphqlsp

+5

.changeset/spicy-garlics-drum.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       '@0no-co/graphqlsp': minor

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Expose `findAllCallExpressions` on `@0no-co/graphqlsp/api`

+7 -1

packages/graphqlsp/src/api.ts

···

       1
       1
        
       export { getGraphQLDiagnostics } from './diagnostics';

     

       2
       2
        
       export { init } from './ts';

     

       3
       3
       -
       export { findAllPersistedCallExpressions, unrollTadaFragments } from './ast';

     

       3
       3
       +
       

     

       4
       4
       +
       export {

     

       5
       5
       +
         findAllPersistedCallExpressions,

     

       6
       6
       +
         findAllCallExpressions,

     

       7
       7
       +
         unrollTadaFragments,

     

       8
       8
       +
       } from './ast';

     

       9
       9
       +
       

     

       4
       10
        
       export {

     

       5
       11
        
         getDocumentReferenceFromTypeQuery,

     

       6
       12
        
         getDocumentReferenceFromDocumentNode,

+19 -6

packages/graphqlsp/src/ast/index.ts

···

       207
       207
        
       }

     

       208
       208
        
       

     

       209
       209
        
       export function findAllPersistedCallExpressions(

     

       210
       210
       +
         sourceFile: ts.SourceFile

     

       211
       211
       +
       ): Array<ts.CallExpression>;

     

       212
       212
       +
       export function findAllPersistedCallExpressions(

     

       210
       213
        
         sourceFile: ts.SourceFile,

     

       211
       214
        
         info: ts.server.PluginCreateInfo

     

       212
       212
       -
       ): Array<{ node: ts.CallExpression; schema: string | null }> {

     

       213
       213
       -
         const result: Array<{ node: ts.CallExpression; schema: string | null }> = [];

     

       214
       214
       -
         const typeChecker = info.languageService.getProgram()?.getTypeChecker();

     

       215
       215
       +
       ): Array<{ node: ts.CallExpression; schema: string | null }>;

     

       216
       216
       +
       

     

       217
       217
       +
       export function findAllPersistedCallExpressions(

     

       218
       218
       +
         sourceFile: ts.SourceFile,

     

       219
       219
       +
         info?: ts.server.PluginCreateInfo

     

       220
       220
       +
       ) {

     

       221
       221
       +
         const result: Array<

     

       222
       222
       +
           ts.CallExpression | { node: ts.CallExpression; schema: string | null }

     

       223
       223
       +
         > = [];

     

       224
       224
       +
         const typeChecker = info?.languageService.getProgram()?.getTypeChecker();

     

       215
       225
        
         function find(node: ts.Node) {

     

       216
       226
        
           if (node && ts.isCallExpression(node)) {

     

       217
       227
        
             // This expression ideally for us looks like <template>.persisted

     
···

       222
       232
        
             const [template, method] = parts;

     

       223
       233
        
             if (!templates.has(template) || method !== 'persisted') return;

     

       224
       234
        
       

     

       225
       225
       -
             const name = getSchemaName(node, typeChecker);

     

       226
       226
       -
       

     

       227
       227
       -
             result.push({ node, schema: name });

     

       235
       235
       +
             if (info) {

     

       236
       236
       +
               const name = getSchemaName(node, typeChecker);

     

       237
       237
       +
               result.push({ node, schema: name });

     

       238
       238
       +
             } else {

     

       239
       239
       +
               result.push(node);

     

       240
       240
       +
             }

     

       228
       241
        
           } else {

     

       229
       242
        
             ts.forEachChild(node, find);

     

       230
       243
        
           }