11509277046

Committed 24 Oct 2024 11:54PM UTC coverage: 31.377%. Remained the same

Build # 11509277046

Build Type

push

github

Committed by

Raemon

Commit Message

Merge remote-tracking branch 'origin/jargonBot' into jargonBot

Run Details

5026 of 42228 branches covered (11.9%)

Branch coverage included in aggregate %.

1 of 6 new or added lines in 2 files covered. (16.67%)

77 existing lines in 5 files now uncovered.

29609 of 68157 relevant lines covered (43.44%)

174.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.28

/packages/lesswrong/server/codegen/generateFragmentTypes.ts

import { getAllFragmentNames, getFragment, graphqlTypeToCollectionName, getCollection, getAllCollections, isValidCollectionName } from '../../lib/vulcan-lib';
import { generatedFileHeader, assert, simplSchemaTypeToTypescript, graphqlTypeToTypescript } from './typeGenerationUtils';
import { getSchema } from '../../lib/utils/getSchema';
import groupBy from 'lodash/groupBy';

const fragmentFileHeader = generatedFileHeader+`//
// Contains Typescript signatures for fragments, generated by
// server/codegen/generateFragmentTypes.ts.
//
`

export function generateFragmentTypes(): string {
  const fragmentNames: Array<FragmentName> = getAllFragmentNames();  
  const sb: Array<string> = [];
  
  for (let fragmentName of fragmentNames) {
    sb.push(generateFragmentTypeDefinition(fragmentName));
  }
  
  sb.push(generateFragmentsIndexType());
  sb.push(generateCollectionNamesByFragmentNameType());
  sb.push(generateCollectionNamesIndexType());
  sb.push(generateCollectionNamesWithCreatedAtIndexType());
  sb.push(generateCollectionNamesWithSlugIndexType());
  
  return fragmentFileHeader + sb.join('');
}

type ParsedFragmentType = ReturnType<typeof getParsedFragment>;

function getParsedFragment(fragmentName: FragmentName) {
  const fragmentDefinitions = getFragment(fragmentName);
  
  // `getFragment` returns the parsed definition of a fragment plus all of its
  // dependency fragments. The one we requested will be first.
  assert((fragmentDefinitions?.definitions?.length ?? 0) > 0);
  const parsedFragment = fragmentDefinitions?.definitions[0];
  assert(parsedFragment?.kind === "FragmentDefinition");
  if (!parsedFragment || !("name" in parsedFragment) || !("selectionSet" in parsedFragment) || parsedFragment?.name?.value !== fragmentName) {
    throw new Error("Retrieved parsed fragment with wrong name");
  }
  return parsedFragment;
}

function fragmentNameToCollectionName(fragmentName: FragmentName): CollectionNameString {
  const parsedFragment = getParsedFragment(fragmentName);
  if (!parsedFragment || !("typeCondition" in parsedFragment)) {
    throw new Error("Not a type node");
  }
  const typeName = parsedFragment.typeCondition.name?.value;
  const collectionName = graphqlTypeToCollectionName(typeName!);
  return collectionName;
}

function generateFragmentTypeDefinition(fragmentName: FragmentName): string {
  const parsedFragment = getParsedFragment(fragmentName);
  const collectionName = fragmentNameToCollectionName(fragmentName);
  const collection = isValidCollectionName(collectionName) ? getCollection(collectionName) : null;
  
  return fragmentToInterface(fragmentName, parsedFragment, collection);
}

function generateFragmentsIndexType(): string {
  const fragmentNames: Array<FragmentName> = getAllFragmentNames();
  const sb: Array<string> = [];
  
  sb.push('interface FragmentTypes {\n');
  for (let fragmentName of fragmentNames) {
    sb.push(`  ${fragmentName}: ${fragmentName}\n`);
  }
  sb.push('}\n\n');
  
  const fragmentNamesByCollection = groupBy(fragmentNames, (f: FragmentName): CollectionNameString => fragmentNameToCollectionName(f));
  sb.push(`interface FragmentTypesByCollection {\n`);
  for (const collectionName of Object.keys(fragmentNamesByCollection)) {
    sb.push(`  ${collectionName}: `);
    sb.push(fragmentNamesByCollection[collectionName].map(f=>`"${f}"`).join("|"));
    sb.push("\n");
  }
  sb.push('}\n\n');
  
  return sb.join('');
}

