@directus/api 24.0.1 → 25.0.0

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

@@ -0,0 +1,142 @@
+import { GraphQLBoolean, GraphQLID, GraphQLList, GraphQLNonNull } from 'graphql';
+import { ObjectTypeComposer, toInputObjectType } from 'graphql-compose';
+import { GraphQLService } from '../index.js';
+import { resolveMutation } from '../resolvers/mutation.js';
+import { getTypes } from './get-types.js';
+import { SYSTEM_DENY_LIST } from './index.js';
+export function getWritableTypes(gql, schemaComposer, schema, inconsistentFields, ReadCollectionTypes) {
+    const { CollectionTypes: CreateCollectionTypes } = getTypes(schemaComposer, gql.scope, schema, inconsistentFields, 'create');
+    const { CollectionTypes: UpdateCollectionTypes } = getTypes(schemaComposer, gql.scope, schema, inconsistentFields, 'update');
+    const DeleteCollectionTypes = {};
+    for (const collection of Object.values(schema.create.collections)) {
+        if (Object.keys(collection.fields).length === 0)
+            continue;
+        if (SYSTEM_DENY_LIST.includes(collection.collection))
+            continue;
+        if (collection.collection in CreateCollectionTypes === false)
+            continue;
+        const collectionIsReadable = collection.collection in ReadCollectionTypes;
+        const creatableFields = CreateCollectionTypes[collection.collection]?.getFields() || {};
+        if (Object.keys(creatableFields).length > 0) {
+            const resolverDefinition = {
+                name: `create_${collection.collection}_items`,
+                type: collectionIsReadable
+                    ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType())))
+                    : GraphQLBoolean,
+                resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+            };
+            if (collectionIsReadable) {
+                resolverDefinition.args = ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs();
+            }
+            CreateCollectionTypes[collection.collection].addResolver(resolverDefinition);
+            CreateCollectionTypes[collection.collection].addResolver({
+                name: `create_${collection.collection}_item`,
+                type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
+                resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+            });
+            CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_items`).addArgs({
+                ...CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_items`).getArgs(),
+                data: [
+                    toInputObjectType(CreateCollectionTypes[collection.collection]).setTypeName(`create_${collection.collection}_input`).NonNull,
+                ],
+            });
+            CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_item`).addArgs({
+                ...CreateCollectionTypes[collection.collection].getResolver(`create_${collection.collection}_item`).getArgs(),
+                data: toInputObjectType(CreateCollectionTypes[collection.collection]).setTypeName(`create_${collection.collection}_input`).NonNull,
+            });
+        }
+    }
+    for (const collection of Object.values(schema.update.collections)) {
+        if (Object.keys(collection.fields).length === 0)
+            continue;
+        if (SYSTEM_DENY_LIST.includes(collection.collection))
+            continue;
+        if (collection.collection in UpdateCollectionTypes === false)
+            continue;
+        const collectionIsReadable = collection.collection in ReadCollectionTypes;
+        const updatableFields = UpdateCollectionTypes[collection.collection]?.getFields() || {};
+        if (Object.keys(updatableFields).length > 0) {
+            if (collection.singleton) {
+                UpdateCollectionTypes[collection.collection].addResolver({
+                    name: `update_${collection.collection}`,
+                    type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
+                    args: {
+                        data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull,
+                    },
+                    resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+                });
+            }
+            else {
+                UpdateCollectionTypes[collection.collection].addResolver({
+                    name: `update_${collection.collection}_batch`,
+                    type: collectionIsReadable
+                        ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType())))
+                        : GraphQLBoolean,
+                    args: {
+                        ...(collectionIsReadable
+                            ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs()
+                            : {}),
+                        data: [
+                            toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull,
+                        ],
+                    },
+                    resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+                });
+                UpdateCollectionTypes[collection.collection].addResolver({
+                    name: `update_${collection.collection}_items`,
+                    type: collectionIsReadable
+                        ? new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ReadCollectionTypes[collection.collection].getType())))
+                        : GraphQLBoolean,
+                    args: {
+                        ...(collectionIsReadable
+                            ? ReadCollectionTypes[collection.collection].getResolver(collection.collection).getArgs()
+                            : {}),
+                        ids: new GraphQLNonNull(new GraphQLList(GraphQLID)),
+                        data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull,
+                    },
+                    resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+                });
+                UpdateCollectionTypes[collection.collection].addResolver({
+                    name: `update_${collection.collection}_item`,
+                    type: collectionIsReadable ? ReadCollectionTypes[collection.collection] : GraphQLBoolean,
+                    args: {
+                        id: new GraphQLNonNull(GraphQLID),
+                        data: toInputObjectType(UpdateCollectionTypes[collection.collection]).setTypeName(`update_${collection.collection}_input`).NonNull,
+                    },
+                    resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+                });
+            }
+        }
+    }
+    DeleteCollectionTypes['many'] = schemaComposer.createObjectTC({
+        name: `delete_many`,
+        fields: {
+            ids: new GraphQLNonNull(new GraphQLList(GraphQLID)),
+        },
+    });
+    DeleteCollectionTypes['one'] = schemaComposer.createObjectTC({
+        name: `delete_one`,
+        fields: {
+            id: new GraphQLNonNull(GraphQLID),
+        },
+    });
+    for (const collection of Object.values(schema.delete.collections)) {
+        DeleteCollectionTypes['many'].addResolver({
+            name: `delete_${collection.collection}_items`,
+            type: DeleteCollectionTypes['many'],
+            args: {
+                ids: new GraphQLNonNull(new GraphQLList(GraphQLID)),
+            },
+            resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+        });
+        DeleteCollectionTypes['one'].addResolver({
+            name: `delete_${collection.collection}_item`,
+            type: DeleteCollectionTypes['one'],
+            args: {
+                id: new GraphQLNonNull(GraphQLID),
+            },
+            resolve: async ({ args, info }) => await resolveMutation(gql, args, info),
+        });
+    }
+    return { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes };
+}

package/dist/services/graphql/subscription.d.ts

@@ -1,7 +1,7 @@
 import type { GraphQLService } from './index.js';
 import type { GraphQLResolveInfo } from 'graphql';
 export declare function bindPubSub(): void;
-export declare function createSubscriptionGenerator(self: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
+export declare function createSubscriptionGenerator(gql: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
     [x: string]: {
         key: string | number;
         data: null;

package/dist/services/graphql/subscription.js

@@ -2,6 +2,7 @@ import { EventEmitter, on } from 'events';
 import { useBus } from '../../bus/index.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { getPayload } from '../../websocket/utils/items.js';
+import { getQuery } from './schema/parse-query.js';
 const messages = createPubSub(new EventEmitter());
 export function bindPubSub() {
     const messenger = useBus();
@@ -9,9 +10,9 @@ export function bindPubSub() {
         messages.publish(`${message['collection']}_mutated`, message);
     });
 }
-export function createSubscriptionGenerator(self, event) {
+export function createSubscriptionGenerator(gql, event) {
     return async function* (_x, _y, _z, request) {
-        const fields = parseFields(self, request);
+        const fields = parseFields(gql, request);
         const args = parseArguments(request);
         for await (const payload of messages.subscribe(event)) {
             const eventData = payload;
@@ -33,7 +34,7 @@ export function createSubscriptionGenerator(self, event) {
             if (eventData['action'] === 'create') {
                 try {
                     subscription.item = eventData['key'];
-                    const result = await getPayload(subscription, self.accountability, schema, eventData);
+                    const result = await getPayload(subscription, gql.accountability, schema, eventData);
                     yield {
                         [event]: {
                             key: eventData['key'],
@@ -50,7 +51,7 @@ export function createSubscriptionGenerator(self, event) {
                 for (const key of eventData['keys']) {
                     try {
                         subscription.item = key;
-                        const result = await getPayload(subscription, self.accountability, schema, eventData);
+                        const result = await getPayload(subscription, gql.accountability, schema, eventData);
                         yield {
                             [event]: {
                                 key,
@@ -78,7 +79,7 @@ function createPubSub(emitter) {
         },
     };
 }
-function parseFields(service, request) {
+function parseFields(gql, request) {
     const selections = request.fieldNodes[0]?.selectionSet?.selections ?? [];
     const dataSelections = selections.reduce((result, selection) => {
         if (selection.kind === 'Field' &&
@@ -88,7 +89,7 @@ function parseFields(service, request) {
         }
         return result;
     }, []);
-    const { fields } = service.getQuery({}, dataSelections, request.variableValues);
+    const { fields } = getQuery({}, dataSelections, request.variableValues, gql.accountability);
     return fields ?? [];
 }
 function parseArguments(request) {

package/dist/services/graphql/utils/aggrgate-query.d.ts

@@ -0,0 +1,6 @@
+import type { Accountability, Query } from '@directus/types';
+import type { SelectionNode } from 'graphql';
+/**
+ * Resolve the aggregation query based on the requested aggregated fields
+ */
+export declare function getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[], accountability?: Accountability | null): Query;

package/dist/services/graphql/utils/aggrgate-query.js

@@ -0,0 +1,32 @@
+import { replaceFuncs } from './replace-funcs.js';
+import { sanitizeQuery } from '../../../utils/sanitize-query.js';
+import { validateQuery } from '../../../utils/validate-query.js';
+/**
+ * Resolve the aggregation query based on the requested aggregated fields
+ */
+export function getAggregateQuery(rawQuery, selections, accountability) {
+    const query = sanitizeQuery(rawQuery, accountability);
+    query.aggregate = {};
+    for (let aggregationGroup of selections) {
+        if ((aggregationGroup.kind === 'Field') !== true)
+            continue;
+        aggregationGroup = aggregationGroup;
+        // filter out graphql pointers, like __typename
+        if (aggregationGroup.name.value.startsWith('__'))
+            continue;
+        const aggregateProperty = aggregationGroup.name.value;
+        query.aggregate[aggregateProperty] =
+            aggregationGroup.selectionSet?.selections
+                // filter out graphql pointers, like __typename
+                .filter((selectionNode) => !selectionNode?.name.value.startsWith('__'))
+                .map((selectionNode) => {
+                selectionNode = selectionNode;
+                return selectionNode.name.value;
+            }) ?? [];
+    }
+    if (query.filter) {
+        query.filter = replaceFuncs(query.filter);
+    }
+    validateQuery(query);
+    return query;
+}

package/dist/services/graphql/utils/replace-fragments.d.ts

@@ -0,0 +1,6 @@
+import type { FragmentDefinitionNode, SelectionNode } from 'graphql';
+/**
+ * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
+ * Effectively merges the selections with the fragments used in those selections
+ */
+export declare function replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;

package/dist/services/graphql/utils/replace-fragments.js

@@ -0,0 +1,21 @@
+import { flatten } from 'lodash-es';
+/**
+ * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
+ * Effectively merges the selections with the fragments used in those selections
+ */
+export function replaceFragmentsInSelections(selections, fragments) {
+    if (!selections)
+        return null;
+    const result = flatten(selections.map((selection) => {
+        // Fragments can contains fragments themselves. This allows for nested fragments
+        if (selection.kind === 'FragmentSpread') {
+            return replaceFragmentsInSelections(fragments[selection.name.value].selectionSet.selections, fragments);
+        }
+        // Nested relational fields can also contain fragments
+        if ((selection.kind === 'Field' || selection.kind === 'InlineFragment') && selection.selectionSet) {
+            selection.selectionSet.selections = replaceFragmentsInSelections(selection.selectionSet.selections, fragments);
+        }
+        return selection;
+    })).filter((s) => s);
+    return result;
+}

package/dist/services/graphql/utils/replace-funcs.d.ts

@@ -0,0 +1,5 @@
+import type { Filter } from '@directus/types';
+/**
+ * Replace functions from GraphQL format to Directus-Filter format
+ */
+export declare function replaceFuncs(filter: Filter): Filter;

package/dist/services/graphql/utils/replace-funcs.js

@@ -0,0 +1,21 @@
+import { FUNCTIONS } from '@directus/constants';
+import { transform } from 'lodash-es';
+/**
+ * Replace functions from GraphQL format to Directus-Filter format
+ */
+export function replaceFuncs(filter) {
+    return replaceFuncDeep(filter);
+    function replaceFuncDeep(filter) {
+        return transform(filter, (result, value, key) => {
+            const isFunctionKey = typeof key === 'string' && key.endsWith('_func') && FUNCTIONS.includes(Object.keys(value)[0]);
+            if (isFunctionKey) {
+                const functionName = Object.keys(value)[0];
+                const fieldName = key.slice(0, -5);
+                result[`${functionName}(${fieldName})`] = Object.values(value)[0];
+            }
+            else {
+                result[key] = value?.constructor === Object || value?.constructor === Array ? replaceFuncDeep(value) : value;
+            }
+        });
+    }
+}

package/dist/services/graphql/utils/sanitize-gql-schema.d.ts

@@ -5,4 +5,4 @@ import type { SchemaOverview } from '@directus/types';
  * @param schema
  * @returns sanitized schema
  */
-export declare function sanitizeGraphqlSchema(schema: SchemaOverview): SchemaOverview;
+export declare function sanitizeGraphqlSchema(schema: Readonly<SchemaOverview>): SchemaOverview;

package/dist/services/graphql/utils/sanitize-gql-schema.js

@@ -36,7 +36,7 @@ const GRAPHQL_RESERVED_NAMES = [
  */
 export function sanitizeGraphqlSchema(schema) {
     const logger = useLogger();
-    const collections = Object.entries(schema.collections).filter(([collectionName, _data]) => {
+    const collectionEntries = Object.entries(schema.collections).filter(([collectionName, _data]) => {
         // double underscore __ is reserved for GraphQL introspection
         if (collectionName.startsWith('__') || !collectionName.match(GRAPHQL_NAME_REGEX)) {
             logger.warn(`GraphQL skipping collection "${collectionName}" because it is not a valid name matching /^[_A-Za-z][_0-9A-Za-z]*$/ or starts with __`);
@@ -48,14 +48,14 @@ export function sanitizeGraphqlSchema(schema) {
         }
         return true;
     });
-    schema.collections = Object.fromEntries(collections);
-    const collectionExists = (collection) => Boolean(schema.collections[collection]);
+    const collections = Object.fromEntries(collectionEntries);
+    const collectionExists = (collection) => Boolean(collections[collection]);
     const skipRelation = (relation) => {
         const relationName = relation.schema?.constraint_name ?? `${relation.collection}.${relation.field}`;
         logger.warn(`GraphQL skipping relation "${relationName}" because it links to a non-existent or invalid collection.`);
         return false;
     };
-    schema.relations = schema.relations.filter((relation) => {
+    const relations = schema.relations.filter((relation) => {
         if (relation.collection && !collectionExists(relation.collection)) {
             return skipRelation(relation);
         }
@@ -76,5 +76,5 @@ export function sanitizeGraphqlSchema(schema) {
         }
         return true;
     });
-    return schema;
+    return { collections, relations };
 }

package/dist/services/items.js

@@ -442,8 +442,6 @@ export class ItemsService {
      */
     async updateByQuery(query, data, opts) {
         const keys = await this.getKeysByQuery(query);
-        const primaryKeyField = this.schema.collections[this.collection].primary;
-        validateKeys(this.schema, this.collection, primaryKeyField, keys);
         return keys.length ? await this.updateMany(keys, data, opts) : [];
     }
     /**

package/dist/services/meta.js

@@ -1,9 +1,8 @@
+import { isArray } from 'lodash-es';
+import { getAstFromQuery } from '../database/get-ast-from-query/get-ast-from-query.js';
 import getDatabase from '../database/index.js';
-import { fetchPermissions } from '../permissions/lib/fetch-permissions.js';
-import { fetchPolicies } from '../permissions/lib/fetch-policies.js';
-import { dedupeAccess } from '../permissions/modules/process-ast/utils/dedupe-access.js';
-import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { applyFilter, applySearch } from '../utils/apply-query.js';
+import { runAst } from '../database/run-ast/run-ast.js';
+import { processAst } from '../permissions/modules/process-ast/process-ast.js';
 export class MetaService {
     knex;
     accountability;
@@ -31,86 +30,28 @@ export class MetaService {
         }, {});
     }
     async totalCount(collection) {
-        const dbQuery = this.knex(collection);
-        let hasJoins = false;
-        if (this.accountability && this.accountability.admin === false) {
-            const context = { knex: this.knex, schema: this.schema };
-            await validateAccess({
-                accountability: this.accountability,
-                action: 'read',
-                collection,
-            }, context);
-            const policies = await fetchPolicies(this.accountability, context);
-            const permissions = await fetchPermissions({
-                action: 'read',
-                policies,
-                accountability: this.accountability,
-            }, context);
-            const collectionPermissions = permissions.filter((permission) => permission.collection === collection);
-            const rules = dedupeAccess(collectionPermissions);
-            const cases = rules.map(({ rule }) => rule);
-            const filter = {
-                _or: cases,
-            };
-            const result = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases, permissions);
-            hasJoins = result.hasJoins;
-        }
-        if (hasJoins) {
-            const primaryKeyName = this.schema.collections[collection].primary;
-            dbQuery.countDistinct({ count: [`${collection}.${primaryKeyName}`] });
-        }
-        else {
-            dbQuery.count('*', { as: 'count' });
-        }
-        const result = await dbQuery.first();
-        return Number(result?.count ?? 0);
+        return this.filterCount(collection, {});
     }
     async filterCount(collection, query) {
-        const dbQuery = this.knex(collection);
-        let filter = query.filter || {};
-        let hasJoins = false;
-        let cases = [];
-        let permissions = [];
-        if (this.accountability && this.accountability.admin === false) {
-            const context = { knex: this.knex, schema: this.schema };
-            await validateAccess({
-                accountability: this.accountability,
-                action: 'read',
-                collection,
-            }, context);
-            const policies = await fetchPolicies(this.accountability, context);
-            permissions = await fetchPermissions({
-                action: 'read',
-                policies,
-                accountability: this.accountability,
-            }, context);
-            const collectionPermissions = permissions.filter((permission) => permission.collection === collection);
-            const rules = dedupeAccess(collectionPermissions);
-            cases = rules.map(({ rule }) => rule);
-            const permissionsFilter = {
-                _or: cases,
-            };
-            if (Object.keys(filter).length > 0) {
-                filter = { _and: [permissionsFilter, filter] };
-            }
-            else {
-                filter = permissionsFilter;
-            }
-        }
-        if (Object.keys(filter).length > 0) {
-            ({ hasJoins } = applyFilter(this.knex, this.schema, dbQuery, filter, collection, {}, cases, permissions));
-        }
-        if (query.search) {
-            applySearch(this.knex, this.schema, dbQuery, query.search, collection);
-        }
-        if (hasJoins) {
-            const primaryKeyName = this.schema.collections[collection].primary;
-            dbQuery.countDistinct({ count: [`${collection}.${primaryKeyName}`] });
-        }
-        else {
-            dbQuery.count('*', { as: 'count' });
-        }
-        const result = await dbQuery.first();
-        return Number(result?.count ?? 0);
+        const aggregateQuery = {
+            aggregate: {
+                count: ['*'],
+            },
+            search: query.search ?? null,
+            filter: query.filter ?? null,
+        };
+        let ast = await getAstFromQuery({
+            collection,
+            query: aggregateQuery,
+            accountability: this.accountability,
+        }, {
+            schema: this.schema,
+            knex: this.knex,
+        });
+        ast = await processAst({ ast, action: 'read', accountability: this.accountability }, { knex: this.knex, schema: this.schema });
+        const records = await runAst(ast, this.schema, this.accountability, {
+            knex: this.knex,
+        });
+        return Number((isArray(records) ? records[0]?.['count'] : records?.['count']) ?? 0);
     }
 }

package/dist/services/users.d.ts

@@ -13,6 +13,10 @@ export declare class UsersService extends ItemsService {
      * directus_settings.auth_password_policy
      */
     private checkPasswordPolicy;
+    /**
+     * Clear users' sessions to log them out
+     */
+    private clearUserSessions;
     /**
      * Get basic information of user identified by email
      */

package/dist/services/users.js

@@ -87,6 +87,21 @@ export class UsersService extends ItemsService {
             }
         }
     }
+    /**
+     * Clear users' sessions to log them out
+     */
+    async clearUserSessions(userKeys, excludeSession) {
+        if (excludeSession) {
+            await this.knex
+                .from('directus_sessions')
+                .whereIn('user', userKeys)
+                .andWhereNot('token', '=', excludeSession)
+                .delete();
+        }
+        else {
+            await this.knex.from('directus_sessions').whereIn('user', userKeys).delete();
+        }
+    }
     /**
      * Get basic information of user identified by email
      */
@@ -238,6 +253,12 @@ export class UsersService extends ItemsService {
             opts.onRequireUserIntegrityCheck?.(opts.userIntegrityCheckFlags);
         }
         const result = await super.updateMany(keys, data, opts);
+        if (data['status'] !== undefined && data['status'] !== 'active') {
+            await this.clearUserSessions(keys);
+        }
+        else if (data['password'] !== undefined || data['email'] !== undefined) {
+            await this.clearUserSessions(keys, this.accountability?.session);
+        }
         // Only clear the caches if the role has been updated
         if ('role' in data) {
             await this.clearCaches(opts);
@@ -264,6 +285,7 @@ export class UsersService extends ItemsService {
         await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
         await this.knex('directus_versions').update({ user_updated: null }).whereIn('user_updated', keys);
         await super.deleteMany(keys, opts);
+        await this.clearUserSessions(keys);
         return keys;
     }
     async inviteUser(email, role, url, subject) {
@@ -462,7 +484,7 @@ export class UsersService extends ItemsService {
         await stall(STALL_TIME, timeStart);
     }
     async resetPassword(token, password) {
-        const { email, scope, hash } = jwt.verify(token, getSecret(), { issuer: 'directus' });
+        const { email, scope, hash } = verifyJWT(token, getSecret());
         if (scope !== 'password-reset' || !hash)
             throw new ForbiddenError();
         const opts = {};

package/dist/utils/apply-query.d.ts

@@ -39,7 +39,7 @@ export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuer
     hasJoins: boolean;
     hasMultiRelationalFilter: boolean;
 };
-export declare function applySearch(knex: Knex, schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): void;
+export declare function applySearch(knex: Knex, schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string, aliasMap: AliasMap, permissions: Permission[]): void;
 export declare function applyAggregate(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string, hasJoins: boolean): void;
 export declare function joinFilterWithCases(filter: Filter | null | undefined, cases: Filter[]): Filter | null;
 export {};