@directus/api 34.0.1 → 35.0.0

package/dist/services/graphql/resolvers/get-field-type.js

@@ -1,51 +1,52 @@
-import { GraphQLBoolean, GraphQLInt, GraphQLNonNull, GraphQLString } from 'graphql';
-import { getGraphQLType } from '../../../utils/get-graphql-type.js';
-export function getFieldType(schemaComposer, schema, action) {
-    const prefix = action === 'read' ? '' : 'write_';
-    const Field = schemaComposer.createObjectTC({
-        name: `${prefix}directus_fields`,
-    });
-    if ('directus_fields' in schema.read.collections === false) {
-        return Field;
-    }
-    Field.addFields({
-        collection: GraphQLString,
-        field: GraphQLString,
-        type: GraphQLString,
-        meta: schemaComposer.createObjectTC({
-            name: `${prefix}directus_fields_meta`,
-            fields: Object.values(schema.read.collections['directus_fields'].fields).reduce((acc, field) => {
-                acc[field.field] = {
-                    type: field.nullable || action === 'write'
-                        ? getGraphQLType(field.type, field.special)
-                        : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
-                    description: field.note,
-                };
-                return acc;
-            }, {}),
-        }),
-        schema: schemaComposer.createObjectTC({
-            name: `${prefix}directus_fields_schema`,
-            fields: {
-                name: GraphQLString,
-                table: GraphQLString,
-                data_type: GraphQLString,
-                default_value: GraphQLString,
-                max_length: GraphQLInt,
-                numeric_precision: GraphQLInt,
-                numeric_scale: GraphQLInt,
-                is_generated: GraphQLBoolean,
-                generation_expression: GraphQLString,
-                is_indexed: GraphQLBoolean,
-                is_nullable: GraphQLBoolean,
-                is_unique: GraphQLBoolean,
-                is_primary_key: GraphQLBoolean,
-                has_auto_increment: GraphQLBoolean,
-                foreign_key_column: GraphQLString,
-                foreign_key_table: GraphQLString,
-                comment: GraphQLString,
-            },
-        }),
-    });
-    return Field;
+import { getGraphQLType } from "../../../utils/get-graphql-type.js";
+import { GraphQLBoolean, GraphQLInt, GraphQLNonNull, GraphQLString } from "graphql";
+
+//#region src/services/graphql/resolvers/get-field-type.ts
+function getFieldType(schemaComposer, schema, action) {
+	const prefix = action === "read" ? "" : "write_";
+	const Field = schemaComposer.createObjectTC({ name: `${prefix}directus_fields` });
+	if ("directus_fields" in schema.read.collections === false) {
+		return Field;
+	}
+	Field.addFields({
+		collection: GraphQLString,
+		field: GraphQLString,
+		type: GraphQLString,
+		meta: schemaComposer.createObjectTC({
+			name: `${prefix}directus_fields_meta`,
+			fields: Object.values(schema.read.collections["directus_fields"].fields).reduce((acc, field) => {
+				acc[field.field] = {
+					type: field.nullable || action === "write" ? getGraphQLType(field.type, field.special) : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
+					description: field.note
+				};
+				return acc;
+			}, {})
+		}),
+		schema: schemaComposer.createObjectTC({
+			name: `${prefix}directus_fields_schema`,
+			fields: {
+				name: GraphQLString,
+				table: GraphQLString,
+				data_type: GraphQLString,
+				default_value: GraphQLString,
+				max_length: GraphQLInt,
+				numeric_precision: GraphQLInt,
+				numeric_scale: GraphQLInt,
+				is_generated: GraphQLBoolean,
+				generation_expression: GraphQLString,
+				is_indexed: GraphQLBoolean,
+				is_nullable: GraphQLBoolean,
+				is_unique: GraphQLBoolean,
+				is_primary_key: GraphQLBoolean,
+				has_auto_increment: GraphQLBoolean,
+				foreign_key_column: GraphQLString,
+				foreign_key_table: GraphQLString,
+				comment: GraphQLString
+			}
+		})
+	});
+	return Field;
 }
+
+//#endregion
+export { getFieldType };

package/dist/services/graphql/resolvers/get-relation-type.js

@@ -1,39 +1,42 @@
-import { GraphQLNonNull, GraphQLString } from 'graphql';
-import { getGraphQLType } from '../../../utils/get-graphql-type.js';
-export function getRelationType(schemaComposer, schema, action) {
-    const prefix = action === 'read' ? '' : 'write_';
-    const Relation = schemaComposer.createObjectTC({
-        name: `${prefix}directus_relations`,
-    });
-    if ('directus_relations' in schema.read.collections === false) {
-        return Relation;
-    }
-    Relation.addFields({
-        collection: GraphQLString,
-        field: GraphQLString,
-        related_collection: GraphQLString,
-        schema: schemaComposer.createObjectTC({
-            name: `${prefix}directus_relations_schema`,
-            fields: {
-                table: new GraphQLNonNull(GraphQLString),
-                column: new GraphQLNonNull(GraphQLString),
-                foreign_key_table: new GraphQLNonNull(GraphQLString),
-                foreign_key_column: new GraphQLNonNull(GraphQLString),
-                constraint_name: GraphQLString,
-                on_update: new GraphQLNonNull(GraphQLString),
-                on_delete: new GraphQLNonNull(GraphQLString),
-            },
-        }),
-        meta: schemaComposer.createObjectTC({
-            name: `${prefix}directus_relations_meta`,
-            fields: Object.values(schema.read.collections['directus_relations'].fields).reduce((acc, field) => {
-                acc[field.field] = {
-                    type: getGraphQLType(field.type, field.special),
-                    description: field.note,
-                };
-                return acc;
-            }, {}),
-        }),
-    });
-    return Relation;
+import { getGraphQLType } from "../../../utils/get-graphql-type.js";
+import { GraphQLNonNull, GraphQLString } from "graphql";
+
+//#region src/services/graphql/resolvers/get-relation-type.ts
+function getRelationType(schemaComposer, schema, action) {
+	const prefix = action === "read" ? "" : "write_";
+	const Relation = schemaComposer.createObjectTC({ name: `${prefix}directus_relations` });
+	if ("directus_relations" in schema.read.collections === false) {
+		return Relation;
+	}
+	Relation.addFields({
+		collection: GraphQLString,
+		field: GraphQLString,
+		related_collection: GraphQLString,
+		schema: schemaComposer.createObjectTC({
+			name: `${prefix}directus_relations_schema`,
+			fields: {
+				table: new GraphQLNonNull(GraphQLString),
+				column: new GraphQLNonNull(GraphQLString),
+				foreign_key_table: new GraphQLNonNull(GraphQLString),
+				foreign_key_column: new GraphQLNonNull(GraphQLString),
+				constraint_name: GraphQLString,
+				on_update: new GraphQLNonNull(GraphQLString),
+				on_delete: new GraphQLNonNull(GraphQLString)
+			}
+		}),
+		meta: schemaComposer.createObjectTC({
+			name: `${prefix}directus_relations_meta`,
+			fields: Object.values(schema.read.collections["directus_relations"].fields).reduce((acc, field) => {
+				acc[field.field] = {
+					type: getGraphQLType(field.type, field.special),
+					description: field.note
+				};
+				return acc;
+			}, {})
+		})
+	});
+	return Relation;
 }
+
+//#endregion
+export { getRelationType };

package/dist/services/graphql/resolvers/mutation.js

@@ -1,74 +1,69 @@
-import { getService } from '../../../utils/get-service.js';
-import { formatError } from '../errors/format.js';
-import { getQuery } from '../schema/parse-query.js';
-import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
-export async function resolveMutation(gql, args, info) {
-    const action = info.fieldName.split('_')[0];
-    let collection = info.fieldName.substring(action.length + 1);
-    if (gql.scope === 'system')
-        collection = `directus_${collection}`;
-    const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-    const query = await getQuery(args, gql.schema, selections || [], info.variableValues, gql.accountability, collection);
-    const singleton = collection.endsWith('_batch') === false &&
-        collection.endsWith('_items') === false &&
-        collection.endsWith('_item') === false &&
-        collection in gql.schema.collections;
-    const single = collection.endsWith('_items') === false && collection.endsWith('_batch') === false;
-    const batchUpdate = action === 'update' && collection.endsWith('_batch');
-    if (collection.endsWith('_batch'))
-        collection = collection.slice(0, -6);
-    if (collection.endsWith('_items'))
-        collection = collection.slice(0, -6);
-    if (collection.endsWith('_item'))
-        collection = collection.slice(0, -5);
-    if (singleton && action === 'update') {
-        return await gql.upsertSingleton(collection, args['data'], query);
-    }
-    const service = getService(collection, {
-        knex: gql.knex,
-        accountability: gql.accountability,
-        schema: gql.schema,
-    });
-    const hasQuery = (query.fields || []).length > 0;
-    try {
-        if (single) {
-            if (action === 'create') {
-                const key = await service.createOne(args['data']);
-                return hasQuery ? await service.readOne(key, query) : true;
-            }
-            if (action === 'update') {
-                const key = await service.updateOne(args['id'], args['data']);
-                return hasQuery ? await service.readOne(key, query) : true;
-            }
-            if (action === 'delete') {
-                await service.deleteOne(args['id']);
-                return { id: args['id'] };
-            }
-            return undefined;
-        }
-        else {
-            if (action === 'create') {
-                const keys = await service.createMany(args['data']);
-                return hasQuery ? await service.readMany(keys, query) : true;
-            }
-            if (action === 'update') {
-                const keys = [];
-                if (batchUpdate) {
-                    keys.push(...(await service.updateBatch(args['data'])));
-                }
-                else {
-                    keys.push(...(await service.updateMany(args['ids'], args['data'])));
-                }
-                return hasQuery ? await service.readMany(keys, query) : true;
-            }
-            if (action === 'delete') {
-                const keys = await service.deleteMany(args['ids']);
-                return { ids: keys };
-            }
-            return undefined;
-        }
-    }
-    catch (err) {
-        return formatError(err);
-    }
+import { getService } from "../../../utils/get-service.js";
+import { formatError } from "../errors/format.js";
+import { getQuery } from "../schema/parse-query.js";
+import { replaceFragmentsInSelections } from "../utils/replace-fragments.js";
+
+//#region src/services/graphql/resolvers/mutation.ts
+async function resolveMutation(gql, args, info) {
+	const action = info.fieldName.split("_")[0];
+	let collection = info.fieldName.substring(action.length + 1);
+	if (gql.scope === "system") collection = `directus_${collection}`;
+	const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
+	const query = await getQuery(args, gql.schema, selections || [], info.variableValues, gql.accountability, collection);
+	const singleton = collection.endsWith("_batch") === false && collection.endsWith("_items") === false && collection.endsWith("_item") === false && collection in gql.schema.collections;
+	const single = collection.endsWith("_items") === false && collection.endsWith("_batch") === false;
+	const batchUpdate = action === "update" && collection.endsWith("_batch");
+	if (collection.endsWith("_batch")) collection = collection.slice(0, -6);
+	if (collection.endsWith("_items")) collection = collection.slice(0, -6);
+	if (collection.endsWith("_item")) collection = collection.slice(0, -5);
+	if (singleton && action === "update") {
+		return await gql.upsertSingleton(collection, args["data"], query);
+	}
+	const service = getService(collection, {
+		knex: gql.knex,
+		accountability: gql.accountability,
+		schema: gql.schema
+	});
+	const hasQuery = (query.fields || []).length > 0;
+	try {
+		if (single) {
+			if (action === "create") {
+				const key = await service.createOne(args["data"]);
+				return hasQuery ? await service.readOne(key, query) : true;
+			}
+			if (action === "update") {
+				const key = await service.updateOne(args["id"], args["data"]);
+				return hasQuery ? await service.readOne(key, query) : true;
+			}
+			if (action === "delete") {
+				await service.deleteOne(args["id"]);
+				return { id: args["id"] };
+			}
+			return undefined;
+		} else {
+			if (action === "create") {
+				const keys = await service.createMany(args["data"]);
+				return hasQuery ? await service.readMany(keys, query) : true;
+			}
+			if (action === "update") {
+				const keys = [];
+				if (batchUpdate) {
+					keys.push(...await service.updateBatch(args["data"]));
+				} else {
+					keys.push(...await service.updateMany(args["ids"], args["data"]));
+				}
+				return hasQuery ? await service.readMany(keys, query) : true;
+			}
+			if (action === "delete") {
+				const keys = await service.deleteMany(args["ids"]);
+				return { ids: keys };
+			}
+			return undefined;
+		}
+	} catch (err) {
+		return formatError(err);
+	}
 }
+
+//#endregion
+export { resolveMutation };

package/dist/services/graphql/resolvers/query.js

@@ -1,70 +1,70 @@
-import { parseFilterFunctionPath } from '@directus/utils';
-import { omit } from 'lodash-es';
-import { parseArgs } from '../schema/parse-args.js';
-import { getQuery } from '../schema/parse-query.js';
-import { getAggregateQuery } from '../utils/aggregate-query.js';
-import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
+import { parseArgs } from "../schema/parse-args.js";
+import { getQuery } from "../schema/parse-query.js";
+import { replaceFragmentsInSelections } from "../utils/replace-fragments.js";
+import { getAggregateQuery } from "../utils/aggregate-query.js";
+import { parseFilterFunctionPath } from "@directus/utils";
+import { omit } from "lodash-es";
+
+//#region src/services/graphql/resolvers/query.ts
 /**
- * Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
- * Directus' query structure which is then executed by the services.
- */
-export async function resolveQuery(gql, info) {
-    let collection = info.fieldName;
-    if (gql.scope === 'system')
-        collection = `directus_${collection}`;
-    const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
-    if (!selections)
-        return null;
-    const args = parseArgs(info.fieldNodes[0].arguments || [], info.variableValues);
-    let query;
-    const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
-    if (isAggregate) {
-        collection = collection.slice(0, -11);
-        query = await getAggregateQuery(args, selections, gql.schema, gql.accountability, collection);
-    }
-    else {
-        if (collection.endsWith('_by_id') && collection in gql.schema.collections === false) {
-            collection = collection.slice(0, -6);
-        }
-        query = await getQuery(args, gql.schema, selections, info.variableValues, gql.accountability, collection);
-        if (collection.endsWith('_by_version') && collection in gql.schema.collections === false) {
-            collection = collection.slice(0, -11);
-            query.versionRaw = true;
-        }
-    }
-    // Transform count(a.b.c) into a.b.count(c)
-    if (query.fields?.length) {
-        for (let fieldIndex = 0; fieldIndex < query.fields.length; fieldIndex++) {
-            query.fields[fieldIndex] = parseFilterFunctionPath(query.fields[fieldIndex]);
-        }
-    }
-    const result = await gql.read(collection, query, args['id']);
-    if (args['id'])
-        return result;
-    /**
-     * Since grouped fields are returned at the top level, we duplicate those fields
-     * into the expected `group` property on the payload, excluding any non-group
-     * fields (i.e. aggregate keys).
-     *
-     * The payload can only contain grouped fields and aggregate keys, as the
-     * aggregate selection is restricted to those fields. Therefore, the original
-     * grouped fields can safely remain at the top level.
-     *
-     * We cannot iterate over `query.group`, because grouped fields that use
-     * functions are normalized (e.g. function(field) → function_field), which would
-     * result in them being skipped.
-     *
-     * Before:
-     * { year_date: 2023, count: { id: 42 } }
-     *
-     * After:
-     * { year_date: 2023, count: { id: 42 }, group: { year_date: 2023 } }
-     */
-    if (query.group) {
-        const aggregateKeys = Object.keys(query.aggregate ?? {});
-        result['map']((payload) => {
-            payload['group'] = omit(payload, aggregateKeys);
-        });
-    }
-    return result;
+* Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
+* Directus' query structure which is then executed by the services.
+*/
+async function resolveQuery(gql, info) {
+	let collection = info.fieldName;
+	if (gql.scope === "system") collection = `directus_${collection}`;
+	const selections = replaceFragmentsInSelections(info.fieldNodes[0]?.selectionSet?.selections, info.fragments);
+	if (!selections) return null;
+	const args = parseArgs(info.fieldNodes[0].arguments || [], info.variableValues);
+	let query;
+	const isAggregate = collection.endsWith("_aggregated") && collection in gql.schema.collections === false;
+	if (isAggregate) {
+		collection = collection.slice(0, -11);
+		query = await getAggregateQuery(args, selections, gql.schema, gql.accountability, collection);
+	} else {
+		if (collection.endsWith("_by_id") && collection in gql.schema.collections === false) {
+			collection = collection.slice(0, -6);
+		}
+		query = await getQuery(args, gql.schema, selections, info.variableValues, gql.accountability, collection);
+		if (collection.endsWith("_by_version") && collection in gql.schema.collections === false) {
+			collection = collection.slice(0, -11);
+			query.versionRaw = true;
+		}
+	}
+	if (query.fields?.length) {
+		for (let fieldIndex = 0; fieldIndex < query.fields.length; fieldIndex++) {
+			query.fields[fieldIndex] = parseFilterFunctionPath(query.fields[fieldIndex]);
+		}
+	}
+	const result = await gql.read(collection, query, args["id"]);
+	if (args["id"]) return result;
+	/**
+	* Since grouped fields are returned at the top level, we duplicate those fields
+	* into the expected `group` property on the payload, excluding any non-group
+	* fields (i.e. aggregate keys).
+	*
+	* The payload can only contain grouped fields and aggregate keys, as the
+	* aggregate selection is restricted to those fields. Therefore, the original
+	* grouped fields can safely remain at the top level.
+	*
+	* We cannot iterate over `query.group`, because grouped fields that use
+	* functions are normalized (e.g. function(field) → function_field), which would
+	* result in them being skipped.
+	*
+	* Before:
+	* { year_date: 2023, count: { id: 42 } }
+	*
+	* After:
+	* { year_date: 2023, count: { id: 42 }, group: { year_date: 2023 } }
+	*/
+	if (query.group) {
+		const aggregateKeys = Object.keys(query.aggregate ?? {});
+		result["map"]((payload) => {
+			payload["group"] = omit(payload, aggregateKeys);
+		});
+	}
+	return result;
 }
+
+//#endregion
+export { resolveQuery };