@directus/api 35.0.2 → 35.2.0

package/dist/services/graphql/schema/read.js

@@ -225,18 +225,10 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 					default: filterOperatorType = StringFilterOperators;
 				}
 				acc[field.field] = filterOperatorType;
-				if (field.type === "date") {
-					acc[`${field.field}_func`] = { type: DateFunctionFilterOperators };
-				}
-				if (field.type === "time") {
-					acc[`${field.field}_func`] = { type: TimeFunctionFilterOperators };
-				}
-				if (field.type === "dateTime" || field.type === "timestamp") {
-					acc[`${field.field}_func`] = { type: DateTimeFunctionFilterOperators };
-				}
-				if (field.type === "json" || field.type === "alias") {
-					acc[`${field.field}_func`] = { type: CountFunctionFilterOperators };
-				}
+				if (field.type === "date") acc[`${field.field}_func`] = { type: DateFunctionFilterOperators };
+				if (field.type === "time") acc[`${field.field}_func`] = { type: TimeFunctionFilterOperators };
+				if (field.type === "dateTime" || field.type === "timestamp") acc[`${field.field}_func`] = { type: DateTimeFunctionFilterOperators };
+				if (field.type === "json" || field.type === "alias") acc[`${field.field}_func`] = { type: CountFunctionFilterOperators };
 				return acc;
 			}, {})
 		});