function generateCollectionNamesByFragmentNameType(): string {
  const fragmentNames: Array<FragmentName> = getAllFragmentNames();
  const sb: Array<string> = [];
  
  sb.push(`interface CollectionNamesByFragmentName {\n`);
  for (let fragmentName of fragmentNames) {
    const collectionName = fragmentNameToCollectionName(fragmentName);
    if (isValidCollectionName(collectionName)) {
      sb.push(`  ${fragmentName}: "${collectionName}"\n`);
    } else {
      sb.push(`  ${fragmentName}: never\n`);
    }
  }
  sb.push('}\n\n');
  
  return sb.join('');
}

const generateCollectionNameList = (
  name: string,
  collections: CollectionBase<CollectionNameString>[],
): string =>
  `type ${name} = ${collections.map(c => `"${c.collectionName}"`).join('|')}\n\n`;

const generateCollectionNamesIndexType = () =>
  generateCollectionNameList("CollectionNameString", getAllCollections());

const generateCollectionNamesWithCreatedAtIndexType = () =>
  generateCollectionNameList(
    "CollectionNameWithCreatedAt",
    getAllCollections().filter((c) => !!c._schemaFields.createdAt),
  );

const generateCollectionNamesWithSlugIndexType = () =>
  generateCollectionNameList(
    "CollectionNameWithSlug",
    getAllCollections().filter((c) => !!c._schemaFields.slug),
  );

function fragmentToInterface(interfaceName: string, parsedFragment: ParsedFragmentType, collection: AnyBecauseTodo): string {
  const sb: Array<string> = [];
  
  const spreadFragments = getSpreadFragments(parsedFragment);
  const inheritanceStr = spreadFragments.length>0 ? ` extends ${spreadFragments.join(', ')}` : "";
  
  sb.push(`interface ${interfaceName}${inheritanceStr} { // fragment on ${collection?.collectionName ?? "non-collection type"}\n`);
  
  const allSubfragments: Array<string> = [];
  for (let selection of parsedFragment.selectionSet.selections) {
    switch(selection.kind) {
      case "Field":
        const { fieldType, subfragment } = getFragmentFieldType(interfaceName, selection, collection)
        sb.push(`  readonly ${selection.name.value}: ${fieldType},\n`);
        if (subfragment)
          allSubfragments.push(subfragment);
        break;
      case "FragmentSpread":
        break;
      default:
        sb.push(`  UNRECOGNIZED: ${selection.kind}\n`);
        break;
    }
  }
  
  sb.push('}\n\n');
  for (let subfragment of allSubfragments)
    sb.push(subfragment);
  return sb.join('');
}

function getSpreadFragments(parsedFragment: AnyBecauseTodo): Array<string> {
  const spreadFragmentNames: Array<string> = [];
  for (let selection of parsedFragment.selectionSet.selections) {
    if(selection.kind === "FragmentSpread") {
      spreadFragmentNames.push(selection.name.value);
    }
  }
  return spreadFragmentNames;
}

