···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
---

     

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

     

       
3
       
+
       
---

     

       
4
       
+
       


     

       
5
       
+
       
Add support for defining multiple indepenent schemas through a new config property called `schemas`, you can

     

       
6
       
+
       
pass a config like the following:

     

       
7
       
+
       


     

       
8
       
+
       
```json

     

       
9
       
+
       
{

     

       
10
       
+
       
  "name": "@0no-co/graphqlsp",

     

       
11
       
+
       
  "schemas": [

     

       
12
       
+
       
    {

     

       
13
       
+
       
      "name": "pokemons",

     

       
14
       
+
       
      "schema": "./pokemons.graphql",

     

       
15
       
+
       
      "tadaOutputLocation": "./pokemons-introspection.d.ts"

     

       
16
       
+
       
    },

     

       
17
       
+
       
    {

     

       
18
       
+
       
      "name": "weather",

     

       
19
       
+
       
      "schema": "./weather.graphql",

     

       
20
       
+
       
      "tadaOutputLocation": "./weather-introspection.d.ts"

     

       
21
       
+
       
    }

     

       
22
       
+
       
  ]

     

       
23
       
+
       
}

     

       
24
       
+
       
```

     

       
25
       
+
       


     

       
26
       
+
       
The LSP will depending on what `graphql()` template you use figure out what API you are reaching out to.

     

···

       
10
       
 
       
 * instead save to a .ts instead of a .d.ts file.

     

       
11
       
 
       
 */

     

       
12
       
 
       
export type introspection = {

     

       
0
       
 
       

     

       
13
       
 
       
  query: 'Query';

     

       
14
       
 
       
  mutation: never;

     

       
15
       
 
       
  subscription: never;

     

       
16
       
 
       
  types: {

     

       
17
       
 
       
    'Attack': { kind: 'OBJECT'; name: 'Attack'; fields: { 'damage': { name: 'damage'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'type': { name: 'type'; type: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; } }; }; };

     

       
18
       
-
       
    'Int': unknown;

     

       
19
       
-
       
    'String': unknown;

     

       
20
       
 
       
    'AttacksConnection': { kind: 'OBJECT'; name: 'AttacksConnection'; fields: { 'fast': { name: 'fast'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Attack'; ofType: null; }; } }; 'special': { name: 'special'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Attack'; ofType: null; }; } }; }; };

     

       
0
       
 
       

     

       
21
       
 
       
    'EvolutionRequirement': { kind: 'OBJECT'; name: 'EvolutionRequirement'; fields: { 'amount': { name: 'amount'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; }; };

     

       
22
       
-
       
    'Pokemon': { kind: 'OBJECT'; name: 'Pokemon'; fields: { 'attacks': { name: 'attacks'; type: { kind: 'OBJECT'; name: 'AttacksConnection'; ofType: null; } }; 'classification': { name: 'classification'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'evolutionRequirements': { name: 'evolutionRequirements'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'EvolutionRequirement'; ofType: null; }; } }; 'evolutions': { name: 'evolutions'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; }; } }; 'fleeRate': { name: 'fleeRate'; type: { kind: 'SCALAR'; name: 'Float'; ofType: null; } }; 'height': { name: 'height'; type: { kind: 'OBJECT'; name: 'PokemonDimension'; ofType: null; } }; 'id': { name: 'id'; type: { kind: 'NON_NULL'; name: never; ofType: { kind: 'SCALAR'; name: 'ID'; ofType: null; }; } }; 'maxCP': { name: 'maxCP'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'maxHP': { name: 'maxHP'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'NON_NULL'; name: never; ofType: { kind: 'SCALAR'; name: 'String'; ofType: null; }; } }; 'resistant': { name: 'resistant'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'types': { name: 'types'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'weaknesses': { name: 'weaknesses'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'weight': { name: 'weight'; type: { kind: 'OBJECT'; name: 'PokemonDimension'; ofType: null; } }; }; };

     

       
23
       
 
       
    'Float': unknown;

     

       
24
       
 
       
    'ID': unknown;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
25
       
 
       
    'PokemonDimension': { kind: 'OBJECT'; name: 'PokemonDimension'; fields: { 'maximum': { name: 'maximum'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'minimum': { name: 'minimum'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; }; };

     

       
26
       
-
       
    'PokemonType': { kind: 'ENUM'; name: 'PokemonType'; type: 'Bug' | 'Dark' | 'Dragon' | 'Electric' | 'Fairy' | 'Fighting' | 'Fire' | 'Flying' | 'Ghost' | 'Grass' | 'Ground' | 'Ice' | 'Normal' | 'Poison' | 'Psychic' | 'Rock' | 'Steel' | 'Water'; };

     

       
27
       
 
       
    'Query': { kind: 'OBJECT'; name: 'Query'; fields: { 'pokemon': { name: 'pokemon'; type: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; } }; 'pokemons': { name: 'pokemons'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; }; } }; }; };

     

       
28
       
-
       
    'Boolean': unknown;

     

       
29
       
 
       
  };

     

       
30
       
 
       
};

     

       
31
       
 
       


     

       
32
       
 
       
import * as gqlTada from 'gql.tada';

     

       
33
       
-
       


     

       
34
       
-
       
declare module 'gql.tada' {

     

       
35
       
-
       
  interface setupSchema {

     

       
36
       
-
       
    introspection: introspection;

     

       
37
       
-
       
  }

     

       
38
       
-
       
}

     

···

       
10
       
 
       
 * instead save to a .ts instead of a .d.ts file.

     

       
11
       
 
       
 */

     

       
12
       
 
       
export type introspection = {

     

       
13
       
+
       
  name: 'pokemons';

     

       
14
       
 
       
  query: 'Query';

     

       
15
       
 
       
  mutation: never;

     

       
16
       
 
       
  subscription: never;

     

       
17
       
 
       
  types: {

     

       
18
       
 
       
    'Attack': { kind: 'OBJECT'; name: 'Attack'; fields: { 'damage': { name: 'damage'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'type': { name: 'type'; type: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; } }; }; };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       
    'AttacksConnection': { kind: 'OBJECT'; name: 'AttacksConnection'; fields: { 'fast': { name: 'fast'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Attack'; ofType: null; }; } }; 'special': { name: 'special'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Attack'; ofType: null; }; } }; }; };

     

       
20
       
+
       
    'Boolean': unknown;

     

       
21
       
 
       
    'EvolutionRequirement': { kind: 'OBJECT'; name: 'EvolutionRequirement'; fields: { 'amount': { name: 'amount'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; }; };

     

       
0
       
 
       

     

       
22
       
 
       
    'Float': unknown;

     

       
23
       
 
       
    'ID': unknown;

     

       
24
       
+
       
    'Int': unknown;

     

       
25
       
+
       
    'Pokemon': { kind: 'OBJECT'; name: 'Pokemon'; fields: { 'attacks': { name: 'attacks'; type: { kind: 'OBJECT'; name: 'AttacksConnection'; ofType: null; } }; 'classification': { name: 'classification'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'evolutionRequirements': { name: 'evolutionRequirements'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'EvolutionRequirement'; ofType: null; }; } }; 'evolutions': { name: 'evolutions'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; }; } }; 'fleeRate': { name: 'fleeRate'; type: { kind: 'SCALAR'; name: 'Float'; ofType: null; } }; 'height': { name: 'height'; type: { kind: 'OBJECT'; name: 'PokemonDimension'; ofType: null; } }; 'id': { name: 'id'; type: { kind: 'NON_NULL'; name: never; ofType: { kind: 'SCALAR'; name: 'ID'; ofType: null; }; } }; 'maxCP': { name: 'maxCP'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'maxHP': { name: 'maxHP'; type: { kind: 'SCALAR'; name: 'Int'; ofType: null; } }; 'name': { name: 'name'; type: { kind: 'NON_NULL'; name: never; ofType: { kind: 'SCALAR'; name: 'String'; ofType: null; }; } }; 'resistant': { name: 'resistant'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'types': { name: 'types'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'weaknesses': { name: 'weaknesses'; type: { kind: 'LIST'; name: never; ofType: { kind: 'ENUM'; name: 'PokemonType'; ofType: null; }; } }; 'weight': { name: 'weight'; type: { kind: 'OBJECT'; name: 'PokemonDimension'; ofType: null; } }; }; };

     

       
26
       
 
       
    'PokemonDimension': { kind: 'OBJECT'; name: 'PokemonDimension'; fields: { 'maximum': { name: 'maximum'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; 'minimum': { name: 'minimum'; type: { kind: 'SCALAR'; name: 'String'; ofType: null; } }; }; };

     

       
27
       
+
       
    'PokemonType': { name: 'PokemonType'; enumValues: 'Bug' | 'Dark' | 'Dragon' | 'Electric' | 'Fairy' | 'Fighting' | 'Fire' | 'Flying' | 'Ghost' | 'Grass' | 'Ground' | 'Ice' | 'Normal' | 'Poison' | 'Psychic' | 'Rock' | 'Steel' | 'Water'; };

     

       
28
       
 
       
    'Query': { kind: 'OBJECT'; name: 'Query'; fields: { 'pokemon': { name: 'pokemon'; type: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; } }; 'pokemons': { name: 'pokemons'; type: { kind: 'LIST'; name: never; ofType: { kind: 'OBJECT'; name: 'Pokemon'; ofType: null; }; } }; }; };

     

       
29
       
+
       
    'String': unknown;

     

       
30
       
 
       
  };

     

       
31
       
 
       
};

     

       
32
       
 
       


     

       
33
       
 
       
import * as gqlTada from 'gql.tada';

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
11
       
 
       
  "license": "ISC",

     

       