@@ -247,8 +239,7 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 		AggregatedFields[collection.collection] = schemaComposer.createObjectTC({
 			name: `${collection.collection}_aggregated_fields`,
 			fields: Object.values(collection.fields).reduce((acc, field) => {
-				const graphqlType = getGraphQLType(field.type, field.special);
-				switch (graphqlType) {
+				switch (getGraphQLType(field.type, field.special)) {
 					case GraphQLBigInt:
 					case GraphQLInt:
 					case GraphQLFloat:
@@ -290,41 +281,36 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 				type: countType
 			}
 		};
-		const hasNumericAggregates = Object.values(collection.fields).some((field) => {
+		if (Object.values(collection.fields).some((field) => {
 			const graphqlType = getGraphQLType(field.type, field.special);
-			if (graphqlType === GraphQLInt || graphqlType === GraphQLFloat) {
-				return true;
-			}
+			if (graphqlType === GraphQLInt || graphqlType === GraphQLFloat) return true;
 			return false;
+		})) Object.assign(AggregateMethods[collection.collection], {
+			avg: {
+				name: "avg",
+				type: AggregatedFields[collection.collection]
+			},
+			sum: {
+				name: "sum",
+				type: AggregatedFields[collection.collection]
+			},
+			avgDistinct: {
+				name: "avgDistinct",
+				type: AggregatedFields[collection.collection]
+			},
+			sumDistinct: {
+				name: "sumDistinct",
+				type: AggregatedFields[collection.collection]
+			},
+			min: {
+				name: "min",
+				type: AggregatedFields[collection.collection]
+			},
+			max: {
+				name: "max",
+				type: AggregatedFields[collection.collection]
+			}
 		});
-		if (hasNumericAggregates) {
-			Object.assign(AggregateMethods[collection.collection], {
-				avg: {
-					name: "avg",
-					type: AggregatedFields[collection.collection]
-				},
-				sum: {
-					name: "sum",
-					type: AggregatedFields[collection.collection]
-				},
-				avgDistinct: {
-					name: "avgDistinct",
-					type: AggregatedFields[collection.collection]
-				},
-				sumDistinct: {
-					name: "sumDistinct",
-					type: AggregatedFields[collection.collection]
-				},
-				min: {
-					name: "min",
-					type: AggregatedFields[collection.collection]
-				},
-				max: {
-					name: "max",
-					type: AggregatedFields[collection.collection]
-				}
-			});
-		}
 		AggregatedFunctions[collection.collection] = schemaComposer.createObjectTC({
 			name: `${collection.collection}_aggregated`,
 			fields: AggregateMethods[collection.collection]
@@ -334,18 +320,15 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 			type: collection.singleton ? ReadCollectionTypes[collection.collection] : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))),
 			resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
 		};
-		if (collection.singleton === false) {
-			resolver.args = {
-				filter: ReadableCollectionFilterTypes[collection.collection],
-				sort: { type: new GraphQLList(GraphQLString) },
-				limit: { type: GraphQLInt },
-				offset: { type: GraphQLInt },
-				page: { type: GraphQLInt },
-				search: { type: GraphQLString }
-			};
-		} else {
-			resolver.args = { version: GraphQLString };
-		}
+		if (collection.singleton === false) resolver.args = {
+			filter: ReadableCollectionFilterTypes[collection.collection],
+			sort: { type: new GraphQLList(GraphQLString) },
+			limit: { type: GraphQLInt },
+			offset: { type: GraphQLInt },
+			page: { type: GraphQLInt },
+			search: { type: GraphQLString }
+		};
+		else resolver.args = { version: GraphQLString };
 		ReadCollectionTypes[collection.collection].addResolver(resolver);
 		ReadCollectionTypes[collection.collection].addResolver({
 			name: `${collection.collection}_aggregated`,
@@ -361,28 +344,24 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 			},
 			resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
 		});
-		if (collection.singleton === false) {
-			ReadCollectionTypes[collection.collection].addResolver({
-				name: `${collection.collection}_by_id`,
-				type: ReadCollectionTypes[collection.collection],
-				args: {
-					id: new GraphQLNonNull(GraphQLID),
-					version: GraphQLString
-				},
-				resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
-			});
-		}
-		if (gql.scope === "items") {
-			VersionCollectionTypes[collection.collection].addResolver({
-				name: `${collection.collection}_by_version`,
-				type: VersionCollectionTypes[collection.collection],
-				args: collection.singleton ? { version: new GraphQLNonNull(GraphQLString) } : {
-					version: new GraphQLNonNull(GraphQLString),
-					id: new GraphQLNonNull(GraphQLID)
-				},
-				resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
-			});
-		}
+		if (collection.singleton === false) ReadCollectionTypes[collection.collection].addResolver({
+			name: `${collection.collection}_by_id`,
+			type: ReadCollectionTypes[collection.collection],
+			args: {
+				id: new GraphQLNonNull(GraphQLID),
+				version: GraphQLString
+			},
+			resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
+		});
+		if (gql.scope === "items") VersionCollectionTypes[collection.collection].addResolver({
+			name: `${collection.collection}_by_version`,
+			type: VersionCollectionTypes[collection.collection],
+			args: collection.singleton ? { version: new GraphQLNonNull(GraphQLString) } : {
+				version: new GraphQLNonNull(GraphQLString),
+				id: new GraphQLNonNull(GraphQLID)
+			},
+			resolve: dedupeRelationalResolver(({ info }) => resolveQuery(gql, info))
+		});
 		const eventName = `${collection.collection}_mutated`;
 		if (collection.collection in ReadCollectionTypes) {
 			const subscriptionType = schemaComposer.createObjectTC({
@@ -408,38 +387,36 @@ async function getReadableTypes(gql, schemaComposer, schema, inconsistentFields)
 		});
 		ReadableCollectionQuantifierFilterTypes[collection] = quantifier_collection;
 	}
-	for (const relation of schema.read.relations) {
-		if (relation.related_collection) {
-			if (SYSTEM_DENY_LIST.includes(relation.related_collection)) continue;
-			ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({ [relation.field]: ReadableCollectionFilterTypes[relation.related_collection] });
-			ReadableCollectionFilterTypes[relation.collection]?.addFields({ [relation.field]: ReadableCollectionFilterTypes[relation.related_collection] });
-			ReadCollectionTypes[relation.collection]?.addFieldArgs(relation.field, {
-				filter: ReadableCollectionFilterTypes[relation.related_collection],
+	for (const relation of schema.read.relations) if (relation.related_collection) {
+		if (SYSTEM_DENY_LIST.includes(relation.related_collection)) continue;
+		ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({ [relation.field]: ReadableCollectionFilterTypes[relation.related_collection] });
+		ReadableCollectionFilterTypes[relation.collection]?.addFields({ [relation.field]: ReadableCollectionFilterTypes[relation.related_collection] });
+		ReadCollectionTypes[relation.collection]?.addFieldArgs(relation.field, {
+			filter: ReadableCollectionFilterTypes[relation.related_collection],
+			sort: { type: new GraphQLList(GraphQLString) },
+			limit: { type: GraphQLInt },
+			offset: { type: GraphQLInt },
+			page: { type: GraphQLInt },
+			search: { type: GraphQLString }
+		});
+		if (relation.meta?.one_field) {
+			ReadableCollectionQuantifierFilterTypes[relation.related_collection]?.addFields({ [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection] });
+			ReadableCollectionFilterTypes[relation.related_collection]?.addFields({ [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection] });
+			ReadCollectionTypes[relation.related_collection]?.addFieldArgs(relation.meta.one_field, {
+				filter: ReadableCollectionFilterTypes[relation.collection],
 				sort: { type: new GraphQLList(GraphQLString) },
 				limit: { type: GraphQLInt },
 				offset: { type: GraphQLInt },
 				page: { type: GraphQLInt },
 				search: { type: GraphQLString }
 			});
-			if (relation.meta?.one_field) {
-				ReadableCollectionQuantifierFilterTypes[relation.related_collection]?.addFields({ [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection] });
-				ReadableCollectionFilterTypes[relation.related_collection]?.addFields({ [relation.meta.one_field]: ReadableCollectionQuantifierFilterTypes[relation.collection] });
-				ReadCollectionTypes[relation.related_collection]?.addFieldArgs(relation.meta.one_field, {
-					filter: ReadableCollectionFilterTypes[relation.collection],
-					sort: { type: new GraphQLList(GraphQLString) },
-					limit: { type: GraphQLInt },
-					offset: { type: GraphQLInt },
-					page: { type: GraphQLInt },
-					search: { type: GraphQLString }
-				});
-			}
-		} else if (relation.meta?.one_allowed_collections) {
-			ReadableCollectionQuantifierFilterTypes[relation.collection]?.removeField(relation.field);
-			ReadableCollectionFilterTypes[relation.collection]?.removeField(relation.field);
-			for (const collection of relation.meta.one_allowed_collections) {
-				ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({ [`${relation.field}__${collection}`]: ReadableCollectionFilterTypes[collection] });
-				ReadableCollectionFilterTypes[relation.collection]?.addFields({ [`${relation.field}__${collection}`]: ReadableCollectionFilterTypes[collection] });
-			}
+		}
+	} else if (relation.meta?.one_allowed_collections) {
+		ReadableCollectionQuantifierFilterTypes[relation.collection]?.removeField(relation.field);
+		ReadableCollectionFilterTypes[relation.collection]?.removeField(relation.field);
+		for (const collection of relation.meta.one_allowed_collections) {
+			ReadableCollectionQuantifierFilterTypes[relation.collection]?.addFields({ [`${relation.field}__${collection}`]: ReadableCollectionFilterTypes[collection] });
+			ReadableCollectionFilterTypes[relation.collection]?.addFields({ [`${relation.field}__${collection}`]: ReadableCollectionFilterTypes[collection] });
 		}
 	}
 	return {

package/dist/services/graphql/schema/write.js

@@ -22,9 +22,7 @@ function getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadC
 				type: collectionIsReadable ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))) : GraphQLBoolean,
 				resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
 			};
-			if (collectionIsReadable) {
-				resolverDefinition.args = ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs();
-			}
+			if (collectionIsReadable) resolverDefinition.args = ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs();
 			CreateCollectionTypes[collection.collection].addResolver(resolverDefinition);
 			CreateCollectionTypes[collection.collection].addResolver({
 				name: `create_${collection.collection}_item`,
@@ -47,44 +45,41 @@ function getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadC
 		if (collection.collection in UpdateCollectionTypes === false) continue;
 		const collectionIsReadable = collection.collection in ReadCollectionTypes;
 		const updatableFields = UpdateCollectionTypes[collection.collection]?.getFields() || {};
-		if (Object.keys(updatableFields).length > 0) {
-			if (collection.singleton) {
-				UpdateCollectionTypes[collection.collection].addResolver({
-					name: `update_${collection.collection}`,
-					type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
-					args: { data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull },
-					resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
-				});
-			} else {
-				UpdateCollectionTypes[collection.collection].addResolver({
-					name: `update_${collection.collection}_batch`,
-					type: collectionIsReadable ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))) : GraphQLBoolean,
-					args: {
-						...collectionIsReadable ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs() : {},
-						data: [toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull]
-					},
-					resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
-				});
-				UpdateCollectionTypes[collection.collection].addResolver({
-					name: `update_${collection.collection}_items`,
-					type: collectionIsReadable ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))) : GraphQLBoolean,
-					args: {
-						...collectionIsReadable ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs() : {},
-						ids: new GraphQLNonNull(new GraphQLList(GraphQLID)),
-						data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull
-					},
-					resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
-				});
-				UpdateCollectionTypes[collection.collection].addResolver({
-					name: `update_${collection.collection}_item`,
-					type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
-					args: {
-						id: new GraphQLNonNull(GraphQLID),
-						data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull
-					},
-					resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
-				});
-			}
+		if (Object.keys(updatableFields).length > 0) if (collection.singleton) UpdateCollectionTypes[collection.collection].addResolver({
+			name: `update_${collection.collection}`,
+			type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
+			args: { data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull },
+			resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
+		});
+		else {
+			UpdateCollectionTypes[collection.collection].addResolver({
+				name: `update_${collection.collection}_batch`,
+				type: collectionIsReadable ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))) : GraphQLBoolean,
+				args: {
+					...collectionIsReadable ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs() : {},
+					data: [toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull]
+				},
+				resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
+			});
+			UpdateCollectionTypes[collection.collection].addResolver({
+				name: `update_${collection.collection}_items`,
+				type: collectionIsReadable ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType()))) : GraphQLBoolean,
+				args: {
+					...collectionIsReadable ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs() : {},
+					ids: new GraphQLNonNull(new GraphQLList(GraphQLID)),
+					data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull
+				},
+				resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
+			});
+			UpdateCollectionTypes[collection.collection].addResolver({
+				name: `update_${collection.collection}_item`,
+				type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
+				args: {
+					id: new GraphQLNonNull(GraphQLID),
+					data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull
+				},
+				resolve: async ({ args, info }) => await resolveMutation(gql, args, info)
+			});
 		}
 	}
 	DeleteCollectionTypes["many"] = schemaComposer.createObjectTC({

package/dist/services/graphql/subscription.js

@@ -8,8 +8,7 @@ import { EventEmitter, on } from "events";
 //#region src/services/graphql/subscription.ts
 const messages = createPubSub(new EventEmitter());
 function bindPubSub() {
-	const messenger = useBus();
-	messenger.subscribe("websocket.event", (message) => {
+	useBus().subscribe("websocket.event", (message) => {
 		messages.publish(`${message["collection"]}_mutated`, message);
 	});
 }
@@ -19,48 +18,36 @@ function createSubscriptionGenerator(gql, event) {
 		const args = parseArguments(request);
 		for await (const payload of messages.subscribe(event)) {
 			const eventData = payload;
-			if ("event" in args && eventData["action"] !== args["event"]) {
-				continue;
-			}
+			if ("event" in args && eventData["action"] !== args["event"]) continue;
 			const schema = await getSchema();
 			const subscription = {
 				collection: eventData["collection"],
 				event: eventData["action"],
 				query: { fields }
 			};
-			if (eventData["action"] === "delete") {
-				for (const key of eventData.keys) {
-					yield { [event]: {
-						key,
-						data: null,
-						event: eventData["action"]
-					} };
-				}
-			}
-			if (eventData["action"] === "create") {
-				try {
-					subscription.item = eventData["key"];
-					const result = await getPayload(subscription, gql.accountability, schema, eventData);
-					yield { [event]: {
-						key: eventData["key"],
-						data: result["data"],
-						event: eventData["action"]
-					} };
-				} catch {}
-			}
-			if (eventData["action"] === "update") {
-				for (const key of eventData["keys"]) {
-					try {
-						subscription.item = key;
-						const result = await getPayload(subscription, gql.accountability, schema, eventData);
-						yield { [event]: {
-							key,
-							data: result["data"],
-							event: eventData["action"]
-						} };
-					} catch {}
-				}
-			}
+			if (eventData["action"] === "delete") for (const key of eventData.keys) yield { [event]: {
+				key,
+				data: null,
+				event: eventData["action"]
+			} };
+			if (eventData["action"] === "create") try {
+				subscription.item = eventData["key"];
+				const result = await getPayload(subscription, gql.accountability, schema, eventData);
+				yield { [event]: {
+					key: eventData["key"],
+					data: result["data"],
+					event: eventData["action"]
+				} };
+			} catch {}
+			if (eventData["action"] === "update") for (const key of eventData["keys"]) try {
+				subscription.item = key;
+				const result = await getPayload(subscription, gql.accountability, schema, eventData);
+				yield { [event]: {
+					key,
+					data: result["data"],
+					event: eventData["action"]
+				} };
+			} catch {}
 		}
 	};
 }
@@ -69,29 +56,21 @@ function createPubSub(emitter) {
 		publish: (event, payload) => void emitter.emit(event, payload),
 		subscribe: async function* (event) {
 			const asyncIterator = on(emitter, event);
-			for await (const [value] of asyncIterator) {
-				yield value;
-			}
+			for await (const [value] of asyncIterator) yield value;
 		}
 	};
 }
 async function parseFields(gql, request) {
-	const selections = request.fieldNodes[0]?.selectionSet?.selections ?? [];
-	const dataSelections = selections.reduce((result, selection) => {
-		if (selection.kind === "Field" && selection.name.value === "data" && selection.selectionSet?.kind === "SelectionSet") {
-			return selection.selectionSet.selections;
-		}
+	const dataSelections = (request.fieldNodes[0]?.selectionSet?.selections ?? []).reduce((result, selection) => {
+		if (selection.kind === "Field" && selection.name.value === "data" && selection.selectionSet?.kind === "SelectionSet") return selection.selectionSet.selections;
 		return result;
 	}, []);
 	const { fields } = await getQuery({}, gql.schema, dataSelections, request.variableValues, gql.accountability);
 	return fields ?? [];
 }
 function parseArguments(request) {
-	const args = request.fieldNodes[0]?.arguments ?? [];
-	return args.reduce((result, current) => {
-		if ("value" in current.value && typeof current.value.value === "string") {
-			result[current.name.value] = current.value.value;
-		}
+	return (request.fieldNodes[0]?.arguments ?? []).reduce((result, current) => {
+		if ("value" in current.value && typeof current.value.value === "string") result[current.name.value] = current.value.value;
 		return result;
 	}, {});
 }

package/dist/services/graphql/types/bigint.js

@@ -9,34 +9,24 @@ const GraphQLBigInt = new GraphQLScalarType({
 	serialize(value) {
 		if (!value) return value;
 		if (typeof value === "string") return value;
-		if (typeof value !== "number") {
-			throw new Error("Value must be a Number");
-		}
+		if (typeof value !== "number") throw new Error("Value must be a Number");
 		return value.toString();
 	},
 	parseValue(value) {
-		if (typeof value !== "string") {
-			throw new Error("Value must be a String");
-		}
+		if (typeof value !== "string") throw new Error("Value must be a String");
 		return parseNumberValue(value);
 	},
 	parseLiteral(ast) {
-		if (ast.kind !== Kind.STRING) {
-			throw new Error("Value must be a String");
-		}
+		if (ast.kind !== Kind.STRING) throw new Error("Value must be a String");
 		return parseNumberValue(ast.value);
 	}
 });
 function parseNumberValue(input) {
 	const intValue = Number(input);
-	if (isNaN(intValue)) {
-		throw new Error("Invalid GraphQLBigInt");
-	}
+	if (isNaN(intValue)) throw new Error("Invalid GraphQLBigInt");
 	if (!Number.isSafeInteger(intValue)) {
 		const bigIntInput = BigInt(input);
-		if (bigIntInput < MIN_BIG_INT || bigIntInput > MAX_BIG_INT) {
-			throw new Error("Invalid GraphQLBigInt");
-		}
+		if (bigIntInput < MIN_BIG_INT || bigIntInput > MAX_BIG_INT) throw new Error("Invalid GraphQLBigInt");
 		return input;
 	}
 	return intValue;

package/dist/services/graphql/types/string-or-float.js

@@ -8,15 +8,11 @@ const GraphQLStringOrFloat = new GraphQLScalarType({
 	name: "GraphQLStringOrFloat",
 	description: "A Float or a String",
 	serialize(value) {
-		if (typeof value !== "string" && typeof value !== "number") {
-			throw new Error("Value must be either a String or a Float");
-		}
+		if (typeof value !== "string" && typeof value !== "number") throw new Error("Value must be either a String or a Float");
 		return value;
 	},
 	parseValue(value) {
-		if (typeof value !== "string" && typeof value !== "number") {
-			throw new Error("Value must be either a String or a Float");
-		}
+		if (typeof value !== "string" && typeof value !== "number") throw new Error("Value must be either a String or a Float");
 		return value;
 	},
 	parseLiteral(ast) {

package/dist/services/graphql/utils/add-path-to-validation-error.js

@@ -7,9 +7,7 @@ function addPathToValidationError(validationError) {
 	let prev = token;
 	const queryRegex = /query_[A-Za-z0-9]{8}/;
 	while (prev) {
-		if (prev.kind === "Name" && prev.value && queryRegex.test(prev.value)) {
-			return locatedError(validationError, validationError.nodes, [prev.value]);
-		}
+		if (prev.kind === "Name" && prev.value && queryRegex.test(prev.value)) return locatedError(validationError, validationError.nodes, [prev.value]);
 		prev = prev.prev;
 	}
 	return locatedError(validationError, validationError.nodes);

package/dist/services/graphql/utils/aggregate-query.js

@@ -21,12 +21,8 @@ async function getAggregateQuery(rawQuery, selections, schema, accountability, c
 			return selectionNode.name.value;
 		}) ?? [];
 	}
-	if (query.filter) {
-		query.filter = replaceFuncs(query.filter);
-	}
-	if (collection && query.filter) {
-		query.filter = filterReplaceM2A(query.filter, collection, schema);
-	}
+	if (query.filter) query.filter = replaceFuncs(query.filter);
+	if (collection && query.filter) query.filter = filterReplaceM2A(query.filter, collection, schema);
 	validateQuery(query);
 	return query;
 }

package/dist/services/graphql/utils/dedupe-resolvers.js

@@ -9,8 +9,7 @@ import { print } from "graphql";
 */
 function resolverCacheKey(args, info) {
 	const selectionKey = info.fieldNodes[0]?.selectionSet ? print(info.fieldNodes[0].selectionSet) : "";
-	const cacheKey = `${info.fieldName}:${hash(args ?? {})}:${selectionKey}`;
-	return cacheKey;
+	return `${info.fieldName}:${hash(args ?? {})}:${selectionKey}`;
 }
 /**
 * Wraps a GraphQL field resolver to deduplicate concurrent calls with identical
@@ -25,9 +24,7 @@ function dedupeResolver(resolver, overrideKey) {
 	return (source, args, context, info) => {
 		const { cache } = context;
 		const cacheKey = overrideKey ?? resolverCacheKey(args, info);
-		if (!cache.has(cacheKey)) {
-			cache.set(cacheKey, resolver(source, args, context, info));
-		}
+		if (!cache.has(cacheKey)) cache.set(cacheKey, resolver(source, args, context, info));
 		return cache.get(cacheKey);
 	};
 }
@@ -44,14 +41,12 @@ function dedupeRelationalResolver(resolver) {
 	return async ({ source, args, context, info }) => {
 		const { cache } = context;
 		const cacheKey = resolverCacheKey(args, info);
-		if (!cache.has(cacheKey)) {
-			cache.set(cacheKey, resolver({
-				source,
-				args,
-				context,
-				info
-			}));
-		}
+		if (!cache.has(cacheKey)) cache.set(cacheKey, resolver({
+			source,
+			args,
+			context,
+			info
+		}));
 		const result = await cache.get(cacheKey);
 		context.data = result;
 		return result;

package/dist/services/graphql/utils/filter-replace-m2a.js

@@ -16,18 +16,13 @@ function filterReplaceM2A(filter_arg, collection, schema, options) {
 			field,
 			useA2O: true
 		}) : null;
-		if (type === "o2m" && relation) {
-			filter[key] = filterReplaceM2A(filter[key], relation.collection, schema, options);
-		} else if (type === "m2o" && relation) {
-			filter[key] = filterReplaceM2A(filter[key], relation.related_collection, schema, options);
-		} else if (type === "a2o" && relation && any_collection && relation.meta?.one_allowed_collections?.includes(any_collection)) {
+		if (type === "o2m" && relation) filter[key] = filterReplaceM2A(filter[key], relation.collection, schema, options);
+		else if (type === "m2o" && relation) filter[key] = filterReplaceM2A(filter[key], relation.related_collection, schema, options);
+		else if (type === "a2o" && relation && any_collection && relation.meta?.one_allowed_collections?.includes(any_collection)) {
 			filter[`${field}:${any_collection}`] = filterReplaceM2A(filter[key], any_collection, schema, options);
 			delete filter[key];
-		} else if (Array.isArray(filter[key])) {
-			filter[key] = filter[key].map((item) => filterReplaceM2A(item, collection, schema, options));
-		} else if (typeof filter[key] === "object") {
-			filter[key] = filterReplaceM2A(filter[key], collection, schema, options);
-		}
+		} else if (Array.isArray(filter[key])) filter[key] = filter[key].map((item) => filterReplaceM2A(item, collection, schema, options));
+		else if (typeof filter[key] === "object") filter[key] = filterReplaceM2A(filter[key], collection, schema, options);
 	}
 	return filter;
 }
@@ -48,18 +43,14 @@ function filterReplaceM2ADeep(deep_arg, collection, schema, options) {
 				field,
 				useA2O: true
 			});
-			if (type === "o2m") {
-				deep[key] = filterReplaceM2ADeep(deep[key], relation.collection, schema);
-			} else if (type === "m2o") {
-				deep[key] = filterReplaceM2ADeep(deep[key], relation.related_collection, schema);
-			} else if (type === "a2o" && any_collection && relation.meta?.one_allowed_collections?.includes(any_collection)) {
+			if (type === "o2m") deep[key] = filterReplaceM2ADeep(deep[key], relation.collection, schema);
+			else if (type === "m2o") deep[key] = filterReplaceM2ADeep(deep[key], relation.related_collection, schema);
+			else if (type === "a2o" && any_collection && relation.meta?.one_allowed_collections?.includes(any_collection)) {
 				deep[`${field}:${any_collection}`] = filterReplaceM2ADeep(deep[key], any_collection, schema);
 				delete deep[key];
 			}
 		}
-		if (key === "_filter") {
-			deep[key] = filterReplaceM2A(deep[key], collection, schema);
-		}
+		if (key === "_filter") deep[key] = filterReplaceM2A(deep[key], collection, schema);
 	}
 	return deep;
 }