function getFragmentFieldType(fragmentName: string, parsedFragmentField: AnyBecauseTodo, collection: AnyBecauseTodo):
  { fieldType: string, subfragment: string|null }
{
  if (collection === null) {
    // Fragments may not correspond to a collection, if eg they're on a graphql
    // type defined with addGraphQLSchema. In that case, emit a type with the
    // right set of fields but with every field having type `any` because sadly
    // we aren't yet tracking down the schema definition.
    return { fieldType: "any", subfragment: null };
  }

  const fieldName: string = parsedFragmentField.name.value;
  if (fieldName === "__typename") {
    return { fieldType: "string", subfragment: null };
  }
  const schema = getSchema(collection);
  
  // There are two ways a field name can appear in a schema. The first is as a
  // regular field with that name. The second is as a resolver with that name,
  // which may be attached to a field with the same name or a different name.
  // If there's a resolver, it takes precedence.
  
  let fieldType: string|null = null;
  
  // Check for a field with a resolver by this name
  for (let schemaFieldName of Object.keys(schema)) {
    const fieldWithResolver = schema[schemaFieldName];
    if (fieldWithResolver?.resolveAs?.fieldName === fieldName) {
      if (fieldWithResolver.typescriptType) {
        fieldType = fieldWithResolver.typescriptType;
      } else {
        assert(!!fieldWithResolver.resolveAs.type);
        fieldType = graphqlTypeToTypescript(fieldWithResolver.resolveAs.type);
      }
      break;
    }
  }
  
  // Check for regular presence in the schema
  if (!fieldType) {
    if (fieldName in schema) {
      const fieldSchema = schema[fieldName];
      assert(fieldSchema?.type);
      if (fieldSchema?.typescriptType && fieldSchema?.blackbox) {
        fieldType = fieldSchema.typescriptType;
      } else if (fieldSchema?.resolveAs?.type && !fieldSchema?.resolveAs?.fieldName) {
        // If the field is a string with allowed values, we need to emit a type that matches the allowed values
        // It'd be annoying to refactor graphqlTypeToTypescript to support this, so we just special-case strings with allowed values here
        // Annoyingly, allowedValues seems to get reassigned from being a top-level field to being on the `type` (probably when it's run through SimpleSchema somewhere)
        if (fieldSchema.resolveAs.type === 'String' && fieldSchema.type?.definitions[0]?.allowedValues?.length) {
          fieldType = simplSchemaTypeToTypescript(schema, fieldName, fieldSchema.type);
        } else {
          fieldType = graphqlTypeToTypescript(fieldSchema.resolveAs.type);
        }
      } else {
        fieldType = simplSchemaTypeToTypescript(schema, fieldName, schema[fieldName].type);
      }
    }
  }
  
  // If neither found, error (fragment contains a field that isn't in the schema)
  if (!fieldType) {
    throw new Error(`Fragment ${fragmentName} contains field ${fieldName} on type ${collection.collectionName} which is not in the schema`);
  }

  const {collection: subfieldCollection, nullable} = subfragmentTypeToCollection(fieldType);
  
  // Now check if the field has a sub-selector
  if (parsedFragmentField.selectionSet?.selections?.length > 0) {
    // As a special case, if the sub-selector spreads a fragment and has no
    // other fields, use that fragment's type
    if (parsedFragmentField.selectionSet.selections.length === 1
      && parsedFragmentField.selectionSet.selections[0].kind === "FragmentSpread")
    {
      const subfragmentName = parsedFragmentField.selectionSet.selections[0].name.value;
      if (fieldType.startsWith("Array<")) {
        return {
          fieldType: nullable ? `Array<${subfragmentName}>|null` : `Array<${subfragmentName}>`,
          subfragment: null
        };
      } else {
        return {
          fieldType: nullable ? `${subfragmentName}|null` : subfragmentName,
          subfragment: null
        };
      }
    }
    else
    {
      if (typeof fieldType !== "string") throw new Error("fieldType is not a string: was "+JSON.stringify(fieldType));
      if (!subfieldCollection) {
        // eslint-disable-next-line no-console
        console.log(`Field ${fieldName} in fragment ${fragmentName} has type ${fieldType} which does not identify a collection`);
        //throw new Error(`Field ${fieldName} in fragment ${fragmentName} has type ${fieldType} which does not identify a collection`);
        return {
          fieldType: "any", subfragment: null
        };
      }
      const subfragmentName = `${fragmentName}_${fieldName}`;
      const subfragment = fragmentToInterface(subfragmentName, parsedFragmentField, subfieldCollection);
      
      // If it's an array type, then it's an array of that subfragment. Otherwise it's an instance of that subfragmetn.
      if (fieldType.startsWith("Array<")) {
        return {
          fieldType: nullable ? `Array<${subfragmentName}>|null` : `Array<${subfragmentName}>`,
          subfragment: subfragment,
        };
      } else {
        return {
          fieldType: nullable ? `${subfragmentName}|null` : subfragmentName,
          subfragment: subfragment,
        };
      }
    }
  } else {
    return {
      fieldType, subfragment: null
    };
  }
}