12
       
 
       
  "dependencies": {

     

       
13
       
 
       
    "@graphql-typed-document-node/core": "^3.2.0",

     

       
14
       
-
       
    "gql.tada": "^1.4.0",

     

       
15
       
 
       
    "@urql/core": "^3.0.0",

     

       
16
       
 
       
    "graphql": "^16.8.1",

     

       
17
       
 
       
    "urql": "^4.0.6"

     

···

       
11
       
 
       
  "license": "ISC",

     

       
12
       
 
       
  "dependencies": {

     

       
13
       
 
       
    "@graphql-typed-document-node/core": "^3.2.0",

     

       
14
       
+
       
    "gql.tada": "1.5.9-canary-8711af177005f46fa3e06d990b6ba28e353e7f9b",

     

       
15
       
 
       
    "@urql/core": "^3.0.0",

     

       
16
       
 
       
    "graphql": "^16.8.1",

     

       
17
       
 
       
    "urql": "^4.0.6"

     

···

       
3
       
 
       
    "plugins": [

     

       
4
       
 
       
      {

     

       
5
       
 
       
        "name": "@0no-co/graphqlsp",

     

       
6
       
-
       
        "schema": "./schema.graphql",

     

       
7
       
-
       
        "tadaOutputLocation": "./introspection.d.ts"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       
      }

     

       
9
       
 
       
    ],

     

       
10
       
 
       
    "jsx": "react-jsx",

     

···

       
3
       
 
       
    "plugins": [

     

       
4
       
 
       
      {

     

       
5
       
 
       
        "name": "@0no-co/graphqlsp",

     

       
6
       
+
       
        "schemas": [

     

       
7
       
+
       
          {

     

       
8
       
+
       
            "name": "pokemons",

     

       
9
       
+
       
            "schema": "./schema.graphql",

     

       
10
       
+
       
            "tadaOutputLocation": "./introspection.d.ts"

     

       
11
       
+
       
          }

     

       
12
       
+
       
        ]

     

       
13
       
 
       
      }

     

       
14
       
 
       
    ],

     

       
15
       
 
       
    "jsx": "react-jsx",

     

···

       
51
       
 
       
    "typescript": "^5.3.3"

     

       
52
       
 
       
  },

     

       
53
       
 
       
  "dependencies": {

     

       
54
       
-
       
    "@gql.tada/internal": "^0.1.2",

     

       
55
       
 
       
    "graphql": "^16.8.1",

     

       
56
       
 
       
    "node-fetch": "^2.0.0"

     

       
57
       
 
       
  },

     

···

       
51
       
 
       
    "typescript": "^5.3.3"

     

       
52
       
 
       
  },

     

       
53
       
 
       
  "dependencies": {

     

       
54
       
+
       
    "@gql.tada/internal": "0.3.0-canary-8711af177005f46fa3e06d990b6ba28e353e7f9b",

     

       
55
       
 
       
    "graphql": "^16.8.1",

     

       
56
       
 
       
    "node-fetch": "^2.0.0"

     

       
57
       
 
       
  },

     

···

       
124
       
 
       
  return wip;

     

       
125
       
 
       
}

     

       
126
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
127
       
 
       
export function findAllCallExpressions(

     

       
128
       
 
       
  sourceFile: ts.SourceFile,

     

       
129
       
 
       
  info: ts.server.PluginCreateInfo,

     

       
130
       
 
       
  shouldSearchFragments: boolean = true

     

       
131
       
 
       
): {

     

       
132
       
-
       
  nodes: Array<ts.NoSubstitutionTemplateLiteral>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
133
       
 
       
  fragments: Array<FragmentDefinitionNode>;

     

       
134
       
 
       
} {

     

       
135
       
-
       
  const result: Array<ts.NoSubstitutionTemplateLiteral> = [];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
136
       
 
       
  let fragments: Array<FragmentDefinitionNode> = [];

     

       
137
       
 
       
  let hasTriedToFindFragments = shouldSearchFragments ? false : true;

     

       
138
       
 
       
  function find(node: ts.Node) {

     

       
139
       
 
       
    if (ts.isCallExpression(node) && templates.has(node.expression.getText())) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
140
       
 
       
      const [arg, arg2] = node.arguments;

     

       
141
       
 
       


     

       
142
       
 
       
      if (!hasTriedToFindFragments && !arg2) {

     
···

       
160
       
 
       
      }

     

       
161
       
 
       


     

       
162
       
 
       
      if (arg && ts.isNoSubstitutionTemplateLiteral(arg)) {

     

       
163
       
-
       
        result.push(arg);

     

       
164
       
 
       
      }

     

       
165
       
 
       
      return;

     

       
166
       
 
       
    } else {

     
···

       
172
       
 
       
}

     

       
173
       
 
       


     

       
174
       
 
       
export function findAllPersistedCallExpressions(

     

       
175
       
-
       
  sourceFile: ts.SourceFile

     

       
176
       
-
       
): Array<ts.CallExpression> {

     

       
177
       
-
       
  const result: Array<ts.CallExpression> = [];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
178
       
 
       
  function find(node: ts.Node) {

     

       
179
       
-
       
    if (ts.isCallExpression(node)) {

     

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

     

       
181
       
 
       
      const expression = node.expression.getText();

     

       
182
       
 
       
      const parts = expression.split('.');

     
···

       
185
       
 
       
      const [template, method] = parts;

     

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

     

       
187
       
 
       


     

       
188
       
-
       
      result.push(node);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
189
       
 
       
    } else {

     

       
190
       
 
       
      ts.forEachChild(node, find);

     

       
191
       
 
       
    }

     

···

       
124
       
 
       
  return wip;

     

       
125
       
 
       
}

     

       
126
       
 
       


     

       
127
       
+
       
export const getSchemaName = (

     

       
128
       
+
       
  node: ts.CallExpression,

     

       
129
       
+
       
  typeChecker?: ts.TypeChecker

     

       
130
       
+
       
): string | null => {

     

       
131
       
+
       
  if (!typeChecker) return null;

     

       
132
       
+
       


     

       
133
       
+
       
  const expression = ts.isPropertyAccessExpression(node.expression)

     

       
134
       
+
       
    ? node.expression.expression

     

       
135
       
+
       
    : node.expression;

     

       
136
       
+
       
  const type = typeChecker.getTypeAtLocation(expression);

     

       
137
       
+
       
  if (type) {

     

       
138
       
+
       
    const brandTypeSymbol = type.getProperty('__name');

     

       
139
       
+
       
    if (brandTypeSymbol) {

     

       
140
       
+
       
      const brand = typeChecker.getTypeOfSymbol(brandTypeSymbol);

     

       
141
       
+
       
      if (brand.isUnionOrIntersection()) {

     

       
142
       
+
       
        const found = brand.types.find(x => x.isStringLiteral());

     

       
143
       
+
       
        return found && found.isStringLiteral() ? found.value : null;

     

       
144
       
+
       
      } else if (brand.isStringLiteral()) {

     

       
145
       
+
       
        return brand.value;

     

       
146
       
+
       
      }

     

       
147
       
+
       
    }

     

       
148
       
+
       
  }

     

       
149
       
+
       


     

       
150
       
+
       
  return null;

     

       
151
       
+
       
};

     

       
152
       
+
       


     

       
153
       
 
       
export function findAllCallExpressions(

     

       
154
       
 
       
  sourceFile: ts.SourceFile,

     

       
155
       
 
       
  info: ts.server.PluginCreateInfo,

     

       
156
       
 
       
  shouldSearchFragments: boolean = true

     

       
157
       
 
       
): {

     

       
158
       
+
       
  nodes: Array<{

     

       
159
       
+
       
    node: ts.NoSubstitutionTemplateLiteral;

     

       
160
       
+
       
    schema: string | null;

     

       
161
       
+
       
  }>;

     

       
162
       
 
       
  fragments: Array<FragmentDefinitionNode>;

     

       
163
       
 
       
} {

     

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

     

       
165
       
+
       
  const result: Array<{

     

       
166
       
+
       
    node: ts.NoSubstitutionTemplateLiteral;

     

       
167
       
+
       
    schema: string | null;

     

       
168
       
+
       
  }> = [];

     

       
169
       
 
       
  let fragments: Array<FragmentDefinitionNode> = [];

     

       
170
       
 
       
  let hasTriedToFindFragments = shouldSearchFragments ? false : true;

     

       
171
       
 
       
  function find(node: ts.Node) {

     

       
172
       
 
       
    if (ts.isCallExpression(node) && templates.has(node.expression.getText())) {

     

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

     

       
174
       
+
       


     

       
175
       
 
       
      const [arg, arg2] = node.arguments;

     

       
176
       
 
       


     

       
177
       
 
       
      if (!hasTriedToFindFragments && !arg2) {

     
···

       
195
       
 
       
      }

     

       
196
       
 
       


     

       
197
       
 
       
      if (arg && ts.isNoSubstitutionTemplateLiteral(arg)) {

     

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

     

       
199
       
 
       
      }

     

       
200
       
 
       
      return;

     

       
201
       
 
       
    } else {

     
···

       
207
       
 
       
}

     

       
208
       
 
       


     

       
209
       
 
       
export function findAllPersistedCallExpressions(

     

       
210
       
+
       
  sourceFile: ts.SourceFile,

     

       
211
       
+
       
  info: ts.server.PluginCreateInfo

     

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

     

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

     

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

     

       
215
       
 
       
  function find(node: ts.Node) {

     

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

     

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

     

       
218
       
 
       
      const expression = node.expression.getText();

     

       
219
       
 
       
      const parts = expression.split('.');

     
···

       
222
       
 
       
      const [template, method] = parts;

     

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

     

       
224
       
 
       


     

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

     

       
226
       
+
       


     

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

     

       
228
       
 
       
    } else {

     

       
229
       
 
       
      ts.forEachChild(node, find);

     

       
230
       
 
       
    }

     

···

       
20
       
 
       
  bubbleUpTemplate,

     

       
21
       
 
       
  findNode,

     

       
22
       
 
       
  getAllFragments,

     

       
0
       
 
       

     

       
23
       
 
       
  getSource,

     

       
24
       
 
       
} from './ast';

     

       
25
       
 
       
import { Cursor } from './ast/cursor';

     
···

       
27
       
 
       
import { getToken } from './ast/token';

     

       
28
       
 
       
import { getSuggestionsForFragmentSpread } from './graphql/getFragmentSpreadSuggestions';

     

       
29
       
 
       
import { templates } from './ast/templates';

     

       
0
       
 
       

     

       
30
       
 
       


     

       
31
       
 
       
export function getGraphQLCompletions(

     

       
32
       
 
       
  filename: string,

     

       
33
       
 
       
  cursorPosition: number,

     

       
34
       
-
       
  schema: { current: GraphQLSchema | null },

     

       
35
       
 
       
  info: ts.server.PluginCreateInfo

     

       
36
       
 
       
): ts.WithMetadata<ts.CompletionInfo> | undefined {

     

       
37
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
46
       
 
       
    ? bubbleUpCallExpression(node)

     

       
47
       
 
       
    : bubbleUpTemplate(node);

     

       
48
       
 
       


     

       
49
       
-
       
  let text, cursor;

     

       
50
       
 
       
  if (

     

       
51
       
 
       
    ts.isCallExpression(node) &&

     

       
52
       
 
       
    isCallExpression &&

     
···

       
54
       
 
       
    node.arguments.length > 0 &&

     

       
55
       
 
       
    ts.isNoSubstitutionTemplateLiteral(node.arguments[0])

     

       
56
       
 
       
  ) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
57
       
 
       
    const foundToken = getToken(node.arguments[0], cursorPosition);

     

       
58
       
-
       
    if (!schema.current || !foundToken) return undefined;

     

       
59
       
 
       


     

       
60
       
 
       
    const queryText = node.arguments[0].getText().slice(1, -1);

     

       
61
       
 
       
    const fragments = getAllFragments(filename, node, info);

     
···

       
88
       
 
       


     

       
89
       
 
       
    text = combinedText;

     

       
90
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     

       
0
       
 
       

     

       
91
       
 
       
  } else {

     

       
92
       
 
       
    return undefined;

     

       
93
       
 
       
  }

     

       
94
       
 
       


     

       
95
       
 
       
  const [suggestions, spreadSuggestions] = getSuggestionsInternal(

     

       
96
       
-
       
    schema.current,

     

       
97
       
 
       
    text,

     

       
98
       
 
       
    cursor

     

       
99
       
 
       
  );

     

···

       
20
       
 
       
  bubbleUpTemplate,

     

       
21
       
 
       
  findNode,

     

       
22
       
 
       
  getAllFragments,

     

       
23
       
+
       
  getSchemaName,

     

       
24
       
 
       
  getSource,

     

       
25
       
 
       
} from './ast';

     

       
26
       
 
       
import { Cursor } from './ast/cursor';

     
···

       
28
       
 
       
import { getToken } from './ast/token';

     

       
29
       
 
       
import { getSuggestionsForFragmentSpread } from './graphql/getFragmentSpreadSuggestions';

     

       
30
       
 
       
import { templates } from './ast/templates';

     

       
31
       
+
       
import { SchemaRef } from './graphql/getSchema';

     

       
32
       
 
       


     

       
33
       
 
       
export function getGraphQLCompletions(

     

       
34
       
 
       
  filename: string,

     

       
35
       
 
       
  cursorPosition: number,

     

       
36
       
+
       
  schema: SchemaRef,

     

       
37
       
 
       
  info: ts.server.PluginCreateInfo

     

       
38
       
 
       
): ts.WithMetadata<ts.CompletionInfo> | undefined {

     

       
39
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
48
       
 
       
    ? bubbleUpCallExpression(node)

     

       
49
       
 
       
    : bubbleUpTemplate(node);

     

       
50
       
 
       


     

       
51
       
+
       
  let text, cursor, schemaToUse: GraphQLSchema | undefined;

     

       
52
       
 
       
  if (

     

       
53
       
 
       
    ts.isCallExpression(node) &&

     

       
54
       
 
       
    isCallExpression &&

     
···

       
56
       
 
       
    node.arguments.length > 0 &&

     

       
57
       
 
       
    ts.isNoSubstitutionTemplateLiteral(node.arguments[0])

     

       
58
       
 
       
  ) {

     

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

     

       
60
       
+
       
    const schemaName = getSchemaName(node, typeChecker);

     

       
61
       
+
       


     

       
62
       
+
       
    schemaToUse =

     

       
63
       
+
       
      schemaName && schema.multi[schemaName]

     

       
64
       
+
       
        ? schema.multi[schemaName]?.schema

     

       
65
       
+
       
        : schema.current?.schema;

     

       
66
       
+
       


     

       
67
       
 
       
    const foundToken = getToken(node.arguments[0], cursorPosition);

     

       
68
       
+
       
    if (!schemaToUse || !foundToken) return undefined;

     

       
69
       
 
       


     

       
70
       
 
       
    const queryText = node.arguments[0].getText().slice(1, -1);

     

       
71
       
 
       
    const fragments = getAllFragments(filename, node, info);

     
···

       
98
       
 
       


     

       
99
       
 
       
    text = combinedText;

     

       
100
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     

       
101
       
+
       
    schemaToUse = schema.current.schema;

     

       
102
       
 
       
  } else {

     

       
103
       
 
       
    return undefined;

     

       
104
       
 
       
  }

     

       
105
       
 
       


     

       
106
       
 
       
  const [suggestions, spreadSuggestions] = getSuggestionsInternal(

     

       
107
       
+
       
    schemaToUse,

     

       
108
       
 
       
    text,

     

       
109
       
 
       
    cursor

     

       
110
       
 
       
  );

     

···

       
174
       
 
       
  const exports = typeChecker.getExportsOfModule(symbol);

     

       
175
       
 
       
  const exportedNames = exports.map(symb => symb.name);

     

       
176
       
 
       
  const nodes = callExpressions.nodes.filter(x => {

     

       
177
       
-
       
    let parent = x.parent;

     

       
178
       
 
       
    while (

     

       
179
       
 
       
      parent &&

     

       
180
       
 
       
      !ts.isSourceFile(parent) &&

     
···

       
191
       
 
       
  });

     

       
192
       
 
       


     

       
193
       
 
       
  nodes.forEach(node => {

     

       
194
       
-
       
    const text = resolveTemplate(node, src.fileName, info).combinedText;

     

       
195
       
 
       
    try {

     

       
196
       
 
       
      const parsed = parse(text, { noLocation: true });

     

       
197
       
 
       
      if (parsed.definitions.every(x => x.kind === Kind.FRAGMENT_DEFINITION)) {

     

···

       
174
       
 
       
  const exports = typeChecker.getExportsOfModule(symbol);

     

       
175
       
 
       
  const exportedNames = exports.map(symb => symb.name);

     

       
176
       
 
       
  const nodes = callExpressions.nodes.filter(x => {

     

       
177
       
+
       
    let parent = x.node.parent;

     

       
178
       
 
       
    while (

     

       
179
       
 
       
      parent &&

     

       
180
       
 
       
      !ts.isSourceFile(parent) &&

     
···

       
191
       
 
       
  });

     

       
192
       
 
       


     

       
193
       
 
       
  nodes.forEach(node => {

     

       
194
       
+
       
    const text = resolveTemplate(node.node, src.fileName, info).combinedText;

     

       
195
       
 
       
    try {

     

       
196
       
 
       
      const parsed = parse(text, { noLocation: true });

     

       
197
       
 
       
      if (parsed.definitions.every(x => x.kind === Kind.FRAGMENT_DEFINITION)) {

     

···

       
29
       
 
       
  getDocumentReferenceFromDocumentNode,

     

       
30
       
 
       
  getDocumentReferenceFromTypeQuery,

     

       
31
       
 
       
} from './persisted';

     

       
0
       
 
       

     

       
32
       
 
       


     

       
33
       
 
       
const clientDirectives = new Set([

     

       
34
       
 
       
  'populate',

     
···

       
76
       
 
       


     

       
77
       
 
       
export function getGraphQLDiagnostics(

     

       
78
       
 
       
  filename: string,

     

       
79
       
-
       
  schema: { current: GraphQLSchema | null; version: number },

     

       
80
       
 
       
  info: ts.server.PluginCreateInfo

     

       
81
       
 
       
): ts.Diagnostic[] | undefined {

     

       
82
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
85
       
 
       
  if (!source) return undefined;

     

       
86
       
 
       


     

       
87
       
 
       
  let fragments: Array<FragmentDefinitionNode> = [],

     

       
88
       
-
       
    nodes: (ts.TaggedTemplateExpression | ts.NoSubstitutionTemplateLiteral)[];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
89
       
 
       
  if (isCallExpression) {

     

       
90
       
 
       
    const result = findAllCallExpressions(source, info);

     

       
91
       
 
       
    fragments = result.fragments;

     

       
92
       
 
       
    nodes = result.nodes;

     

       
93
       
 
       
  } else {

     

       
94
       
-
       
    nodes = findAllTaggedTemplateNodes(source);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
95
       
 
       
  }

     

       
96
       
 
       


     

       
97
       
-
       
  const texts = nodes.map(node => {

     

       
98
       
 
       
    if (

     

       
99
       
 
       
      (ts.isNoSubstitutionTemplateLiteral(node) ||

     

       
100
       
 
       
        ts.isTemplateExpression(node)) &&

     
···

       
131
       
 
       
  let fragmentDiagnostics: ts.Diagnostic[] = [];

     

       
132
       
 
       


     

       
133
       
 
       
  if (isCallExpression) {

     

       
134
       
-
       
    const persistedCalls = findAllPersistedCallExpressions(source);

     

       
135
       
 
       
    // We need to check whether the user has correctly inserted a hash,

     

       
136
       
 
       
    // by means of providing an argument to the function and that they

     

       
137
       
 
       
    // are establishing a reference to the document by means of the generic.

     

       
138
       
-
       
    //

     

       
139
       
-
       
    // OPTIONAL: we could also check whether the hash is out of date with the

     

       
140
       
-
       
    // document but this removes support for self-generating identifiers

     

       
141
       
 
       
    const persistedDiagnostics = persistedCalls

     

       
142
       
-
       
      .map<ts.Diagnostic | null>(callExpression => {

     

       
0
       
 
       

     

       
143
       
 
       
        if (!callExpression.typeArguments && !callExpression.arguments[1]) {

     

       
144
       
 
       
          return {

     

       
145
       
 
       
            category: ts.DiagnosticCategory.Warning,

     
···

       
252
       
 
       


     

       
253
       
 
       
        const hash = callExpression.arguments[0].getText().slice(1, -1);

     

       
254
       
 
       
        if (hash.startsWith('sha256:')) {

     

       
255
       
-
       
          const hash = generateHashForDocument(

     

       
256
       
 
       
            info,

     

       
257
       
 
       
            initializer.arguments[0],

     

       
258
       
 
       
            foundFilename

     

       
259
       
 
       
          );

     

       
260
       
-
       
          if (!hash) return null;

     

       
261
       
-
       
          const upToDateHash = `sha256:${hash}`;

     

       
0
       
 
       

     

       
262
       
 
       
          if (upToDateHash !== hash) {

     

       
263
       
 
       
            return {

     

       
264
       
 
       
              category: ts.DiagnosticCategory.Warning,

     
···

       
283
       
 
       
    const moduleSpecifierToFragments = getColocatedFragmentNames(source, info);

     

       
284
       
 
       


     

       
285
       
 
       
    const usedFragments = new Set();

     

       
286
       
-
       
    nodes.forEach(node => {

     

       
287
       
 
       
      try {

     

       
288
       
 
       
        const parsed = parse(node.getText().slice(1, -1), {

     

       
289
       
 
       
          noLocation: true,

     
···

       
331
       
 
       
    nodes,

     

       
332
       
 
       
    fragments,

     

       
333
       
 
       
  }: {

     

       
334
       
-
       
    nodes: (ts.TaggedTemplateExpression | ts.NoSubstitutionTemplateLiteral)[];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
335
       
 
       
    fragments: FragmentDefinitionNode[];

     

       
336
       
 
       
  },

     

       
337
       
-
       
  schema: { current: GraphQLSchema | null; version: number },

     

       
338
       
 
       
  info: ts.server.PluginCreateInfo

     

       
339
       
 
       
) => {

     

       
340
       
 
       
  const filename = source.fileName;

     
···

       
342
       
 
       


     

       
343
       
 
       
  const diagnostics = nodes

     

       
344
       
 
       
    .map(originalNode => {

     

       
345
       
-
       
      let node = originalNode;

     

       
346
       
 
       
      if (

     

       
347
       
 
       
        !isCallExpression &&

     

       
348
       
 
       
        (ts.isNoSubstitutionTemplateLiteral(node) ||

     
···

       
397
       
 
       
        } catch (e) {}

     

       
398
       
 
       
      }

     

       
399
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
400
       
 
       
      const graphQLDiagnostics = getDiagnostics(

     

       
401
       
 
       
        text,

     

       
402
       
-
       
        schema.current,

     

       
403
       
 
       
        undefined,

     

       
404
       
 
       
        undefined,

     

       
405
       
 
       
        docFragments

     
···

       
482
       
 
       
              message: 'Operation should contain a name.',

     

       
483
       
 
       
              start: node.getStart(),

     

       
484
       
 
       
              code: MISSING_OPERATION_NAME_CODE,

     

       
485
       
-
       
              length: originalNode.getText().length,

     

       
486
       
 
       
              range: {} as any,

     

       
487
       
 
       
              severity: 2,

     

       
488
       
 
       
            } as any);

     
···

       
516
       
 
       
    const usageDiagnostics =

     

       
517
       
 
       
      checkFieldUsageInFile(

     

       
518
       
 
       
        source,

     

       
519
       
-
       
        nodes as ts.NoSubstitutionTemplateLiteral[],

     

       
520
       
 
       
        info

     

       
521
       
 
       
      ) || [];

     

       
522
       
 
       


     

···

       
29
       
 
       
  getDocumentReferenceFromDocumentNode,

     

       
30
       
 
       
  getDocumentReferenceFromTypeQuery,

     

       
31
       
 
       
} from './persisted';

     

       
32
       
+
       
import { SchemaRef } from './graphql/getSchema';

     

       
33
       
 
       


     

       
34
       
 
       
const clientDirectives = new Set([

     

       
35
       
 
       
  'populate',

     
···

       
77
       
 
       


     

       
78
       
 
       
export function getGraphQLDiagnostics(

     

       
79
       
 
       
  filename: string,

     

       
80
       
+
       
  schema: SchemaRef,

     

       
81
       
 
       
  info: ts.server.PluginCreateInfo

     

       
82
       
 
       
): ts.Diagnostic[] | undefined {

     

       
83
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
86
       
 
       
  if (!source) return undefined;

     

       
87
       
 
       


     

       
88
       
 
       
  let fragments: Array<FragmentDefinitionNode> = [],

     

       
89
       
+
       
    nodes: {

     

       
90
       
+
       
      node: ts.NoSubstitutionTemplateLiteral | ts.TaggedTemplateExpression;

     

       
91
       
+
       
      schema: string | null;

     

       
92
       
+
       
    }[];

     

       
93
       
 
       
  if (isCallExpression) {

     

       
94
       
 
       
    const result = findAllCallExpressions(source, info);

     

       
95
       
 
       
    fragments = result.fragments;

     

       
96
       
 
       
    nodes = result.nodes;

     

       
97
       
 
       
  } else {

     

       
98
       
+
       
    nodes = findAllTaggedTemplateNodes(source).map(x => ({

     

       
99
       
+
       
      node: x,

     

       
100
       
+
       
      schema: null,

     

       
101
       
+
       
    }));

     

       
102
       
 
       
  }

     

       
103
       
 
       


     

       
104
       
+
       
  const texts = nodes.map(({ node }) => {

     

       
105
       
 
       
    if (

     

       
106
       
 
       
      (ts.isNoSubstitutionTemplateLiteral(node) ||

     

       
107
       
 
       
        ts.isTemplateExpression(node)) &&

     
···

       
138
       
 
       
  let fragmentDiagnostics: ts.Diagnostic[] = [];

     

       
139
       
 
       


     

       
140
       
 
       
  if (isCallExpression) {

     

       
141
       
+
       
    const persistedCalls = findAllPersistedCallExpressions(source, info);

     

       
142
       
 
       
    // We need to check whether the user has correctly inserted a hash,

     

       
143
       
 
       
    // by means of providing an argument to the function and that they

     

       
144
       
 
       
    // are establishing a reference to the document by means of the generic.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
145
       
 
       
    const persistedDiagnostics = persistedCalls

     

       
146
       
+
       
      .map<ts.Diagnostic | null>(found => {

     

       
147
       
+
       
        const { node: callExpression } = found;

     

       
148
       
 
       
        if (!callExpression.typeArguments && !callExpression.arguments[1]) {

     

       
149
       
 
       
          return {

     

       
150
       
 
       
            category: ts.DiagnosticCategory.Warning,

     
···

       
257
       
 
       


     

       
258
       
 
       
        const hash = callExpression.arguments[0].getText().slice(1, -1);

     

       
259
       
 
       
        if (hash.startsWith('sha256:')) {

     

       
260
       
+
       
          const generatedHash = generateHashForDocument(

     

       
261
       
 
       
            info,

     

       
262
       
 
       
            initializer.arguments[0],

     

       
263
       
 
       
            foundFilename

     

       
264
       
 
       
          );

     

       
265
       
+
       
          if (!generatedHash) return null;

     

       
266
       
+
       


     

       
267
       
+
       
          const upToDateHash = `sha256:${generatedHash}`;

     

       
268
       
 
       
          if (upToDateHash !== hash) {

     

       
269
       
 
       
            return {

     

       
270
       
 
       
              category: ts.DiagnosticCategory.Warning,

     
···

       
289
       
 
       
    const moduleSpecifierToFragments = getColocatedFragmentNames(source, info);

     

       
290
       
 
       


     

       
291
       
 
       
    const usedFragments = new Set();

     

       
292
       
+
       
    nodes.forEach(({ node }) => {

     

       
293
       
 
       
      try {

     

       
294
       
 
       
        const parsed = parse(node.getText().slice(1, -1), {

     

       
295
       
 
       
          noLocation: true,

     
···

       
337
       
 
       
    nodes,

     

       
338
       
 
       
    fragments,

     

       
339
       
 
       
  }: {

     

       
340
       
+
       
    nodes: {

     

       
341
       
+
       
      node: ts.TaggedTemplateExpression | ts.NoSubstitutionTemplateLiteral;

     

       
342
       
+
       
      schema: string | null;

     

       
343
       
+
       
    }[];

     

       
344
       
 
       
    fragments: FragmentDefinitionNode[];

     

       
345
       
 
       
  },

     

       
346
       
+
       
  schema: SchemaRef,

     

       
347
       
 
       
  info: ts.server.PluginCreateInfo

     

       
348
       
 
       
) => {

     

       
349
       
 
       
  const filename = source.fileName;

     
···

       
351
       
 
       


     

       
352
       
 
       
  const diagnostics = nodes

     

       
353
       
 
       
    .map(originalNode => {

     

       
354
       
+
       
      let node = originalNode.node;

     

       
355
       
 
       
      if (

     

       
356
       
 
       
        !isCallExpression &&

     

       
357
       
 
       
        (ts.isNoSubstitutionTemplateLiteral(node) ||

     
···

       
406
       
 
       
        } catch (e) {}

     

       
407
       
 
       
      }

     

       
408
       
 
       


     

       
409
       
+
       
      const schemaToUse =

     

       
410
       
+
       
        originalNode.schema && schema.multi[originalNode.schema]

     

       
411
       
+
       
          ? schema.multi[originalNode.schema]?.schema

     

       
412
       
+
       
          : schema.current?.schema;

     

       
413
       
+
       


     

       
414
       
+
       
      if (!schemaToUse) {

     

       
415
       
+
       
        return undefined;

     

       
416
       
+
       
      }

     

       
417
       
+
       


     

       
418
       
 
       
      const graphQLDiagnostics = getDiagnostics(

     

       
419
       
 
       
        text,

     

       
420
       
+
       
        schemaToUse,

     

       
421
       
 
       
        undefined,

     

       
422
       
 
       
        undefined,

     

       
423
       
 
       
        docFragments

     
···

       
500
       
 
       
              message: 'Operation should contain a name.',

     

       
501
       
 
       
              start: node.getStart(),

     

       
502
       
 
       
              code: MISSING_OPERATION_NAME_CODE,

     

       
503
       
+
       
              length: originalNode.node.getText().length,

     

       
504
       
 
       
              range: {} as any,

     

       
505
       
 
       
              severity: 2,

     

       
506
       
 
       
            } as any);

     
···

       
534
       
 
       
    const usageDiagnostics =

     

       
535
       
 
       
      checkFieldUsageInFile(

     

       
536
       
 
       
        source,

     

       
537
       
+
       
        nodes.map(x => x.node) as ts.NoSubstitutionTemplateLiteral[],

     

       
538
       
 
       
        info

     

       
539
       
 
       
      ) || [];

     

       
540
       
 
       


     

···

       
2
       
 
       
import fs from 'node:fs/promises';

     

       
3
       
 
       
import path from 'path';

     

       
4
       
 
       


     

       
5
       
-
       
import type { GraphQLSchema, IntrospectionQuery } from 'graphql';

     

       
6
       
 
       


     

       
7
       
 
       
import {

     

       
8
       
-
       
  type SchemaOrigin,

     

       
9
       
 
       
  type SchemaLoaderResult,

     

       
10
       
-
       
  load,

     

       
11
       
-
       
  resolveTypeScriptRootDir,

     

       
0
       
 
       

     

       
12
       
 
       
  minifyIntrospection,

     

       
13
       
 
       
  outputIntrospectionFile,

     

       
0
       
 
       

     

       
14
       
 
       
} from '@gql.tada/internal';

     

       
15
       
 
       


     

       
16
       
 
       
import { ts } from '../ts';

     
···

       
93
       
 
       
  }

     

       
94
       
 
       
}

     

       
95
       
 
       


     

       
96
       
-
       
export interface SchemaRef {

     

       
97
       
-
       
  current: GraphQLSchema | null;

     

       
98
       
-
       
  version: number;

     

       
99
       
-
       
}

     

       
100
       
 
       


     

       
101
       
 
       
export const loadSchema = (

     

       
102
       
 
       
  // TODO: abstract info away

     

       
103
       
 
       
  info: ts.server.PluginCreateInfo,

     

       
104
       
-
       
  origin: SchemaOrigin,

     

       
105
       
 
       
  logger: Logger

     

       
106
       
-
       
): SchemaRef => {

     

       
107
       
-
       
  let loaderResult: SchemaLoaderResult | null = null;

     

       
108
       
-
       
  const ref: SchemaRef = { current: null, version: 0 };

     

       
109
       
 
       


     

       
110
       
 
       
  (async () => {

     

       
111
       
 
       
    const rootPath =

     

       
112
       
 
       
      (await resolveTypeScriptRootDir(info.project.getProjectName())) ||

     

       
113
       
 
       
      path.dirname(info.project.getProjectName());

     

       
0
       
 
       

     

       
114
       
 
       
    const tadaDisablePreprocessing =

     

       
115
       
 
       
      info.config.tadaDisablePreprocessing ?? false;

     

       
116
       
 
       
    const tadaOutputLocation =

     
···

       
120
       
 
       
    logger('Got root-directory to resolve schema from: ' + rootPath);

     

       
121
       
 
       
    logger('Resolving schema from "schema" config: ' + JSON.stringify(origin));

     

       
122
       
 
       


     

       
123
       
-
       
    const loader = load({ origin, rootPath });

     

       
124
       
-
       


     

       
125
       
 
       
    try {

     

       
126
       
-
       
      logger(`Loading schema from "${origin}"`);

     

       
127
       
-
       
      loaderResult = await loader.load();

     

       
128
       
 
       
    } catch (error) {

     

       
129
       
 
       
      logger(`Failed to load schema: ${error}`);

     

       
130
       
 
       
    }

     

       
131
       
 
       


     

       
132
       
-
       
    if (loaderResult) {

     

       
133
       
-
       
      ref.current = loaderResult && loaderResult.schema;

     

       
134
       
-
       
      ref.version++;

     

       
135
       
-
       
      if (tadaOutputLocation) {

     

       
136
       
-
       
        saveTadaIntrospection(

     

       
137
       
-
       
          loaderResult.introspection,

     

       
138
       
-
       
          tadaOutputLocation,

     

       
139
       
-
       
          tadaDisablePreprocessing,

     

       
140
       
-
       
          logger

     

       
141
       
-
       
        );

     

       
142
       
-
       
      }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
143
       
 
       
    }

     

       
144
       
 
       


     

       
145
       
-
       
    loader.notifyOnUpdate(result => {

     

       
146
       
-
       
      logger(`Got schema for origin "${origin}"`);

     

       
147
       
-
       
      ref.current = (loaderResult = result).schema;

     

       
148
       
-
       
      ref.version++;

     

       
149
       
-
       
      if (tadaOutputLocation) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
150
       
 
       
        saveTadaIntrospection(

     

       
151
       
-
       
          loaderResult.introspection,

     

       
152
       
-
       
          tadaOutputLocation,

     

       
153
       
 
       
          tadaDisablePreprocessing,

     

       
154
       
 
       
          logger

     

       
155
       
 
       
        );

     
···

       
157
       
 
       
    });

     

       
158
       
 
       
  })();

     

       
159
       
 
       


     

       
160
       
-
       
  return ref;

     

       
161
       
 
       
};

     

···

       
2
       
 
       
import fs from 'node:fs/promises';

     

       
3
       
 
       
import path from 'path';

     

       
4
       
 
       


     

       
5
       
+
       
import type { IntrospectionQuery } from 'graphql';

     

       
6
       
 
       


     

       
7
       
 
       
import {

     

       
0
       
 
       

     

       
8
       
 
       
  type SchemaLoaderResult,

     

       
9
       
+
       
  type SchemaRef as _SchemaRef,

     

       
10
       
+
       
  type GraphQLSPConfig,

     

       
11
       
+
       
  loadRef,

     

       
12
       
 
       
  minifyIntrospection,

     

       
13
       
 
       
  outputIntrospectionFile,

     

       
14
       
+
       
  resolveTypeScriptRootDir,

     

       
15
       
 
       
} from '@gql.tada/internal';

     

       
16
       
 
       


     

       
17
       
 
       
import { ts } from '../ts';

     
···

       
94
       
 
       
  }

     

       
95
       
 
       
}

     

       
96
       
 
       


     

       
97
       
+
       
export type SchemaRef = _SchemaRef<SchemaLoaderResult | null>;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
98
       
 
       


     

       
99
       
 
       
export const loadSchema = (

     

       
100
       
 
       
  // TODO: abstract info away

     

       
101
       
 
       
  info: ts.server.PluginCreateInfo,

     

       
102
       
+
       
  origin: GraphQLSPConfig,

     

       
103
       
 
       
  logger: Logger

     

       
104
       
+
       
): _SchemaRef<SchemaLoaderResult | null> => {

     

       
105
       
+
       
  const ref = loadRef(origin);

     

       
0
       
 
       

     

       
106
       
 
       


     

       
107
       
 
       
  (async () => {

     

       
108
       
 
       
    const rootPath =

     

       
109
       
 
       
      (await resolveTypeScriptRootDir(info.project.getProjectName())) ||

     

       
110
       
 
       
      path.dirname(info.project.getProjectName());

     

       
111
       
+
       


     

       
112
       
 
       
    const tadaDisablePreprocessing =

     

       
113
       
 
       
      info.config.tadaDisablePreprocessing ?? false;

     

       
114
       
 
       
    const tadaOutputLocation =

     
···

       
118
       
 
       
    logger('Got root-directory to resolve schema from: ' + rootPath);

     

       
119
       
 
       
    logger('Resolving schema from "schema" config: ' + JSON.stringify(origin));

     

       
120
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
121
       
 
       
    try {

     

       
122
       
+
       
      logger(`Loading schema...`);

     

       
123
       
+
       
      await ref.load({ rootPath });

     

       
124
       
 
       
    } catch (error) {

     

       
125
       
 
       
      logger(`Failed to load schema: ${error}`);

     

       
126
       
 
       
    }

     

       
127
       
 
       


     

       
128
       
+
       
    if (ref.current) {

     

       
129
       
+
       
      saveTadaIntrospection(

     

       
130
       
+
       
        ref.current.introspection,

     

       
131
       
+
       
        tadaOutputLocation,

     

       
132
       
+
       
        tadaDisablePreprocessing,

     

       
133
       
+
       
        logger

     

       
134
       
+
       
      );

     

       
135
       
+
       
    } else if (ref.multi) {

     

       
136
       
+
       
      Object.values(ref.multi).forEach(value => {

     

       
137
       
+
       
        if (!value) return;

     

       
138
       
+
       


     

       
139
       
+
       
        if (value.tadaOutputLocation) {

     

       
140
       
+
       
          saveTadaIntrospection(

     

       
141
       
+
       
            value.introspection,

     

       
142
       
+
       
            path.resolve(rootPath, value.tadaOutputLocation),

     

       
143
       
+
       
            tadaDisablePreprocessing,

     

       
144
       
+
       
            logger

     

       
145
       
+
       
          );

     

       
146
       
+
       
        }

     

       
147
       
+
       
      });

     

       
148
       
 
       
    }

     

       
149
       
 
       


     

       
150
       
+
       
    ref.autoupdate({ rootPath }, (schemaRef, value) => {

     

       
151
       
+
       
      if (!value) return;

     

       
152
       
+
       


     

       
153
       
+
       
      if (value.tadaOutputLocation) {

     

       
154
       
+
       
        const found = schemaRef.multi

     

       
155
       
+
       
          ? schemaRef.multi[value.name as string]

     

       
156
       
+
       
          : schemaRef.current;

     

       
157
       
+
       
        if (!found) return;

     

       
158
       
 
       
        saveTadaIntrospection(

     

       
159
       
+
       
          found.introspection,

     

       
160
       
+
       
          path.resolve(rootPath, value.tadaOutputLocation),

     

       
161
       
 
       
          tadaDisablePreprocessing,

     

       
162
       
 
       
          logger

     

       
163
       
 
       
        );

     
···

       
165
       
 
       
    });

     

       
166
       
 
       
  })();

     

       
167
       
 
       


     

       
168
       
+
       
  return ref as any;

     

       
169
       
 
       
};

     

···

       
25
       
 
       


     

       
26
       
 
       
interface Config {

     

       
27
       
 
       
  schema: SchemaOrigin;

     

       
0
       
 
       

     

       
28
       
 
       
  tadaDisablePreprocessing?: boolean;

     

       
29
       
 
       
  templateIsCallExpression?: boolean;

     

       
30
       
 
       
  shouldCheckForColocatedFragments?: boolean;

     
···

       
39
       
 
       
  const config: Config = info.config;

     

       
40
       
 
       


     

       
41
       
 
       
  logger('config: ' + JSON.stringify(config));

     

       
42
       
-
       
  if (!config.schema) {

     

       
43
       
 
       
    logger('Missing "schema" option in configuration.');

     

       
44
       
 
       
    throw new Error('Please provide a GraphQL Schema!');

     

       
45
       
 
       
  }

     
···

       
52
       
 
       


     

       
53
       
 
       
  const proxy = createBasicDecorator(info);

     

       
54
       
 
       


     

       
55
       
-
       
  const schema = loadSchema(info, config.schema, logger);

     

       
56
       
 
       


     

       
57
       
 
       
  proxy.getSemanticDiagnostics = (filename: string): ts.Diagnostic[] => {

     

       
58
       
 
       
    const originalDiagnostics =

     

···

       
25
       
 
       


     

       
26
       
 
       
interface Config {

     

       
27
       
 
       
  schema: SchemaOrigin;

     

       
28
       
+
       
  schemas: SchemaOrigin[];

     

       
29
       
 
       
  tadaDisablePreprocessing?: boolean;

     

       
30
       
 
       
  templateIsCallExpression?: boolean;

     

       
31
       
 
       
  shouldCheckForColocatedFragments?: boolean;

     
···

       
40
       
 
       
  const config: Config = info.config;

     

       
41
       
 
       


     

       
42
       
 
       
  logger('config: ' + JSON.stringify(config));

     

       
43
       
+
       
  if (!config.schema && !config.schemas) {

     

       
44
       
 
       
    logger('Missing "schema" option in configuration.');

     

       
45
       
 
       
    throw new Error('Please provide a GraphQL Schema!');

     

       
46
       
 
       
  }

     
···

       
53
       
 
       


     

       
54
       
 
       
  const proxy = createBasicDecorator(info);

     

       
55
       
 
       


     

       
56
       
+
       
  const schema = loadSchema(info, config, logger);

     

       
57
       
 
       


     

       
58
       
 
       
  proxy.getSemanticDiagnostics = (filename: string): ts.Diagnostic[] => {

     

       
59
       
 
       
    const originalDiagnostics =

     

···

       
78
       
 
       
  // is more defined we will need to use the ts.Symbol to support re-exporting

     

       
79
       
 
       
  // this function by means of "export const peristed = graphql.persisted".

     

       
80
       
 
       
  if (

     

       
81
       
-
       
    !ts.isCallExpression(callExpression) ||

     

       
82
       
 
       
    !isPersistedCall(callExpression.expression) ||

     

       
83
       
 
       
    (!callExpression.typeArguments && !callExpression.arguments[1])

     

       
84
       
 
       
  )

     

···

       
78
       
 
       
  // is more defined we will need to use the ts.Symbol to support re-exporting

     

       
79
       
 
       
  // this function by means of "export const peristed = graphql.persisted".

     

       
80
       
 
       
  if (

     

       
81
       
+
       
    (callExpression && !ts.isCallExpression(callExpression)) ||

     

       
82
       
 
       
    !isPersistedCall(callExpression.expression) ||

     

       
83
       
 
       
    (!callExpression.typeArguments && !callExpression.arguments[1])

     

       
84
       
 
       
  )

     

···

       
6
       
 
       
  bubbleUpCallExpression,

     

       
7
       
 
       
  bubbleUpTemplate,

     

       
8
       
 
       
  findNode,

     

       
0
       
 
       

     

       
9
       
 
       
  getSource,

     

       
10
       
 
       
} from './ast';

     

       
11
       
 
       
import { resolveTemplate } from './ast/resolve';

     

       
12
       
 
       
import { getToken } from './ast/token';

     

       
13
       
 
       
import { Cursor } from './ast/cursor';

     

       
14
       
 
       
import { templates } from './ast/templates';

     

       
0
       
 
       

     

       
15
       
 
       


     

       
16
       
 
       
export function getGraphQLQuickInfo(

     

       
17
       
 
       
  filename: string,

     

       
18
       
 
       
  cursorPosition: number,

     

       
19
       
-
       
  schema: { current: GraphQLSchema | null },

     

       
20
       
 
       
  info: ts.server.PluginCreateInfo

     

       
21
       
 
       
): ts.QuickInfo | undefined {

     

       
22
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
31
       
 
       
    ? bubbleUpCallExpression(node)

     

       
32
       
 
       
    : bubbleUpTemplate(node);

     

       
33
       
 
       


     

       
34
       
-
       
  let cursor, text;

     

       
35
       
 
       
  if (

     

       
36
       
 
       
    ts.isCallExpression(node) &&

     

       
37
       
 
       
    isCallExpression &&

     
···

       
39
       
 
       
    node.arguments.length > 0 &&

     

       
40
       
 
       
    ts.isNoSubstitutionTemplateLiteral(node.arguments[0])

     

       
41
       
 
       
  ) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
42
       
 
       
    const foundToken = getToken(node.arguments[0], cursorPosition);

     

       
43
       
-
       
    if (!schema.current || !foundToken) return undefined;

     

       
44
       
 
       


     

       
45
       
 
       
    text = node.arguments[0].getText();

     

       
46
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     
···

       
69
       
 
       
    foundToken.line = foundToken.line + amountOfLines;

     

       
70
       
 
       
    text = combinedText;

     

       
71
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     

       
0
       
 
       

     

       
72
       
 
       
  } else {

     

       
73
       
 
       
    return undefined;

     

       
74
       
 
       
  }

     

       
75
       
 
       


     

       
76
       
-
       
  const hoverInfo = getHoverInformation(schema.current, text, cursor);

     

       
77
       
 
       


     

       
78
       
 
       
  return {

     

       
79
       
 
       
    kind: ts.ScriptElementKind.label,

     

···

       
6
       
 
       
  bubbleUpCallExpression,

     

       
7
       
 
       
  bubbleUpTemplate,

     

       
8
       
 
       
  findNode,

     

       
9
       
+
       
  getSchemaName,

     

       
10
       
 
       
  getSource,

     

       
11
       
 
       
} from './ast';

     

       
12
       
 
       
import { resolveTemplate } from './ast/resolve';

     

       
13
       
 
       
import { getToken } from './ast/token';

     

       
14
       
 
       
import { Cursor } from './ast/cursor';

     

       
15
       
 
       
import { templates } from './ast/templates';

     

       
16
       
+
       
import { SchemaRef } from './graphql/getSchema';

     

       
17
       
 
       


     

       
18
       
 
       
export function getGraphQLQuickInfo(

     

       
19
       
 
       
  filename: string,

     

       
20
       
 
       
  cursorPosition: number,

     

       
21
       
+
       
  schema: SchemaRef,

     

       
22
       
 
       
  info: ts.server.PluginCreateInfo

     

       
23
       
 
       
): ts.QuickInfo | undefined {

     

       
24
       
 
       
  const isCallExpression = info.config.templateIsCallExpression ?? true;

     
···

       
33
       
 
       
    ? bubbleUpCallExpression(node)

     

       
34
       
 
       
    : bubbleUpTemplate(node);

     

       
35
       
 
       


     

       
36
       
+
       
  let cursor, text, schemaToUse: GraphQLSchema | undefined;

     

       
37
       
 
       
  if (

     

       
38
       
 
       
    ts.isCallExpression(node) &&

     

       
39
       
 
       
    isCallExpression &&

     
···

       
41
       
 
       
    node.arguments.length > 0 &&

     

       
42
       
 
       
    ts.isNoSubstitutionTemplateLiteral(node.arguments[0])

     

       
43
       
 
       
  ) {

     

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

     

       
45
       
+
       
    const schemaName = getSchemaName(node, typeChecker);

     

       
46
       
+
       


     

       
47
       
+
       
    schemaToUse =

     

       
48
       
+
       
      schemaName && schema.multi[schemaName]

     

       
49
       
+
       
        ? schema.multi[schemaName]?.schema

     

       
50
       
+
       
        : schema.current?.schema;

     

       
51
       
+
       


     

       
52
       
 
       
    const foundToken = getToken(node.arguments[0], cursorPosition);

     

       
53
       
+
       
    if (!schemaToUse || !foundToken) return undefined;

     

       
54
       
 
       


     

       
55
       
 
       
    text = node.arguments[0].getText();

     

       
56
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     
···

       
79
       
 
       
    foundToken.line = foundToken.line + amountOfLines;

     

       
80
       
 
       
    text = combinedText;

     

       
81
       
 
       
    cursor = new Cursor(foundToken.line, foundToken.start - 1);

     

       
82
       
+
       
    schemaToUse = schema.current.schema;

     

       
83
       
 
       
  } else {

     

       
84
       
 
       
    return undefined;

     

       
85
       
 
       
  }

     

       
86
       
 
       


     

       
87
       
+
       
  const hoverInfo = getHoverInformation(schemaToUse, text, cursor);

     

       
88
       
 
       


     

       
89
       
 
       
  return {

     

       
90
       
 
       
    kind: ts.ScriptElementKind.label,

     

···

       
144
       
 
       
        specifier: ^3.0.0

     

       
145
       
 
       
        version: 3.2.2(graphql@16.8.1)

     

       
146
       
 
       
      gql.tada:

     

       
147
       
-
       
        specifier: ^1.4.0

     

       
148
       
-
       
        version: 1.4.0(graphql@16.8.1)

     

       
149
       
 
       
      graphql:

     

       
150
       
 
       
        specifier: ^16.8.1

     

       
151
       
 
       
        version: 16.8.1

     
···

       
175
       
 
       
  packages/graphqlsp:

     

       
176
       
 
       
    dependencies:

     

       
177
       
 
       
      '@gql.tada/internal':

     

       
178
       
-
       
        specifier: ^0.1.2

     

       
179
       
-
       
        version: 0.1.2(graphql@16.8.1)(typescript@5.3.3)

     

       
180
       
 
       
      graphql:

     

       
181
       
 
       
        specifier: ^16.8.1

     

       
182
       
 
       
        version: 16.8.1

     
···

       
213
       
 
       
        version: link:../../../packages/graphqlsp

     

       
214
       
 
       
      '@urql/core':

     

       
215
       
 
       
        specifier: ^4.0.4

     

       
216
       
-
       
        version: 4.2.2(graphql@16.8.1)

     

       
217
       
 
       
    devDependencies:

     

       
218
       
 
       
      typescript:

     

       
219
       
 
       
        specifier: ^5.3.3

     
···

       
307
       
 
       
    dependencies:

     

       
308
       
 
       
      graphql: 16.8.1

     

       
309
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
310
       
 
       
  /@actions/core@1.10.1:

     

       
311
       
 
       
    resolution: {integrity: sha512-3lBR9EDAY+iYIpTnTIXmWcNbX3T2kCkAEQGIQx4NVQ0575nk2k3GRZDTPQG+vVtS2izSLmINlxXf0uLtnrTP+g==}

     

       
312
       
 
       
    dependencies:

     
···

       
338
       
 
       
    dependencies:

     

       
339
       
 
       
      '@jridgewell/gen-mapping': 0.3.3

     

       
340
       
 
       
      '@jridgewell/trace-mapping': 0.3.21

     

       
341
       
-
       
    dev: true

     

       
342
       
 
       


     

       
343
       
 
       
  /@ardatan/relay-compiler@12.0.0(graphql@16.8.1):

     

       
344
       
 
       
    resolution: {integrity: sha512-9anThAaj1dQr6IGmzBMcfzOQKTa5artjuPmw8NYK/fiGEMjADbSguBY2FMDykt+QhilR3wc9VA/3yVju7JHg7Q==}

     
···

       
556
       
 
       
  /@babel/helper-string-parser@7.23.4:

     

       
557
       
 
       
    resolution: {integrity: sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ==}

     

       
558
       
 
       
    engines: {node: '>=6.9.0'}

     

       
559
       
-
       
    dev: true

     

       
560
       
 
       


     

       
561
       
 
       
  /@babel/helper-validator-identifier@7.22.20:

     

       
562
       
 
       
    resolution: {integrity: sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==}

     

       
563
       
 
       
    engines: {node: '>=6.9.0'}

     

       
564
       
-
       
    dev: true

     

       
565
       
 
       


     

       
566
       
 
       
  /@babel/helper-validator-option@7.23.5:

     

       
567
       
 
       
    resolution: {integrity: sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==}

     
···

       
596
       
 
       
      '@babel/types': 7.23.6

     

       
597
       
 
       
    dev: true

     

       
598
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
599
       
 
       
  /@babel/plugin-proposal-class-properties@7.18.6(@babel/core@7.23.7):

     

       
600
       
 
       
    resolution: {integrity: sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==}

     

       
601
       
 
       
    engines: {node: '>=6.9.0'}

     
···

       
954
       
 
       
      '@babel/helper-string-parser': 7.23.4

     

       
955
       
 
       
      '@babel/helper-validator-identifier': 7.22.20

     

       
956
       
 
       
      to-fast-properties: 2.0.0

     

       
957
       
-
       
    dev: true

     

       
958
       
 
       


     

       
959
       
 
       
  /@changesets/apply-release-plan@6.1.4:

     

       
960
       
 
       
    resolution: {integrity: sha512-FMpKF1fRlJyCZVYHr3CbinpZZ+6MwvOtWUuO8uo+svcATEoc1zRDcj23pAurJ2TZ/uVz1wFHH6K3NlACy0PLew==}

     
···

       
1359
       
 
       
    engines: {node: '>=14'}

     

       
1360
       
 
       
    dev: true

     

       
1361
       
 
       


     

       
1362
       
-
       
  /@gql.tada/cli-utils@0.3.0:

     

       
1363
       
-
       
    resolution: {integrity: sha512-kDebLVuM5r3/bI1MmlhHr9VKHxXeq8Gxy1wHVTPva4R5ObfbhzxnHsTCvR6MUp8ziy9Pg9MESb8S1YZW8ohM3A==}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1364
       
 
       
    dependencies:

     

       
1365
       
-
       
      '@gql.tada/internal': 0.1.0

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1366
       
 
       
      graphql: 16.8.1

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1367
       
 
       
    dev: false

     

       
1368
       
 
       


     

       
1369
       
-
       
  /@gql.tada/internal@0.1.0:

     

       
1370
       
-
       
    resolution: {integrity: sha512-FTvBVXVvt0xUo8hvRlwFoyeNXpUDqc+e20MzFkF8ozbsa5PoYb/gksmmnHMjUphsIq1H3Hq8o4RGstFN5LKH4w==}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1371
       
 
       
    dependencies:

     

       
0
       
 
       

     

       
1372
       
 
       
      graphql: 16.8.1

     

       
1373
       
 
       
      typescript: 5.3.3

     

       
1374
       
 
       
    dev: false

     

       
1375
       
 
       


     

       
1376
       
-
       
  /@gql.tada/internal@0.1.2(graphql@16.8.1)(typescript@5.3.3):

     

       
1377
       
-
       
    resolution: {integrity: sha512-8I4Z1zxYYGK66FWdB3yIZBn3cITLPnciEgjChp3K2+Ha1e/AEBGtZv9AUlodraO/RZafDMkpFhoi+tMpluBjeg==}

     

       
1378
       
 
       
    peerDependencies:

     

       
1379
       
 
       
      graphql: ^16.8.1

     

       
1380
       
-
       
      typescript: ^5.3.3

     

       
1381
       
 
       
    dependencies:

     

       
1382
       
 
       
      '@0no-co/graphql.web': 1.0.6(graphql@16.8.1)

     

       
1383
       
 
       
      graphql: 16.8.1

     
···

       
1996
       
 
       
      '@jridgewell/set-array': 1.1.2

     

       
1997
       
 
       
      '@jridgewell/sourcemap-codec': 1.4.15

     

       
1998
       
 
       
      '@jridgewell/trace-mapping': 0.3.21

     

       
1999
       
-
       
    dev: true

     

       
2000
       
 
       


     

       
2001
       
 
       
  /@jridgewell/resolve-uri@3.1.1:

     

       
2002
       
 
       
    resolution: {integrity: sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==}

     

       
2003
       
 
       
    engines: {node: '>=6.0.0'}

     

       
2004
       
-
       
    dev: true

     

       
2005
       
 
       


     

       
2006
       
 
       
  /@jridgewell/set-array@1.1.2:

     

       
2007
       
 
       
    resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==}

     

       
2008
       
 
       
    engines: {node: '>=6.0.0'}

     

       
2009
       
-
       
    dev: true

     

       
2010
       
 
       


     

       
2011
       
 
       
  /@jridgewell/source-map@0.3.3:

     

       
2012
       
 
       
    resolution: {integrity: sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==}

     
···

       
2017
       
 
       


     

       
2018
       
 
       
  /@jridgewell/sourcemap-codec@1.4.15:

     

       
2019
       
 
       
    resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==}

     

       
2020
       
-
       
    dev: true

     

       
2021
       
 
       


     

       
2022
       
 
       
  /@jridgewell/trace-mapping@0.3.21:

     

       
2023
       
 
       
    resolution: {integrity: sha512-SRfKmRe1KvYnxjEMtxEr+J4HIeMX5YBg/qhRHpxEIGjhX1rshcHlnFUE9K0GazhVKWM7B+nARSkV8LuvJdJ5/g==}

     

       
2024
       
 
       
    dependencies:

     

       
2025
       
 
       
      '@jridgewell/resolve-uri': 3.1.1

     

       
2026
       
 
       
      '@jridgewell/sourcemap-codec': 1.4.15

     

       
2027
       
-
       
    dev: true

     

       
2028
       
 
       


     

       
2029
       
 
       
  /@jridgewell/trace-mapping@0.3.9:

     

       
2030
       
 
       
    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}

     
···

       
2268
       
 
       
    peerDependencies:

     

       
2269
       
 
       
      rollup: ^2.14.0||^3.0.0||^4.0.0

     

       
2270
       
 
       
      tslib: '*'

     

       
2271
       
-
       
      typescript: ^5.3.3

     

       
2272
       
 
       
    peerDependenciesMeta:

     

       
2273
       
 
       
      rollup:

     

       
2274
       
 
       
        optional: true

     
···

       
2437
       
 
       


     

       
2438
       
 
       
  /@types/estree@1.0.5:

     

       
2439
       
 
       
    resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==}

     

       
2440
       
-
       
    dev: true

     

       
2441
       
 
       


     

       
2442
       
 
       
  /@types/is-ci@3.0.0:

     

       
2443
       
 
       
    resolution: {integrity: sha512-Q0Op0hdWbYd1iahB+IFNQcWXFq4O0Q5MwQP7uN0souuQ4rPg1vEYcnIOfr1gY+M+6rc8FGoRaBO1mOOvL29sEQ==}

     
···

       
2515
       
 
       
      wonka: 6.3.4

     

       
2516
       
 
       
    dev: false

     

       
2517
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2518
       
 
       
  /@urql/core@4.2.2(graphql@16.8.1):

     

       
2519
       
 
       
    resolution: {integrity: sha512-TP1kheq9bnrEdnVbJqh0g0ZY/wfdpPeAzjiiDK+Tm+Pbi0O1Xdu6+fUJ/wJo5QpHZzkIyya4/AecG63e6scFqQ==}

     

       
2520
       
 
       
    dependencies:

     

       
2521
       
-
       
      '@0no-co/graphql.web': 1.0.4(graphql@16.8.1)

     

       
2522
       
 
       
      wonka: 6.3.4

     

       
2523
       
 
       
    transitivePeerDependencies:

     

       
2524
       
 
       
      - graphql

     
···

       
2562
       
 
       
      pretty-format: 29.7.0

     

       
2563
       
 
       
    dev: true

     

       
2564
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2565
       
 
       
  /@whatwg-node/events@0.0.3:

     

       
2566
       
 
       
    resolution: {integrity: sha512-IqnKIDWfXBJkvy/k6tzskWTc2NK3LcqHlb+KHGCrjOCH4jfQckRX0NAiIcC/vIqQkzLYw2r2CTSwAxcrtcD6lA==}

     

       
2567
       
 
       
    dev: true

     
···

       
2619
       
 
       
    resolution: {integrity: sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==}

     

       
2620
       
 
       
    engines: {node: '>=0.4.0'}

     

       
2621
       
 
       
    hasBin: true

     

       
2622
       
-
       
    dev: true

     

       
2623
       
 
       


     

       
2624
       
 
       
  /agent-base@7.1.0:

     

       
2625
       
 
       
    resolution: {integrity: sha512-o/zjMZRhJxny7OyEF+Op8X+efiELC7k7yOjMzgfzVqOzXqkBkWI79YoTdOtsuWd5BWhAGAuOY/Xa6xpiaWXiNg==}

     
···

       
2705
       
 
       
    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}

     

       
2706
       
 
       
    dev: true

     

       
2707
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2708
       
 
       
  /array-buffer-byte-length@1.0.0:

     

       
2709
       
 
       
    resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==}

     

       
2710
       
 
       
    dependencies:

     
···

       
2768
       
 
       
    engines: {node: '>= 0.4'}

     

       
2769
       
 
       
    dev: true

     

       
2770
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2771
       
 
       
  /babel-plugin-syntax-trailing-function-commas@7.0.0-beta.0:

     

       
2772
       
 
       
    resolution: {integrity: sha512-Xj9XuRuz3nTSbaTXWv3itLOcxyF4oPD8douBBmj7U9BBC6nEBYfyOJYQMf/8PJAFotC62UY5dFfIGEPr7WswzQ==}

     

       
2773
       
 
       
    dev: true

     
···

       
2809
       
 
       


     

       
2810
       
 
       
  /balanced-match@1.0.2:

     

       
2811
       
 
       
    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}

     

       
2812
       
-
       
    dev: true

     

       
2813
       
 
       


     

       
2814
       
 
       
  /base64-js@1.5.1:

     

       
2815
       
 
       
    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}

     
···

       
2845
       
 
       
    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}

     

       
2846
       
 
       
    dependencies:

     

       
2847
       
 
       
      balanced-match: 1.0.2

     

       
2848
       
-
       
    dev: true

     

       
2849
       
 
       


     

       
2850
       
 
       
  /braces@3.0.2:

     

       
2851
       
 
       
    resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}

     
···

       
3104
       
 
       
    engines: {node: '>=0.8'}

     

       
3105
       
 
       
    dev: true

     

       
3106
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3107
       
 
       
  /color-convert@1.9.3:

     

       
3108
       
 
       
    resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}

     

       
3109
       
 
       
    dependencies:

     
···

       
3154
       
 
       
    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}

     

       
3155
       
 
       
    dev: true

     

       
3156
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3157
       
 
       
  /concat-map@0.0.1:

     

       
3158
       
 
       
    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}

     

       
3159
       
 
       
    dev: true

     
···

       
3174
       
 
       
    resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==}

     

       
3175
       
 
       
    engines: {node: '>=14'}

     

       
3176
       
 
       
    peerDependencies:

     

       
3177
       
-
       
      typescript: ^5.3.3

     

       
3178
       
 
       
    peerDependenciesMeta:

     

       
3179
       
 
       
      typescript:

     

       
3180
       
 
       
        optional: true

     
···

       
3222
       
 
       
      which: 2.0.2

     

       
3223
       
 
       
    dev: true

     

       
3224
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3225
       
 
       
  /csstype@3.1.3:

     

       
3226
       
 
       
    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}

     

       
3227
       
 
       
    dev: true

     
···

       
3256
       
 
       
    resolution: {integrity: sha512-8YnDaaf7N3k/q5HnTJVuzSyLETjoZjVmHc4AeKAzOvKHEFQKcn64OKBfzHYtE9zGjctNM7V9I0MfnUVLpi7M5g==}

     

       
3257
       
 
       
    dev: true

     

       
3258
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3259
       
 
       
  /debounce@1.2.1:

     

       
3260
       
 
       
    resolution: {integrity: sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==}

     

       
3261
       
 
       
    dev: true

     
···

       
3284
       
 
       
    resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==}

     

       
3285
       
 
       
    engines: {node: '>=0.10.0'}

     

       
3286
       
 
       
    dev: true

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3287
       
 
       


     

       
3288
       
 
       
  /deep-eql@4.1.3:

     

       
3289
       
 
       
    resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==}

     
···

       
3333
       
 
       
  /deprecation@2.3.1:

     

       
3334
       
 
       
    resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==}

     

       
3335
       
 
       
    dev: true

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3336
       
 
       


     

       
3337
       
 
       
  /detect-indent@6.1.0:

     

       
3338
       
 
       
    resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}

     
···

       
3396
       
 
       
      ansi-colors: 4.1.3

     

       
3397
       
 
       
    dev: true

     

       
3398
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3399
       
 
       
  /error-ex@1.3.2:

     

       
3400
       
 
       
    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}

     

       
3401
       
 
       
    dependencies:

     
···

       
3514
       
 
       


     

       
3515
       
 
       
  /estree-walker@2.0.2:

     

       
3516
       
 
       
    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}

     

       
3517
       
-
       
    dev: true

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3518
       
 
       


     

       
3519
       
 
       
  /eventemitter3@5.0.1:

     

       
3520
       
 
       
    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}

     
···

       
3813
       
 
       
      - graphql

     

       
3814
       
 
       
    dev: false

     

       
3815
       
 
       


     

       
3816
       
-
       
  /gql.tada@1.4.0(graphql@16.8.1):

     

       
3817
       
-
       
    resolution: {integrity: sha512-/LZJmInJQESn0QafOrDCJRk9ASeI65caU/HmarPtcSNitNWBrH7UfNOsHtISnTTA/CS80eUYqy3M4ogasFZWPQ==}

     

       
3818
       
 
       
    hasBin: true

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3819
       
 
       
    dependencies:

     

       
3820
       
-
       
      '@0no-co/graphql.web': 1.0.4(graphql@16.8.1)

     

       
3821
       
-
       
      '@gql.tada/cli-utils': 0.3.0

     

       
3822
       
-
       
      '@gql.tada/internal': 0.1.0

     

       
0
       
 
       

     

       
3823
       
 
       
    transitivePeerDependencies:

     

       
0
       
 
       

     

       
3824
       
 
       
      - graphql

     

       
0
       
 
       

     

       
3825
       
 
       
    dev: false

     

       
3826
       
 
       


     

       
3827
       
 
       
  /graceful-fs@4.2.11:

     
···

       
3964
       
 
       
      function-bind: 1.1.2

     

       
3965
       
 
       
    dev: true

     

       
3966
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3967
       
 
       
  /header-case@2.0.4:

     

       
3968
       
 
       
    resolution: {integrity: sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==}

     

       
3969
       
 
       
    dependencies:

     
···

       
4232
       
 
       
      '@types/estree': 1.0.5

     

       
4233
       
 
       
    dev: true

     

       
4234
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4235
       
 
       
  /is-regex@1.1.4:

     

       
4236
       
 
       
    resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==}

     

       
4237
       
 
       
    engines: {node: '>= 0.4'}

     
···

       
4494
       
 
       
    engines: {node: '>=14'}

     

       
4495
       
 
       
    dev: true

     

       
4496
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4497
       
 
       
  /locate-path@5.0.0:

     

       
4498
       
 
       
    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}

     

       
4499
       
 
       
    engines: {node: '>=8'}

     
···

       
4572
       
 
       
    resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==}

     

       
4573
       
 
       
    dependencies:

     

       
4574
       
 
       
      tslib: 2.6.2

     

       
4575
       
-
       
    dev: true

     

       
4576
       
 
       


     

       
4577
       
 
       
  /lru-cache@10.0.1:

     

       
4578
       
 
       
    resolution: {integrity: sha512-IJ4uwUTi2qCccrioU6g9g/5rvvVl13bsdczUUcqbciD9iLr095yj8DQKdObriEvuNSx325N1rV1O0sJFszx75g==}

     
···

       
4604
       
 
       
    engines: {node: '>=12'}

     

       
4605
       
 
       
    dependencies:

     

       
4606
       
 
       
      '@jridgewell/sourcemap-codec': 1.4.15

     

       
4607
       
-
       
    dev: true

     

       
4608
       
 
       


     

       
4609
       
 
       
  /make-error@1.3.6:

     

       
4610
       
 
       
    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}

     
···

       
4625
       
 
       
    engines: {node: '>=8'}

     

       
4626
       
 
       
    dev: true

     

       
4627
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4628
       
 
       
  /meow@6.1.1:

     

       
4629
       
 
       
    resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==}

     

       
4630
       
 
       
    engines: {node: '>=8'}

     
···

       
4718
       
 
       
      brace-expansion: 2.0.1

     

       
4719
       
 
       
    dev: true

     

       
4720
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4721
       
 
       
  /minimist-options@4.1.0:

     

       
4722
       
 
       
    resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==}

     

       
4723
       
 
       
    engines: {node: '>= 6'}

     
···

       
4745
       
 
       
    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}

     

       
4746
       
 
       
    dev: true

     

       
4747
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4748
       
 
       
  /mute-stream@0.0.8:

     

       
4749
       
 
       
    resolution: {integrity: sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==}

     

       
4750
       
 
       
    dev: true

     
···

       
4760
       
 
       
    dependencies:

     

       
4761
       
 
       
      lower-case: 2.0.2

     

       
4762
       
 
       
      tslib: 2.6.2

     

       
4763
       
-
       
    dev: true

     

       
4764
       
 
       


     

       
4765
       
 
       
  /node-fetch@2.6.7:

     

       
4766
       
 
       
    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}

     
···

       
4973
       
 
       
    dependencies:

     

       
4974
       
 
       
      no-case: 3.0.4

     

       
4975
       
 
       
      tslib: 2.6.2

     

       
4976
       
-
       
    dev: true

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4977
       
 
       


     

       
4978
       
 
       
  /path-case@3.0.4:

     

       
4979
       
 
       
    resolution: {integrity: sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==}

     
···

       
5031
       
 
       
    resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}

     

       
5032
       
 
       
    dev: true

     

       
5033
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5034
       
 
       
  /picocolors@1.0.0:

     

       
5035
       
 
       
    resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}

     

       
5036
       
 
       
    dev: true

     
···

       
5301
       
 
       
    engines: {node: '>=16'}

     

       
5302
       
 
       
    peerDependencies:

     

       
5303
       
 
       
      rollup: ^3.29.4 || ^4

     

       
5304
       
-
       
      typescript: ^5.3.3

     

       
5305
       
 
       
    dependencies:

     

       
5306
       
 
       
      magic-string: 0.30.5

     

       
5307
       
 
       
      rollup: 4.9.5

     
···

       
5533
       
 
       
    engines: {node: '>=0.10.0'}

     

       
5534
       
 
       
    dev: true

     

       
5535
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5536
       
 
       
  /source-map-support@0.5.21:

     

       
5537
       
 
       
    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}

     

       
5538
       
 
       
    dependencies:

     
···

       
5717
       
 
       
    engines: {node: '>= 0.4'}

     

       
5718
       
 
       
    dev: true

     

       
5719
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5720
       
 
       
  /swap-case@2.0.2:

     

       
5721
       
 
       
    resolution: {integrity: sha512-kc6S2YS/2yXbtkSMunBtKdah4VFETZ8Oh6ONSmSd9bRxhqTrtARUCBUiWXH3xVPpvR7tz2CSnkuXVE42EcGnMw==}

     

       
5722
       
 
       
    dependencies:

     
···

       
5773
       
 
       
  /to-fast-properties@2.0.0:

     

       
5774
       
 
       
    resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}

     

       
5775
       
 
       
    engines: {node: '>=4'}

     

       
5776
       
-
       
    dev: true

     

       
5777
       
 
       


     

       
5778
       
 
       
  /to-regex-range@5.0.1:

     

       
5779
       
 
       
    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}

     
···

       
5801
       
 
       
      '@swc/core': '>=1.2.50'

     

       
5802
       
 
       
      '@swc/wasm': '>=1.2.50'

     

       
5803
       
 
       
      '@types/node': '*'

     

       
5804
       
-
       
      typescript: ^5.3.3

     

       
5805
       
 
       
    peerDependenciesMeta:

     

       
5806
       
 
       
      '@swc/core':

     

       
5807
       
 
       
        optional: true

     
···

       
5831
       
 
       


     

       
5832
       
 
       
  /tslib@2.6.2:

     

       
5833
       
 
       
    resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}

     

       
5834
       
-
       
    dev: true

     

       
5835
       
 
       


     

       
5836
       
 
       
  /tty-table@4.2.1:

     

       
5837
       
 
       
    resolution: {integrity: sha512-xz0uKo+KakCQ+Dxj1D/tKn2FSyreSYWzdkL/BYhgN6oMW808g8QRMuh1atAV9fjTPbWBjfbkKQpI/5rEcnAc7g==}

     
···

       
6135
       
 
       
    resolution: {integrity: sha512-zHhCWatviizPIq9B7Vh9uvrH6x3sK8itC84HkamnBWoDFJtzBf7SWlpLCZUit72b3os45h6RWQNC9xHRDF8dRA==}

     

       
6136
       
 
       
    dev: true

     

       
6137
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6138
       
 
       
  /wcwidth@1.0.1:

     

       
6139
       
 
       
    resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}

     

       
6140
       
 
       
    dependencies:

     
···

       
6364
       
 
       
    id: file:packages/graphqlsp

     

       
6365
       
 
       
    name: '@0no-co/graphqlsp'

     

       
6366
       
 
       
    peerDependencies:

     

       
6367
       
-
       
      typescript: ^5.3.3

     

       
6368
       
 
       
    dependencies:

     

       
6369
       
-
       
      '@gql.tada/internal': 0.1.2(graphql@16.8.1)(typescript@5.3.3)

     

       
6370
       
 
       
      graphql: 16.8.1

     

       
6371
       
 
       
      node-fetch: 2.6.7

     

       
6372
       
 
       
      typescript: 5.3.3