@directus/api 24.0.1 → 25.0.0

package/dist/services/graphql/schema/get-types.js

@@ -0,0 +1,223 @@
+import { GraphQLID, GraphQLInt, GraphQLNonNull, GraphQLScalarType, GraphQLUnionType } from 'graphql';
+import { GraphQLJSON, ObjectTypeComposer } from 'graphql-compose';
+import { mapKeys, pick } from 'lodash-es';
+import { GENERATE_SPECIAL } from '../../../constants.js';
+import { getGraphQLType } from '../../../utils/get-graphql-type.js';
+import {} from '../index.js';
+import { SYSTEM_DENY_LIST } from './index.js';
+/**
+ * Construct an object of types for every collection, using the permitted fields per action type
+ * as it's fields.
+ */
+export function getTypes(schemaComposer, scope, schema, inconsistentFields, action) {
+    const CollectionTypes = {};
+    const VersionTypes = {};
+    const CountFunctions = schemaComposer.createObjectTC({
+        name: 'count_functions',
+        fields: {
+            count: {
+                type: GraphQLInt,
+            },
+        },
+    });
+    const DateFunctions = schemaComposer.createObjectTC({
+        name: 'date_functions',
+        fields: {
+            year: {
+                type: GraphQLInt,
+            },
+            month: {
+                type: GraphQLInt,
+            },
+            week: {
+                type: GraphQLInt,
+            },
+            day: {
+                type: GraphQLInt,
+            },
+            weekday: {
+                type: GraphQLInt,
+            },
+        },
+    });
+    const TimeFunctions = schemaComposer.createObjectTC({
+        name: 'time_functions',
+        fields: {
+            hour: {
+                type: GraphQLInt,
+            },
+            minute: {
+                type: GraphQLInt,
+            },
+            second: {
+                type: GraphQLInt,
+            },
+        },
+    });
+    const DateTimeFunctions = schemaComposer.createObjectTC({
+        name: 'datetime_functions',
+        fields: {
+            ...DateFunctions.getFields(),
+            ...TimeFunctions.getFields(),
+        },
+    });
+    for (const collection of Object.values(schema[action].collections)) {
+        if (Object.keys(collection.fields).length === 0)
+            continue;
+        if (SYSTEM_DENY_LIST.includes(collection.collection))
+            continue;
+        CollectionTypes[collection.collection] = schemaComposer.createObjectTC({
+            name: action === 'read' ? collection.collection : `${action}_${collection.collection}`,
+            fields: Object.values(collection.fields).reduce((acc, field) => {
+                let type = getGraphQLType(field.type, field.special);
+                const fieldIsInconsistent = inconsistentFields[action][collection.collection]?.includes(field.field);
+                // GraphQL doesn't differentiate between not-null and has-to-be-submitted. We
+                // can't non-null in update, as that would require every not-nullable field to be
+                // submitted on updates
+                if (field.nullable === false &&
+                    !field.defaultValue &&
+                    !GENERATE_SPECIAL.some((flag) => field.special.includes(flag)) &&
+                    fieldIsInconsistent === false &&
+                    action !== 'update') {
+                    type = new GraphQLNonNull(type);
+                }
+                if (collection.primary === field.field && fieldIsInconsistent === false) {
+                    // permissions IDs need to be nullable https://github.com/directus/directus/issues/20509
+                    if (collection.collection === 'directus_permissions') {
+                        type = GraphQLID;
+                    }
+                    else if (!field.defaultValue && !field.special.includes('uuid') && action === 'create') {
+                        type = new GraphQLNonNull(GraphQLID);
+                    }
+                    else if (['create', 'update'].includes(action)) {
+                        type = GraphQLID;
+                    }
+                    else {
+                        type = new GraphQLNonNull(GraphQLID);
+                    }
+                }
+                acc[field.field] = {
+                    type,
+                    description: field.note,
+                    resolve: (obj) => {
+                        return obj[field.field];
+                    },
+                };
+                if (action === 'read') {
+                    if (field.type === 'date') {
+                        acc[`${field.field}_func`] = {
+                            type: DateFunctions,
+                            resolve: (obj) => {
+                                const funcFields = Object.keys(DateFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                return mapKeys(pick(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                            },
+                        };
+                    }
+                    if (field.type === 'time') {
+                        acc[`${field.field}_func`] = {
+                            type: TimeFunctions,
+                            resolve: (obj) => {
+                                const funcFields = Object.keys(TimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                return mapKeys(pick(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                            },
+                        };
+                    }
+                    if (field.type === 'dateTime' || field.type === 'timestamp') {
+                        acc[`${field.field}_func`] = {
+                            type: DateTimeFunctions,
+                            resolve: (obj) => {
+                                const funcFields = Object.keys(DateTimeFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                return mapKeys(pick(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                            },
+                        };
+                    }
+                    if (field.type === 'json' || field.type === 'alias') {
+                        acc[`${field.field}_func`] = {
+                            type: CountFunctions,
+                            resolve: (obj) => {
+                                const funcFields = Object.keys(CountFunctions.getFields()).map((key) => `${field.field}_${key}`);
+                                return mapKeys(pick(obj, funcFields), (_value, key) => key.substring(field.field.length + 1));
+                            },
+                        };
+                    }
+                }
+                return acc;
+            }, {}),
+        });
+        if (scope === 'items') {
+            VersionTypes[collection.collection] = CollectionTypes[collection.collection].clone(`version_${collection.collection}`);
+        }
+    }
+    for (const relation of schema[action].relations) {
+        if (relation.related_collection) {
+            if (SYSTEM_DENY_LIST.includes(relation.related_collection))
+                continue;
+            CollectionTypes[relation.collection]?.addFields({
+                [relation.field]: {
+                    type: CollectionTypes[relation.related_collection],
+                    resolve: (obj, _, __, info) => {
+                        return obj[info?.path?.key ?? relation.field];
+                    },
+                },
+            });
+            VersionTypes[relation.collection]?.addFields({
+                [relation.field]: {
+                    type: GraphQLJSON,
+                    resolve: (obj, _, __, info) => {
+                        return obj[info?.path?.key ?? relation.field];
+                    },
+                },
+            });
+            if (relation.meta?.one_field) {
+                CollectionTypes[relation.related_collection]?.addFields({
+                    [relation.meta.one_field]: {
+                        type: [CollectionTypes[relation.collection]],
+                        resolve: (obj, _, __, info) => {
+                            return obj[info?.path?.key ?? relation.meta.one_field];
+                        },
+                    },
+                });
+                if (scope === 'items') {
+                    VersionTypes[relation.related_collection]?.addFields({
+                        [relation.meta.one_field]: {
+                            type: GraphQLJSON,
+                            resolve: (obj, _, __, info) => {
+                                return obj[info?.path?.key ?? relation.meta.one_field];
+                            },
+                        },
+                    });
+                }
+            }
+        }
+        else if (relation.meta?.one_allowed_collections && action === 'read') {
+            // NOTE: There are no union input types in GraphQL, so context only applies to Read actions
+            CollectionTypes[relation.collection]?.addFields({
+                [relation.field]: {
+                    type: new GraphQLUnionType({
+                        name: `${relation.collection}_${relation.field}_union`,
+                        types: relation.meta.one_allowed_collections.map((collection) => CollectionTypes[collection].getType()),
+                        resolveType(_value, context, info) {
+                            let path = [];
+                            let currentPath = info.path;
+                            while (currentPath.prev) {
+                                path.push(currentPath.key);
+                                currentPath = currentPath.prev;
+                            }
+                            path = path.reverse().slice(0, -1);
+                            let parent = context['data'];
+                            for (const pathPart of path) {
+                                parent = parent[pathPart];
+                            }
+                            const collection = parent[relation.meta.one_collection_field];
+                            return CollectionTypes[collection].getType().name;
+                        },
+                    }),
+                    resolve: (obj, _, __, info) => {
+                        return obj[info?.path?.key ?? relation.field];
+                    },
+                },
+            });
+        }
+    }
+    return { CollectionTypes, VersionTypes };
+}

package/dist/services/graphql/schema/index.d.ts

@@ -0,0 +1,32 @@
+import type { SchemaOverview } from '@directus/types';
+import { GraphQLSchema } from 'graphql';
+import type { ObjectTypeComposer } from 'graphql-compose';
+import { type FieldMap } from '../../../permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
+import { GraphQLService } from '../index.js';
+export type Schema = {
+    read: SchemaOverview;
+    create: SchemaOverview;
+    update: SchemaOverview;
+    delete: SchemaOverview;
+};
+export type InconsistentFields = {
+    read: FieldMap;
+    create: FieldMap;
+    update: FieldMap;
+    delete: FieldMap;
+};
+export type CollectionTypes = {
+    CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    DeleteCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+};
+/**
+ * These should be ignored in the context of GraphQL, and/or are replaced by a custom resolver (for non-standard structures)
+ */
+export declare const SYSTEM_DENY_LIST: string[];
+export declare const READ_ONLY: string[];
+/**
+ * Generate the GraphQL schema. Pulls from the schema information generated by the get-schema util.
+ */
+export declare function generateSchema(gql: GraphQLService, type?: 'schema' | 'sdl'): Promise<GraphQLSchema | string>;

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

@@ -0,0 +1,190 @@
+import { useEnv } from '@directus/env';
+import { isSystemCollection } from '@directus/system-data';
+import { Semaphore } from 'async-mutex';
+import { GraphQLSchema } from 'graphql';
+import { SchemaComposer } from 'graphql-compose';
+import { fetchAllowedFieldMap, } from '../../../permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.js';
+import { fetchInconsistentFieldMap } from '../../../permissions/modules/fetch-inconsistent-field-map/fetch-inconsistent-field-map.js';
+import { reduceSchema } from '../../../utils/reduce-schema.js';
+import { GraphQLService } from '../index.js';
+import { injectSystemResolvers } from '../resolvers/system.js';
+import { cache } from '../schema-cache.js';
+import { GraphQLVoid } from '../types/void.js';
+import { sanitizeGraphqlSchema } from '../utils/sanitize-gql-schema.js';
+import { getReadableTypes } from './read.js';
+import { getWritableTypes } from './write.js';
+/**
+ * These should be ignored in the context of GraphQL, and/or are replaced by a custom resolver (for non-standard structures)
+ */
+export const SYSTEM_DENY_LIST = [
+    'directus_collections',
+    'directus_fields',
+    'directus_relations',
+    'directus_migrations',
+    'directus_sessions',
+    'directus_extensions',
+];
+export const READ_ONLY = ['directus_activity', 'directus_revisions'];
+const env = useEnv();
+const semaphore = new Semaphore(env['GRAPHQL_SCHEMA_GENERATION_MAX_CONCURRENT'] ?? 5);
+/**
+ * Generate the GraphQL schema. Pulls from the schema information generated by the get-schema util.
+ */
+export async function generateSchema(gql, type = 'schema') {
+    const key = `${gql.scope}_${type}_${gql.accountability?.role}_${gql.accountability?.user}`;
+    const cachedSchema = cache.get(key);
+    if (cachedSchema)
+        return cachedSchema;
+    return semaphore.runExclusive(async () => {
+        // Check the cache again after acquiring the lock
+        const cachedSchema = cache.get(key);
+        if (cachedSchema)
+            return cachedSchema;
+        const schemaComposer = new SchemaComposer();
+        let schema;
+        const sanitizedSchema = sanitizeGraphqlSchema(gql.schema);
+        if (!gql.accountability || gql.accountability.admin) {
+            schema = {
+                read: sanitizedSchema,
+                create: sanitizedSchema,
+                update: sanitizedSchema,
+                delete: sanitizedSchema,
+            };
+        }
+        else {
+            schema = {
+                read: reduceSchema(sanitizedSchema, await fetchAllowedFieldMap({
+                    accountability: gql.accountability,
+                    action: 'read',
+                }, { schema: gql.schema, knex: gql.knex })),
+                create: reduceSchema(sanitizedSchema, await fetchAllowedFieldMap({
+                    accountability: gql.accountability,
+                    action: 'create',
+                }, { schema: gql.schema, knex: gql.knex })),
+                update: reduceSchema(sanitizedSchema, await fetchAllowedFieldMap({
+                    accountability: gql.accountability,
+                    action: 'update',
+                }, { schema: gql.schema, knex: gql.knex })),
+                delete: reduceSchema(sanitizedSchema, await fetchAllowedFieldMap({
+                    accountability: gql.accountability,
+                    action: 'delete',
+                }, { schema: gql.schema, knex: gql.knex })),
+            };
+        }
+        const inconsistentFields = {
+            read: await fetchInconsistentFieldMap({
+                accountability: gql.accountability,
+                action: 'read',
+            }, { schema: gql.schema, knex: gql.knex }),
+            create: await fetchInconsistentFieldMap({
+                accountability: gql.accountability,
+                action: 'create',
+            }, { schema: gql.schema, knex: gql.knex }),
+            update: await fetchInconsistentFieldMap({
+                accountability: gql.accountability,
+                action: 'update',
+            }, { schema: gql.schema, knex: gql.knex }),
+            delete: await fetchInconsistentFieldMap({
+                accountability: gql.accountability,
+                action: 'delete',
+            }, { schema: gql.schema, knex: gql.knex }),
+        };
+        const { ReadCollectionTypes, VersionCollectionTypes } = getReadableTypes(gql, schemaComposer, schema, inconsistentFields);
+        const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadCollectionTypes);
+        const CollectionTypes = {
+            CreateCollectionTypes,
+            ReadCollectionTypes,
+            UpdateCollectionTypes,
+            DeleteCollectionTypes,
+        };
+        const scopeFilter = (collection) => {
+            if (gql.scope === 'items' && isSystemCollection(collection.collection))
+                return false;
+            if (gql.scope === 'system') {
+                if (isSystemCollection(collection.collection) === false)
+                    return false;
+                if (SYSTEM_DENY_LIST.includes(collection.collection))
+                    return false;
+            }
+            return true;
+        };
+        if (gql.scope === 'system') {
+            injectSystemResolvers(gql, schemaComposer, CollectionTypes, schema);
+        }
+        const readableCollections = Object.values(schema.read.collections)
+            .filter((collection) => collection.collection in ReadCollectionTypes)
+            .filter(scopeFilter);
+        if (readableCollections.length > 0) {
+            schemaComposer.Query.addFields(readableCollections.reduce((acc, collection) => {
+                const collectionName = gql.scope === 'items' ? collection.collection : collection.collection.substring(9);
+                acc[collectionName] = ReadCollectionTypes[collection.collection].getResolver(collection.collection);
+                if (gql.schema.collections[collection.collection].singleton === false) {
+                    acc[`${collectionName}_by_id`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_id`);
+                    acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
+                }
+                if (gql.scope === 'items') {
+                    acc[`${collectionName}_by_version`] = VersionCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_version`);
+                }
+                return acc;
+            }, {}));
+        }
+        else {
+            schemaComposer.Query.addFields({
+                _empty: {
+                    type: GraphQLVoid,
+                    description: "There's no data to query.",
+                },
+            });
+        }
+        if (Object.keys(schema.create.collections).length > 0) {
+            schemaComposer.Mutation.addFields(Object.values(schema.create.collections)
+                .filter((collection) => collection.collection in CreateCollectionTypes && collection.singleton === false)
+                .filter(scopeFilter)
+                .filter((collection) => READ_ONLY.includes(collection.collection) === false)
+                .reduce((acc, collection) => {
+                const collectionName = gql.scope === 'items' ? collection.collection : collection.collection.substring(9);
+                acc[`create_${collectionName}_items`] = CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_items`);
+                acc[`create_${collectionName}_item`] = CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_item`);
+                return acc;
+            }, {}));
+        }
+        if (Object.keys(schema.update.collections).length > 0) {
+            schemaComposer.Mutation.addFields(Object.values(schema.update.collections)
+                .filter((collection) => collection.collection in UpdateCollectionTypes)
+                .filter(scopeFilter)
+                .filter((collection) => READ_ONLY.includes(collection.collection) === false)
+                .reduce((acc, collection) => {
+                const collectionName = gql.scope === 'items' ? collection.collection : collection.collection.substring(9);
+                if (collection.singleton) {
+                    acc[`update_${collectionName}`] = UpdateCollectionTypes[collection.collection].getResolver(`update_${collection.collection}`);
+                }
+                else {
+                    acc[`update_${collectionName}_items`] = UpdateCollectionTypes[collection.collection].getResolver(`update_${collection.collection}_items`);
+                    acc[`update_${collectionName}_batch`] = UpdateCollectionTypes[collection.collection].getResolver(`update_${collection.collection}_batch`);
+                    acc[`update_${collectionName}_item`] = UpdateCollectionTypes[collection.collection].getResolver(`update_${collection.collection}_item`);
+                }
+                return acc;
+            }, {}));
+        }
+        if (Object.keys(schema.delete.collections).length > 0) {
+            schemaComposer.Mutation.addFields(Object.values(schema.delete.collections)
+                .filter((collection) => collection.singleton === false)
+                .filter(scopeFilter)
+                .filter((collection) => READ_ONLY.includes(collection.collection) === false)
+                .reduce((acc, collection) => {
+                const collectionName = gql.scope === 'items' ? collection.collection : collection.collection.substring(9);
+                acc[`delete_${collectionName}_items`] = DeleteCollectionTypes['many'].getResolver(`delete_${collection.collection}_items`);
+                acc[`delete_${collectionName}_item`] = DeleteCollectionTypes['one'].getResolver(`delete_${collection.collection}_item`);
+                return acc;
+            }, {}));
+        }
+        if (type === 'sdl') {
+            const sdl = schemaComposer.toSDL();
+            cache.set(key, sdl);
+            return sdl;
+        }
+        const gqlSchema = schemaComposer.buildSchema();
+        cache.set(key, gqlSchema);
+        return gqlSchema;
+    });
+}

package/dist/services/graphql/schema/parse-args.d.ts

@@ -0,0 +1,9 @@
+import type { ArgumentNode, GraphQLResolveInfo } from 'graphql';
+/**
+ * GraphQL's regular resolver `args` variable only contains the "top-level" arguments. Seeing that we convert the
+ * whole nested tree into one big query using Directus' own query resolver, we want to have a nested structure of
+ * arguments for the whole resolving tree, which can later be transformed into Directus' AST using `deep`.
+ * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
+ * of arguments
+ */
+export declare function parseArgs(args: readonly ArgumentNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;

package/dist/services/graphql/schema/parse-args.js

@@ -0,0 +1,35 @@
+/**
+ * GraphQL's regular resolver `args` variable only contains the "top-level" arguments. Seeing that we convert the
+ * whole nested tree into one big query using Directus' own query resolver, we want to have a nested structure of
+ * arguments for the whole resolving tree, which can later be transformed into Directus' AST using `deep`.
+ * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
+ * of arguments
+ */
+export function parseArgs(args, variableValues) {
+    if (!args || args['length'] === 0)
+        return {};
+    const parse = (node) => {
+        switch (node.kind) {
+            case 'Variable':
+                return variableValues[node.name.value];
+            case 'ListValue':
+                return node.values.map(parse);
+            case 'ObjectValue':
+                return Object.fromEntries(node.fields.map((node) => [node.name.value, parse(node.value)]));
+            case 'NullValue':
+                return null;
+            case 'StringValue':
+                return String(node.value);
+            case 'IntValue':
+            case 'FloatValue':
+                return Number(node.value);
+            case 'BooleanValue':
+                return Boolean(node.value);
+            case 'EnumValue':
+            default:
+                return 'value' in node ? node.value : null;
+        }
+    };
+    const argsObject = Object.fromEntries(args['map']((arg) => [arg.name.value, parse(arg.value)]));
+    return argsObject;
+}

package/dist/services/graphql/schema/parse-query.d.ts

@@ -0,0 +1,7 @@
+import type { Accountability, Query } from '@directus/types';
+import type { GraphQLResolveInfo, SelectionNode } from 'graphql';
+/**
+ * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
+ * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
+ */
+export declare function getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues'], accountability?: Accountability | null): Query;

package/dist/services/graphql/schema/parse-query.js

@@ -0,0 +1,98 @@
+import { get, mapKeys, merge, set, uniq } from 'lodash-es';
+import { sanitizeQuery } from '../../../utils/sanitize-query.js';
+import { validateQuery } from '../../../utils/validate-query.js';
+import { replaceFuncs } from '../utils/replace-funcs.js';
+import { parseArgs } from './parse-args.js';
+/**
+ * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
+ * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
+ */
+export function getQuery(rawQuery, selections, variableValues, accountability) {
+    const query = sanitizeQuery(rawQuery, accountability);
+    const parseAliases = (selections) => {
+        const aliases = {};
+        for (const selection of selections) {
+            if (selection.kind !== 'Field')
+                continue;
+            if (selection.alias?.value) {
+                aliases[selection.alias.value] = selection.name.value;
+            }
+        }
+        return aliases;
+    };
+    const parseFields = (selections, parent) => {
+        const fields = [];
+        for (let selection of selections) {
+            if ((selection.kind === 'Field' || selection.kind === 'InlineFragment') !== true)
+                continue;
+            selection = selection;
+            let current;
+            let currentAlias = null;
+            // Union type (Many-to-Any)
+            if (selection.kind === 'InlineFragment') {
+                if (selection.typeCondition.name.value.startsWith('__'))
+                    continue;
+                current = `${parent}:${selection.typeCondition.name.value}`;
+            }
+            // Any other field type
+            else {
+                // filter out graphql pointers, like __typename
+                if (selection.name.value.startsWith('__'))
+                    continue;
+                current = selection.name.value;
+                if (selection.alias) {
+                    currentAlias = selection.alias.value;
+                }
+                if (parent) {
+                    current = `${parent}.${current}`;
+                    if (currentAlias) {
+                        currentAlias = `${parent}.${currentAlias}`;
+                        // add nested aliases into deep query
+                        if (selection.selectionSet) {
+                            if (!query.deep)
+                                query.deep = {};
+                            set(query.deep, parent, merge({}, get(query.deep, parent), { _alias: { [selection.alias.value]: selection.name.value } }));
+                        }
+                    }
+                }
+            }
+            if (selection.selectionSet) {
+                let children;
+                if (current.endsWith('_func')) {
+                    children = [];
+                    const rootField = current.slice(0, -5);
+                    for (const subSelection of selection.selectionSet.selections) {
+                        if (subSelection.kind !== 'Field')
+                            continue;
+                        if (subSelection.name.value.startsWith('__'))
+                            continue;
+                        children.push(`${subSelection.name.value}(${rootField})`);
+                    }
+                }
+                else {
+                    children = parseFields(selection.selectionSet.selections, currentAlias ?? current);
+                }
+                fields.push(...children);
+            }
+            else {
+                fields.push(current);
+            }
+            if (selection.kind === 'Field' && selection.arguments && selection.arguments.length > 0) {
+                if (selection.arguments && selection.arguments.length > 0) {
+                    if (!query.deep)
+                        query.deep = {};
+                    const args = parseArgs(selection.arguments, variableValues);
+                    set(query.deep, currentAlias ?? current, merge({}, get(query.deep, currentAlias ?? current), mapKeys(sanitizeQuery(args, accountability), (_value, key) => `_${key}`)));
+                }
+            }
+        }
+        return uniq(fields);
+    };
+    query.alias = parseAliases(selections);
+    query.fields = parseFields(selections);
+    if (query.filter)
+        query.filter = replaceFuncs(query.filter);
+    query.deep = replaceFuncs(query.deep);
+    validateQuery(query);
+    return query;
+}

package/dist/services/graphql/schema/read.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaComposer } from 'graphql-compose';
+import { InputTypeComposer, ObjectTypeComposer } from 'graphql-compose';
+import { GraphQLService } from '../index.js';
+import { type InconsistentFields, type Schema } from './index.js';
+/**
+ * Create readable types and attach resolvers for each. Also prepares full filter argument structures
+ */
+export declare function getReadableTypes(gql: GraphQLService, schemaComposer: SchemaComposer, schema: Schema, inconsistentFields: InconsistentFields): {
+    ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    VersionCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    ReadableCollectionFilterTypes: Record<string, InputTypeComposer<any>>;
+};