// Given the type of a field (as a string which is a Typescript type), where
// that field is a collection type with optional array- or nullable-wrapping,
// return the collection.
function subfragmentTypeToCollection(fieldType: string): {
  collection: CollectionBase<any>|null,
  nullable: boolean,
}{
  if (fieldType.startsWith("Array<") && fieldType.endsWith(">")) {
    return {
      collection: subfragmentTypeToCollection(fieldType.substr(6, fieldType.length-7)).collection,
      nullable: false,
    };
  } else if (fieldType.endsWith("|null")) {
    return {
      collection: subfragmentTypeToCollection(fieldType.substr(0, fieldType.length-5)).collection,
      nullable: true,
    };
  } else if (fieldType.endsWith("!")) {
    return {
      collection: subfragmentTypeToCollection(fieldType.substr(0, fieldType.length-1)).collection,
      nullable: false
    };
  } else {
    const collectionName = graphqlTypeToCollectionName(fieldType);
    if (isValidCollectionName(collectionName)) {
      return {
        collection: getCollection(collectionName),
        nullable: false
      };
    } else {
      return {
        collection: null,
        nullable: false
      }
    }
  }
}

1	import { getAllFragmentNames, getFragment, graphqlTypeToCollectionName, getCollection, getAllCollections, isValidCollectionName } from '../../lib/vulcan-lib';	54✔
2	import { generatedFileHeader, assert, simplSchemaTypeToTypescript, graphqlTypeToTypescript } from './typeGenerationUtils';	18✔
3	import { getSchema } from '../../lib/utils/getSchema';	18✔
4	import groupBy from 'lodash/groupBy';	18✔
5
6	const fragmentFileHeader = generatedFileHeader+`//	18✔
7	// Contains Typescript signatures for fragments, generated by
8	// server/codegen/generateFragmentTypes.ts.
9	//
10	`
11
12	export function generateFragmentTypes(): string {
13	const fragmentNames: Array<FragmentName> = getAllFragmentNames();	×
14	const sb: Array<string> = [];	×
15
16	for (let fragmentName of fragmentNames) {	×
17	sb.push(generateFragmentTypeDefinition(fragmentName));	×
18	}
19
20	sb.push(generateFragmentsIndexType());	×
21	sb.push(generateCollectionNamesByFragmentNameType());	×
22	sb.push(generateCollectionNamesIndexType());	×
23	sb.push(generateCollectionNamesWithCreatedAtIndexType());	×
24	sb.push(generateCollectionNamesWithSlugIndexType());	×
25
26	return fragmentFileHeader + sb.join('');	×
27	}
28
29	type ParsedFragmentType = ReturnType<typeof getParsedFragment>;
30
31	function getParsedFragment(fragmentName: FragmentName) {
32	const fragmentDefinitions = getFragment(fragmentName);	×
33
34	// `getFragment` returns the parsed definition of a fragment plus all of its
35	// dependency fragments. The one we requested will be first.
36	assert((fragmentDefinitions?.definitions?.length ?? 0) > 0);	×
37	const parsedFragment = fragmentDefinitions?.definitions[0];	×
38	assert(parsedFragment?.kind === "FragmentDefinition");	×
39	if (!parsedFragment \|\| !("name" in parsedFragment) \|\| !("selectionSet" in parsedFragment) \|\| parsedFragment?.name?.value !== fragmentName) {	×
40	throw new Error("Retrieved parsed fragment with wrong name");	×
41	}
42	return parsedFragment;	×
43	}
44
45	function fragmentNameToCollectionName(fragmentName: FragmentName): CollectionNameString {
46	const parsedFragment = getParsedFragment(fragmentName);	×
47	if (!parsedFragment \|\| !("typeCondition" in parsedFragment)) {	×
48	throw new Error("Not a type node");	×
49	}
50	const typeName = parsedFragment.typeCondition.name?.value;	×
51	const collectionName = graphqlTypeToCollectionName(typeName!);	×
52	return collectionName;	×
53	}
54
55	function generateFragmentTypeDefinition(fragmentName: FragmentName): string {
56	const parsedFragment = getParsedFragment(fragmentName);	×
57	const collectionName = fragmentNameToCollectionName(fragmentName);	×
58	const collection = isValidCollectionName(collectionName) ? getCollection(collectionName) : null;	×
59
60	return fragmentToInterface(fragmentName, parsedFragment, collection);	×
61	}
62
63	function generateFragmentsIndexType(): string {
64	const fragmentNames: Array<FragmentName> = getAllFragmentNames();	×
65	const sb: Array<string> = [];	×
66
67	sb.push('interface FragmentTypes {\n');	×
68	for (let fragmentName of fragmentNames) {	×
69	sb.push(` ${fragmentName}: ${fragmentName}\n`);	×
70	}
71	sb.push('}\n\n');	×
72
73	const fragmentNamesByCollection = groupBy(fragmentNames, (f: FragmentName): CollectionNameString => fragmentNameToCollectionName(f));	×
74	sb.push(`interface FragmentTypesByCollection {\n`);	×
75	for (const collectionName of Object.keys(fragmentNamesByCollection)) {	×
76	sb.push(` ${collectionName}: `);	×
77	sb.push(fragmentNamesByCollection[collectionName].map(f=>`"${f}"`).join("\|"));	×
78	sb.push("\n");	×
79	}
80	sb.push('}\n\n');	×
81
82	return sb.join('');	×
83	}
84
85	function generateCollectionNamesByFragmentNameType(): string {
86	const fragmentNames: Array<FragmentName> = getAllFragmentNames();	×
87	const sb: Array<string> = [];	×
88
89	sb.push(`interface CollectionNamesByFragmentName {\n`);	×
90	for (let fragmentName of fragmentNames) {	×
91	const collectionName = fragmentNameToCollectionName(fragmentName);	×
92	if (isValidCollectionName(collectionName)) {	×
93	sb.push(` ${fragmentName}: "${collectionName}"\n`);	×
94	} else {
95	sb.push(` ${fragmentName}: never\n`);	×
96	}
97	}
98	sb.push('}\n\n');	×
99
100	return sb.join('');	×
101	}
102
103	const generateCollectionNameList = (	18✔
104	name: string,
105	collections: CollectionBase<CollectionNameString>[],
106	): string =>
107	`type ${name} = ${collections.map(c => `"${c.collectionName}"`).join('\|')}\n\n`;	×
108
109	const generateCollectionNamesIndexType = () =>	18✔
110	generateCollectionNameList("CollectionNameString", getAllCollections());	×
111
112	const generateCollectionNamesWithCreatedAtIndexType = () =>	18✔
113	generateCollectionNameList(	×
114	"CollectionNameWithCreatedAt",
115	getAllCollections().filter((c) => !!c._schemaFields.createdAt),	×
116	);
117
118	const generateCollectionNamesWithSlugIndexType = () =>	18✔
119	generateCollectionNameList(	×
120	"CollectionNameWithSlug",
121	getAllCollections().filter((c) => !!c._schemaFields.slug),	×
122	);
123
124	function fragmentToInterface(interfaceName: string, parsedFragment: ParsedFragmentType, collection: AnyBecauseTodo): string {
125	const sb: Array<string> = [];	×
126
127	const spreadFragments = getSpreadFragments(parsedFragment);	×
128	const inheritanceStr = spreadFragments.length>0 ? ` extends ${spreadFragments.join(', ')}` : "";	×
129
130	sb.push(`interface ${interfaceName}${inheritanceStr} { // fragment on ${collection?.collectionName ?? "non-collection type"}\n`);	×
131
132	const allSubfragments: Array<string> = [];	×
133	for (let selection of parsedFragment.selectionSet.selections) {	×
134	switch(selection.kind) {	×
135	case "Field":
136	const { fieldType, subfragment } = getFragmentFieldType(interfaceName, selection, collection)	×
137	sb.push(` readonly ${selection.name.value}: ${fieldType},\n`);	×
138	if (subfragment)	×
139	allSubfragments.push(subfragment);	×
140	break;	×
141	case "FragmentSpread":
142	break;	×
143	default:
144	sb.push(` UNRECOGNIZED: ${selection.kind}\n`);	×
145	break;	×
146	}
147	}
148
149	sb.push('}\n\n');	×
150	for (let subfragment of allSubfragments)	×
151	sb.push(subfragment);	×
152	return sb.join('');	×
153	}
154
155	function getSpreadFragments(parsedFragment: AnyBecauseTodo): Array<string> {
156	const spreadFragmentNames: Array<string> = [];	×
157	for (let selection of parsedFragment.selectionSet.selections) {	×
158	if(selection.kind === "FragmentSpread") {	×
159	spreadFragmentNames.push(selection.name.value);	×
160	}
161	}
162	return spreadFragmentNames;	×
163	}
164
165	function getFragmentFieldType(fragmentName: string, parsedFragmentField: AnyBecauseTodo, collection: AnyBecauseTodo):
166	{ fieldType: string, subfragment: string\|null }
167	{
168	if (collection === null) {	×
169	// Fragments may not correspond to a collection, if eg they're on a graphql
170	// type defined with addGraphQLSchema. In that case, emit a type with the
171	// right set of fields but with every field having type `any` because sadly
172	// we aren't yet tracking down the schema definition.
173	return { fieldType: "any", subfragment: null };	×
174	}
175
176	const fieldName: string = parsedFragmentField.name.value;	×
177	if (fieldName === "__typename") {	×
178	return { fieldType: "string", subfragment: null };	×
179	}
180	const schema = getSchema(collection);	×
181
182	// There are two ways a field name can appear in a schema. The first is as a
183	// regular field with that name. The second is as a resolver with that name,
184	// which may be attached to a field with the same name or a different name.
185	// If there's a resolver, it takes precedence.
186
187	let fieldType: string\|null = null;	×
188
189	// Check for a field with a resolver by this name
190	for (let schemaFieldName of Object.keys(schema)) {	×
191	const fieldWithResolver = schema[schemaFieldName];	×
192	if (fieldWithResolver?.resolveAs?.fieldName === fieldName) {	×
193	if (fieldWithResolver.typescriptType) {	×
194	fieldType = fieldWithResolver.typescriptType;	×
195	} else {
196	assert(!!fieldWithResolver.resolveAs.type);	×
197	fieldType = graphqlTypeToTypescript(fieldWithResolver.resolveAs.type);	×
198	}
199	break;	×
200	}
201	}
202
203	// Check for regular presence in the schema
204	if (!fieldType) {	×
205	if (fieldName in schema) {	×
206	const fieldSchema = schema[fieldName];	×
207	assert(fieldSchema?.type);	×
208	if (fieldSchema?.typescriptType && fieldSchema?.blackbox) {	×
209	fieldType = fieldSchema.typescriptType;	×
210	} else if (fieldSchema?.resolveAs?.type && !fieldSchema?.resolveAs?.fieldName) {	×
211	// If the field is a string with allowed values, we need to emit a type that matches the allowed values
212	// It'd be annoying to refactor graphqlTypeToTypescript to support this, so we just special-case strings with allowed values here
213	// Annoyingly, allowedValues seems to get reassigned from being a top-level field to being on the `type` (probably when it's run through SimpleSchema somewhere)
NEW 214	if (fieldSchema.resolveAs.type === 'String' && fieldSchema.type?.definitions[0]?.allowedValues?.length) {	×
NEW 215	fieldType = simplSchemaTypeToTypescript(schema, fieldName, fieldSchema.type);	×
216	} else {
NEW 217	fieldType = graphqlTypeToTypescript(fieldSchema.resolveAs.type);	×
218	}
219	} else {
UNCOV 220	fieldType = simplSchemaTypeToTypescript(schema, fieldName, schema[fieldName].type);	×
221	}
222	}
223	}
224
225	// If neither found, error (fragment contains a field that isn't in the schema)
UNCOV 226	if (!fieldType) {	×
227	throw new Error(`Fragment ${fragmentName} contains field ${fieldName} on type ${collection.collectionName} which is not in the schema`);	×
228	}
229
UNCOV 230	const {collection: subfieldCollection, nullable} = subfragmentTypeToCollection(fieldType);	×
231
232	// Now check if the field has a sub-selector
233	if (parsedFragmentField.selectionSet?.selections?.length > 0) {	×
234	// As a special case, if the sub-selector spreads a fragment and has no
235	// other fields, use that fragment's type
UNCOV 236	if (parsedFragmentField.selectionSet.selections.length === 1	×
237	&& parsedFragmentField.selectionSet.selections[0].kind === "FragmentSpread")
238	{
UNCOV 239	const subfragmentName = parsedFragmentField.selectionSet.selections[0].name.value;	×
240	if (fieldType.startsWith("Array<")) {	×
UNCOV 241	return {	×
242	fieldType: nullable ? `Array<${subfragmentName}>\|null` : `Array<${subfragmentName}>`,	×
243	subfragment: null
244	};
245	} else {
246	return {	×
247	fieldType: nullable ? `${subfragmentName}\|null` : subfragmentName,	×
248	subfragment: null
249	};
250	}
251	}
252	else
253	{
UNCOV 254	if (typeof fieldType !== "string") throw new Error("fieldType is not a string: was "+JSON.stringify(fieldType));	×
UNCOV 255	if (!subfieldCollection) {	×
256	// eslint-disable-next-line no-console
UNCOV 257	console.log(`Field ${fieldName} in fragment ${fragmentName} has type ${fieldType} which does not identify a collection`);	×
258	//throw new Error(`Field ${fieldName} in fragment ${fragmentName} has type ${fieldType} which does not identify a collection`);
UNCOV 259	return {	×
260	fieldType: "any", subfragment: null
261	};
262	}
UNCOV 263	const subfragmentName = `${fragmentName}_${fieldName}`;	×
264	const subfragment = fragmentToInterface(subfragmentName, parsedFragmentField, subfieldCollection);	×
265
266	// If it's an array type, then it's an array of that subfragment. Otherwise it's an instance of that subfragmetn.
UNCOV 267	if (fieldType.startsWith("Array<")) {	×
UNCOV 268	return {	×
269	fieldType: nullable ? `Array<${subfragmentName}>\|null` : `Array<${subfragmentName}>`,	×
270	subfragment: subfragment,
271	};
272	} else {
UNCOV 273	return {	×
274	fieldType: nullable ? `${subfragmentName}\|null` : subfragmentName,	×
275	subfragment: subfragment,
276	};
277	}
278	}
279	} else {
280	return {	×
281	fieldType, subfragment: null
282	};
283	}
284	}
285
286	// Given the type of a field (as a string which is a Typescript type), where
287	// that field is a collection type with optional array- or nullable-wrapping,
288	// return the collection.
289	function subfragmentTypeToCollection(fieldType: string): {
290	collection: CollectionBase<any>\|null,
291	nullable: boolean,
292	}{
UNCOV 293	if (fieldType.startsWith("Array<") && fieldType.endsWith(">")) {	×
UNCOV 294	return {	×
295	collection: subfragmentTypeToCollection(fieldType.substr(6, fieldType.length-7)).collection,
296	nullable: false,
297	};
UNCOV 298	} else if (fieldType.endsWith("\|null")) {	×
UNCOV 299	return {	×
300	collection: subfragmentTypeToCollection(fieldType.substr(0, fieldType.length-5)).collection,
301	nullable: true,
302	};
UNCOV 303	} else if (fieldType.endsWith("!")) {	×
UNCOV 304	return {	×
305	collection: subfragmentTypeToCollection(fieldType.substr(0, fieldType.length-1)).collection,
306	nullable: false
307	};
308	} else {
UNCOV 309	const collectionName = graphqlTypeToCollectionName(fieldType);	×
310	if (isValidCollectionName(collectionName)) {	×
311	return {	×
312	collection: getCollection(collectionName),
313	nullable: false
314	};
315	} else {
316	return {	×
317	collection: null,
318	nullable: false
319	}
320	}
321	}
322	}

ForumMagnum / ForumMagnum / 11509277046

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous