@directus/api 25.0.0 → 26.0.0

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>;

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

@@ -1,11 +1,10 @@
 import { useEnv } from '@directus/env';
 import { toBoolean } from '@directus/utils';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
-import { GraphQLJSON, ObjectTypeComposer, SchemaComposer, toInputObjectType } from 'graphql-compose';
+import { GraphQLJSON, SchemaComposer, toInputObjectType } from 'graphql-compose';
 import getDatabase from '../../../database/index.js';
 import { fetchAccountabilityCollectionAccess } from '../../../permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.js';
 import { fetchAccountabilityPolicyGlobals } from '../../../permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.js';
-import { getGraphQLType } from '../../../utils/get-graphql-type.js';
 import { CollectionsService } from '../../collections.js';
 import { FieldsService } from '../../fields.js';
 import { FilesService } from '../../files.js';
@@ -18,6 +17,9 @@ import { GraphQLService } from '../index.js';
 import { generateSchema } from '../schema/index.js';
 import { getQuery } from '../schema/parse-query.js';
 import { replaceFragmentsInSelections } from '../utils/replace-fragments.js';
+import { getCollectionType } from './get-collection-type.js';
+import { getFieldType } from './get-field-type.js';
+import { getRelationType } from './get-relation-type.js';
 import { resolveSystemAdmin } from './system-admin.js';
 import { globalResolvers } from './system-global.js';
 const env = useEnv();
@@ -187,47 +189,8 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
             },
         },
     });
-    const Collection = schemaComposer.createObjectTC({
-        name: 'directus_collections',
-    });
-    const Field = schemaComposer.createObjectTC({
-        name: 'directus_fields',
-    });
-    const Relation = schemaComposer.createObjectTC({
-        name: 'directus_relations',
-    });
-    const Extension = schemaComposer.createObjectTC({
-        name: 'directus_extensions',
-    });
-    const composers = {
-        Collection,
-        Field,
-        Relation,
-        Extension,
-    };
     if ('directus_collections' in schema.read.collections) {
-        Collection.addFields({
-            collection: GraphQLString,
-            meta: schemaComposer.createObjectTC({
-                name: 'directus_collections_meta',
-                fields: Object.values(schema.read.collections['directus_collections'].fields).reduce((acc, field) => {
-                    acc[field.field] = {
-                        type: field.nullable
-                            ? getGraphQLType(field.type, field.special)
-                            : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
-                        description: field.note,
-                    };
-                    return acc;
-                }, {}),
-            }),
-            schema: schemaComposer.createObjectTC({
-                name: 'directus_collections_schema',
-                fields: {
-                    name: GraphQLString,
-                    comment: GraphQLString,
-                },
-            }),
-        });
+        const Collection = getCollectionType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             collections: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Collection.getType()))),
@@ -255,45 +218,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
         });
     }
     if ('directus_fields' in schema.read.collections) {
-        Field.addFields({
-            collection: GraphQLString,
-            field: GraphQLString,
-            type: GraphQLString,
-            meta: schemaComposer.createObjectTC({
-                name: 'directus_fields_meta',
-                fields: Object.values(schema.read.collections['directus_fields'].fields).reduce((acc, field) => {
-                    acc[field.field] = {
-                        type: field.nullable
-                            ? getGraphQLType(field.type, field.special)
-                            : new GraphQLNonNull(getGraphQLType(field.type, field.special)),
-                        description: field.note,
-                    };
-                    return acc;
-                }, {}),
-            }),
-            schema: schemaComposer.createObjectTC({
-                name: '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,
-                },
-            }),
-        });
+        const Field = getFieldType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             fields: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Field.getType()))),
@@ -335,33 +260,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
         });
     }
     if ('directus_relations' in schema.read.collections) {
-        Relation.addFields({
-            collection: GraphQLString,
-            field: GraphQLString,
-            related_collection: GraphQLString,
-            schema: schemaComposer.createObjectTC({
-                name: '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: '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;
-                }, {}),
-            }),
-        });
+        const Relation = getRelationType(schemaComposer, schema, 'read');
         schemaComposer.Query.addFields({
             relations: {
                 type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(Relation.getType()))),
@@ -402,7 +301,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
             },
         });
     }
-    resolveSystemAdmin(gql, schemaComposer, composers);
+    resolveSystemAdmin(gql, schema, schemaComposer);
     if ('directus_users' in schema.read.collections) {
         schemaComposer.Query.addFields({
             users_me: {
@@ -412,7 +311,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                         return null;
                     const service = new UsersService({ schema: gql.schema, accountability: gql.accountability });
                     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);
                     return await service.readOne(gql.accountability.user, query);
                 },
             },
@@ -450,7 +349,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                         schema: gql.schema,
                     });
                     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);
                     query.limit = -1;
                     const roles = await service.readMany(gql.accountability.roles, query);
                     return roles;
@@ -498,7 +397,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                     await service.updateOne(gql.accountability.user, args['data']);
                     if ('directus_users' in ReadCollectionTypes) {
                         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);
                         return await service.readOne(gql.accountability.user, query);
                     }
                     return true;
@@ -522,7 +421,7 @@ export function injectSystemResolvers(gql, schemaComposer, { CreateCollectionTyp
                     const primaryKey = await service.importOne(args['url'], args['data']);
                     if ('directus_files' in ReadCollectionTypes) {
                         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);
                         return await service.readOne(primaryKey, query);
                     }
                     return true;

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

@@ -89,7 +89,7 @@ export async function generateSchema(gql, type = 'schema') {
                 action: 'delete',
             }, { schema: gql.schema, knex: gql.knex }),
         };
-        const { ReadCollectionTypes, VersionCollectionTypes } = getReadableTypes(gql, schemaComposer, schema, inconsistentFields);
+        const { ReadCollectionTypes, VersionCollectionTypes } = await getReadableTypes(gql, schemaComposer, schema, inconsistentFields);
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadCollectionTypes);
         const CollectionTypes = {
             CreateCollectionTypes,