@directus/api 24.0.1 → 25.0.0

package/dist/services/graphql/resolvers/mutation.d.ts

@@ -0,0 +1,4 @@
+import type { Item } from '@directus/types';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLService } from '../index.js';
+export declare function resolveMutation(gql: GraphQLService, args: Record<string, any>, info: GraphQLResolveInfo): Promise<Partial<Item> | boolean | undefined>;

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

@@ -0,0 +1,74 @@
+import { getService } from '../../../utils/get-service.js';
+import { formatError } from '../errors/format.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
+import { getQuery } from '../schema/parse-query.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 = getQuery(args, selections || [], info.variableValues, gql.accountability);
+    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);
+    }
+}

package/dist/services/graphql/resolvers/query.d.ts

@@ -0,0 +1,8 @@
+import type { Item } from '@directus/types';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLService } from '../index.js';
+/**
+ * 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 declare function resolveQuery(gql: GraphQLService, info: GraphQLResolveInfo): Promise<Partial<Item> | null>;

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

@@ -0,0 +1,87 @@
+import { parseFilterFunctionPath } from '@directus/utils';
+import { omit } from 'lodash-es';
+import { mergeVersionsRaw, mergeVersionsRecursive } from '../../../utils/merge-version-data.js';
+import { VersionsService } from '../../versions.js';
+import { getAggregateQuery } from '../utils/aggrgate-query.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
+import { parseArgs } from '../schema/parse-args.js';
+import { getQuery } from '../schema/parse-query.js';
+/**
+ * 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;
+    let versionRaw = false;
+    const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
+    if (isAggregate) {
+        query = getAggregateQuery(args, selections, gql.accountability);
+        collection = collection.slice(0, -11);
+    }
+    else {
+        query = getQuery(args, selections, info.variableValues, gql.accountability);
+        if (collection.endsWith('_by_id') && collection in gql.schema.collections === false) {
+            collection = collection.slice(0, -6);
+        }
+        if (collection.endsWith('_by_version') && collection in gql.schema.collections === false) {
+            collection = collection.slice(0, -11);
+            versionRaw = true;
+        }
+    }
+    if (args['id']) {
+        query.filter = {
+            _and: [
+                query.filter || {},
+                {
+                    [gql.schema.collections[collection].primary]: {
+                        _eq: args['id'],
+                    },
+                },
+            ],
+        };
+        query.limit = 1;
+    }
+    // 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);
+    if (args['version']) {
+        const versionsService = new VersionsService({ accountability: gql.accountability, schema: gql.schema });
+        const saves = await versionsService.getVersionSaves(args['version'], collection, args['id']);
+        if (saves) {
+            if (gql.schema.collections[collection].singleton) {
+                return versionRaw
+                    ? mergeVersionsRaw(result, saves)
+                    : mergeVersionsRecursive(result, saves, collection, gql.schema);
+            }
+            else {
+                if (result?.[0] === undefined)
+                    return null;
+                return versionRaw
+                    ? mergeVersionsRaw(result[0], saves)
+                    : mergeVersionsRecursive(result[0], saves, collection, gql.schema);
+            }
+        }
+    }
+    if (args['id']) {
+        return result?.[0] || null;
+    }
+    if (query.group) {
+        // for every entry in result add a group field based on query.group;
+        const aggregateKeys = Object.keys(query.aggregate ?? {});
+        result['map']((field) => {
+            field['group'] = omit(field, aggregateKeys);
+        });
+    }
+    return result;
+}

package/dist/services/graphql/resolvers/system-admin.d.ts

@@ -0,0 +1,5 @@
+import { SchemaComposer } from 'graphql-compose';
+import type { GraphQLParams } from '../../../types/index.js';
+import { GraphQLService } from '../index.js';
+import type { BaseTypeComposers } from './system.js';
+export declare function resolveSystemAdmin(gql: GraphQLService, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { Collection, Field, Relation, Extension }: BaseTypeComposers): void;

package/dist/services/graphql/resolvers/system-admin.js

@@ -0,0 +1,236 @@
+import { GraphQLBoolean, GraphQLID, GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql';
+import { SchemaComposer, toInputObjectType } from 'graphql-compose';
+import { CollectionsService } from '../../collections.js';
+import { ExtensionsService } from '../../extensions.js';
+import { FieldsService } from '../../fields.js';
+import { RelationsService } from '../../relations.js';
+import { GraphQLService } from '../index.js';
+export function resolveSystemAdmin(gql, schemaComposer, { Collection, Field, Relation, Extension }) {
+    if (gql.accountability?.admin === true) {
+        schemaComposer.Mutation.addFields({
+            create_collections_item: {
+                type: Collection,
+                args: {
+                    data: toInputObjectType(Collection.clone('create_directus_collections'), {
+                        postfix: '_input',
+                    }).addFields({
+                        fields: [
+                            toInputObjectType(Field.clone('create_directus_collections_fields'), { postfix: '_input' }).NonNull,
+                        ],
+                    }).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const collectionsService = new CollectionsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    const collectionKey = await collectionsService.createOne(args['data']);
+                    return await collectionsService.readOne(collectionKey);
+                },
+            },
+            update_collections_item: {
+                type: Collection,
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    data: toInputObjectType(Collection.clone('update_directus_collections'), {
+                        postfix: '_input',
+                    }).removeField(['collection', 'schema']).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const collectionsService = new CollectionsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    const collectionKey = await collectionsService.updateOne(args['collection'], args['data']);
+                    return await collectionsService.readOne(collectionKey);
+                },
+            },
+            delete_collections_item: {
+                type: schemaComposer.createObjectTC({
+                    name: 'delete_collection',
+                    fields: {
+                        collection: GraphQLString,
+                    },
+                }),
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                },
+                resolve: async (_, args) => {
+                    const collectionsService = new CollectionsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await collectionsService.deleteOne(args['collection']);
+                    return { collection: args['collection'] };
+                },
+            },
+        });
+        schemaComposer.Mutation.addFields({
+            create_fields_item: {
+                type: Field,
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    data: toInputObjectType(Field.clone('create_directus_fields'), { postfix: '_input' }).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const service = new FieldsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await service.createField(args['collection'], args['data']);
+                    return await service.readOne(args['collection'], args['data'].field);
+                },
+            },
+            update_fields_item: {
+                type: Field,
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    field: new GraphQLNonNull(GraphQLString),
+                    data: toInputObjectType(Field.clone('update_directus_fields'), { postfix: '_input' }).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const service = new FieldsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await service.updateField(args['collection'], {
+                        ...args['data'],
+                        field: args['field'],
+                    });
+                    return await service.readOne(args['collection'], args['data'].field);
+                },
+            },
+            delete_fields_item: {
+                type: schemaComposer.createObjectTC({
+                    name: 'delete_field',
+                    fields: {
+                        collection: GraphQLString,
+                        field: GraphQLString,
+                    },
+                }),
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    field: new GraphQLNonNull(GraphQLString),
+                },
+                resolve: async (_, args) => {
+                    const service = new FieldsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await service.deleteField(args['collection'], args['field']);
+                    const { collection, field } = args;
+                    return { collection, field };
+                },
+            },
+        });
+        schemaComposer.Mutation.addFields({
+            create_relations_item: {
+                type: Relation,
+                args: {
+                    data: toInputObjectType(Relation.clone('create_directus_relations'), { postfix: '_input' }).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const relationsService = new RelationsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await relationsService.createOne(args['data']);
+                    return await relationsService.readOne(args['data'].collection, args['data'].field);
+                },
+            },
+            update_relations_item: {
+                type: Relation,
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    field: new GraphQLNonNull(GraphQLString),
+                    data: toInputObjectType(Relation.clone('update_directus_relations'), { postfix: '_input' }).NonNull,
+                },
+                resolve: async (_, args) => {
+                    const relationsService = new RelationsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await relationsService.updateOne(args['collection'], args['field'], args['data']);
+                    return await relationsService.readOne(args['data'].collection, args['data'].field);
+                },
+            },
+            delete_relations_item: {
+                type: schemaComposer.createObjectTC({
+                    name: 'delete_relation',
+                    fields: {
+                        collection: GraphQLString,
+                        field: GraphQLString,
+                    },
+                }),
+                args: {
+                    collection: new GraphQLNonNull(GraphQLString),
+                    field: new GraphQLNonNull(GraphQLString),
+                },
+                resolve: async (_, args) => {
+                    const relationsService = new RelationsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await relationsService.deleteOne(args['collection'], args['field']);
+                    return { collection: args['collection'], field: args['field'] };
+                },
+            },
+        });
+        Extension.addFields({
+            bundle: GraphQLString,
+            name: new GraphQLNonNull(GraphQLString),
+            schema: schemaComposer.createObjectTC({
+                name: 'directus_extensions_schema',
+                fields: {
+                    type: GraphQLString,
+                    local: GraphQLBoolean,
+                },
+            }),
+            meta: schemaComposer.createObjectTC({
+                name: 'directus_extensions_meta',
+                fields: {
+                    enabled: GraphQLBoolean,
+                },
+            }),
+        });
+        schemaComposer.Query.addFields({
+            extensions: {
+                type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Extension.getType()))),
+                resolve: async () => {
+                    const service = new ExtensionsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    return await service.readAll();
+                },
+            },
+        });
+        schemaComposer.Mutation.addFields({
+            update_extensions_item: {
+                type: Extension,
+                args: {
+                    id: GraphQLID,
+                    data: toInputObjectType(schemaComposer.createObjectTC({
+                        name: 'update_directus_extensions_input',
+                        fields: {
+                            meta: schemaComposer.createObjectTC({
+                                name: 'update_directus_extensions_input_meta',
+                                fields: {
+                                    enabled: GraphQLBoolean,
+                                },
+                            }),
+                        },
+                    })),
+                },
+                resolve: async (_, args) => {
+                    const extensionsService = new ExtensionsService({
+                        accountability: gql.accountability,
+                        schema: gql.schema,
+                    });
+                    await extensionsService.updateOne(args['id'], args['data']);
+                    return await extensionsService.readOne(args['id']);
+                },
+            },
+        });
+    }
+}

package/dist/services/graphql/resolvers/system-global.d.ts

@@ -0,0 +1,7 @@
+import { SchemaComposer } from 'graphql-compose';
+import type { GraphQLParams } from '../../../types/index.js';
+import { GraphQLService } from '../index.js';
+/**
+ * Globally available mutations
+ */
+export declare function globalResolvers(gql: GraphQLService, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>): void;