@directus/api 25.0.1 → 26.0.1

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

@@ -0,0 +1,51 @@
+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;
+}

package/dist/services/graphql/resolvers/get-relation-type.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaComposer } from 'graphql-compose';
+import type { Schema } from '../schema/index.js';
+export declare function getRelationType(schemaComposer: SchemaComposer, schema: Schema, action: 'read' | 'write'): import("graphql-compose").ObjectTypeComposer<any, any>;

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

@@ -0,0 +1,39 @@
+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;
+}

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

@@ -8,7 +8,7 @@ export async function resolveMutation(gql, args, info) {
     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 query = await getQuery(args, selections || [], info.variableValues, gql.schema, gql.accountability);
     const singleton = collection.endsWith('_batch') === false &&
         collection.endsWith('_items') === false &&
         collection.endsWith('_item') === false &&

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

@@ -2,10 +2,10 @@ 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';
+import { getAggregateQuery } from '../utils/aggregate-query.js';
+import { replaceFragmentsInSelections } from '../utils/replace-fragments.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.
@@ -22,11 +22,11 @@ export async function resolveQuery(gql, info) {
     let versionRaw = false;
     const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
     if (isAggregate) {
-        query = getAggregateQuery(args, selections, gql.accountability);
+        query = await getAggregateQuery(args, selections, gql.schema, gql.accountability);
         collection = collection.slice(0, -11);
     }
     else {
-        query = getQuery(args, selections, info.variableValues, gql.accountability);
+        query = await getQuery(args, selections, info.variableValues, gql.schema, gql.accountability);
         if (collection.endsWith('_by_id') && collection in gql.schema.collections === false) {
             collection = collection.slice(0, -6);
         }

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

@@ -1,5 +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;
+import type { Schema } from '../schema/index.js';
+export declare function resolveSystemAdmin(gql: GraphQLService, schema: Schema, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>): void;

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

@@ -5,178 +5,186 @@ 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);
-                },
+import { getFieldType } from './get-field-type.js';
+import { getRelationType } from './get-relation-type.js';
+import { getCollectionType } from './get-collection-type.js';
+export function resolveSystemAdmin(gql, schema, schemaComposer) {
+    if (!gql.accountability?.admin) {
+        return;
+    }
+    const Collection = getCollectionType(schemaComposer, schema, 'write');
+    const Field = getFieldType(schemaComposer, schema, 'write');
+    const Relation = getRelationType(schemaComposer, schema, 'write');
+    schemaComposer.Mutation.addFields({
+        create_collections_item: {
+            type: Collection,
+            args: {
+                data: toInputObjectType(Collection, {
+                    postfix: '_input',
+                }).addFields({
+                    fields: [toInputObjectType(Field, { postfix: '_input' }).NonNull],
+                }).NonNull,
             },
-            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);
-                },
+            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);
             },
-            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'] };
-                },
+        },
+        update_collections_item: {
+            type: Collection,
+            args: {
+                collection: new GraphQLNonNull(GraphQLString),
+                data: toInputObjectType(Collection, {
+                    postfix: '_input',
+                }).removeField(['collection', 'schema']).NonNull,
             },
-        });
-        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);
-                },
+            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);
             },
-            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_collections_item: {
+            type: schemaComposer.createObjectTC({
+                name: 'delete_collection',
+                fields: {
+                    collection: GraphQLString,
                 },
+            }),
+            args: {
+                collection: new GraphQLNonNull(GraphQLString),
             },
-            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 };
-                },
+            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_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);
-                },
+        },
+    });
+    schemaComposer.Mutation.addFields({
+        create_fields_item: {
+            type: Field,
+            args: {
+                collection: new GraphQLNonNull(GraphQLString),
+                data: toInputObjectType(Field, { postfix: '_input' }).NonNull,
             },
-            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);
-                },
+            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);
             },
-            delete_relations_item: {
-                type: schemaComposer.createObjectTC({
-                    name: 'delete_relation',
-                    fields: {
-                        collection: GraphQLString,
-                        field: GraphQLString,
-                    },
-                }),
-                args: {
-                    collection: new GraphQLNonNull(GraphQLString),
-                    field: new GraphQLNonNull(GraphQLString),
+        },
+        update_fields_item: {
+            type: Field,
+            args: {
+                collection: new GraphQLNonNull(GraphQLString),
+                field: new GraphQLNonNull(GraphQLString),
+                data: toInputObjectType(Field, { 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,
                 },
-                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'] };
+            }),
+            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, { 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, { 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),
             },
-        });
-        Extension.addFields({
+            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'] };
+            },
+        },
+    });
+    const Extension = schemaComposer.createObjectTC({
+        name: 'directus_extensions',
+        fields: {
             bundle: GraphQLString,
             name: new GraphQLNonNull(GraphQLString),
             schema: schemaComposer.createObjectTC({
@@ -192,45 +200,45 @@ export function resolveSystemAdmin(gql, schemaComposer, { Collection, Field, Rel
                     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.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']);
-                },
+        },
+    });
+    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.d.ts

@@ -1,11 +1,5 @@
-import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+import { SchemaComposer } from 'graphql-compose';
 import type { GraphQLParams } from '../../../types/index.js';
 import { GraphQLService } from '../index.js';
 import { type CollectionTypes, type Schema } from '../schema/index.js';
-export type BaseTypeComposers = {
-    Collection: ObjectTypeComposer<any, any>;
-    Field: ObjectTypeComposer<any, any>;
-    Relation: ObjectTypeComposer<any, any>;
-    Extension: ObjectTypeComposer<any, any>;
-};
 export declare function injectSystemResolvers(gql: GraphQLService, schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes }: CollectionTypes, schema: Schema): SchemaComposer<any>;