@directus/api 9.25.0

package/dist/utils/calculate-field-depth.js

@@ -0,0 +1,71 @@
+import { isPlainObject, isArray } from 'lodash-es';
+/**
+ * Calculates the depth of a given JSON structure, not counting any _ prefixed properties
+ *
+ * Used to calculate the field depth in a filter or deep query structure
+ *
+ * @example
+ *
+ * ```js
+ * const deep = {
+ * 	translations: {
+ * 		_filter: {
+ * 			_and: [
+ * 				{
+ * 					language_id: {
+ * 						name: {
+ * 							_eq: 'English'
+ * 						}
+ * 					}
+ * 				},
+ * 				{
+ * 					status: {
+ * 						_eq: 'Published'
+ * 					}
+ * 				}
+ * 			]
+ * 		}
+ * 	}
+ * };
+ *
+ * const result = calculateFieldDepth(deep); // => 3
+ * ```
+ */
+export function calculateFieldDepth(obj, dotNotationKeys = []) {
+    if (!obj) {
+        return 0;
+    }
+    let depth = 0;
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        const nestedValue = obj[key];
+        if (dotNotationKeys.includes(key) && nestedValue) {
+            let sortDepth = 0;
+            for (const sortKey of nestedValue) {
+                if (sortKey) {
+                    sortDepth = Math.max(sortKey.split('.').length, sortDepth);
+                }
+            }
+            if (sortDepth > depth) {
+                depth = sortDepth;
+            }
+        }
+        else {
+            if (!isPlainObject(nestedValue) && !isArray(nestedValue))
+                continue;
+            let nestedDepth = 0;
+            if (Array.isArray(nestedValue)) {
+                nestedDepth = Math.max(...nestedValue.map((val) => calculateFieldDepth(val, dotNotationKeys)));
+            }
+            else {
+                nestedDepth = calculateFieldDepth(nestedValue, dotNotationKeys);
+            }
+            if (key.startsWith('_') === false)
+                nestedDepth += 1;
+            if (nestedDepth > depth) {
+                depth = nestedDepth;
+            }
+        }
+    }
+    return depth;
+}

package/dist/utils/calculate-field-depth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/compress.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare function compress(raw: Record<string, any> | Record<string, any>[]): Promise<Buffer>;
+export declare function decompress(compressed: Buffer): Promise<any>;

package/dist/utils/compress.js

@@ -0,0 +1,12 @@
+import { compress as compressSnappy, uncompress as uncompressSnappy } from 'snappy';
+import { compress as compressJSON, decompress as decompressJSON } from '@directus/utils';
+export async function compress(raw) {
+    if (!raw)
+        return raw;
+    return await compressSnappy(compressJSON(raw));
+}
+export async function decompress(compressed) {
+    if (!compressed)
+        return compressed;
+    return decompressJSON((await uncompressSnappy(compressed, { asBuffer: false })));
+}

package/dist/utils/construct-flow-tree.d.ts

@@ -0,0 +1,2 @@
+import type { Flow, FlowRaw } from '@directus/types';
+export declare function constructFlowTree(flow: FlowRaw): Flow;

package/dist/utils/construct-flow-tree.js

@@ -0,0 +1,27 @@
+import { omit } from 'lodash-es';
+export function constructFlowTree(flow) {
+    const rootOperation = flow.operations.find((operation) => operation.id === flow.operation) ?? null;
+    const operationTree = constructOperationTree(rootOperation, flow.operations);
+    const flowTree = {
+        ...omit(flow, 'operations'),
+        operation: operationTree,
+        options: flow.options ?? {},
+    };
+    return flowTree;
+}
+function constructOperationTree(root, operations) {
+    if (root === null) {
+        return null;
+    }
+    const resolveOperation = root.resolve !== null ? operations.find((operation) => operation.id === root.resolve) : null;
+    const rejectOperation = root.reject !== null ? operations.find((operation) => operation.id === root.reject) : null;
+    if (resolveOperation === undefined || rejectOperation === undefined) {
+        throw new Error('Undefined reference in operations');
+    }
+    const operationTree = {
+        ...omit(root, 'flow'),
+        resolve: constructOperationTree(resolveOperation, operations),
+        reject: constructOperationTree(rejectOperation, operations),
+    };
+    return operationTree;
+}

package/dist/utils/filter-items.d.ts

@@ -0,0 +1,2 @@
+import type { Query } from '@directus/types';
+export declare function filterItems(items: Record<string, any>[], filter: Query['filter']): Record<string, any>[];

package/dist/utils/filter-items.js

@@ -0,0 +1,33 @@
+import { generateJoi } from '@directus/utils';
+/*
+ Note: Filtering is normally done through SQL in run-ast. This function can be used in case an already
+ existing array of items has to be filtered using the same filter syntax as used in the ast-to-sql flow
+ */
+export function filterItems(items, filter) {
+    if (!filter)
+        return items;
+    return items.filter((item) => {
+        return passesFilter(item, filter);
+    });
+    function passesFilter(item, filter) {
+        if (!filter || Object.keys(filter).length === 0)
+            return true;
+        if (Object.keys(filter)[0] === '_and') {
+            const subfilter = Object.values(filter)[0];
+            return subfilter.every((subFilter) => {
+                return passesFilter(item, subFilter);
+            });
+        }
+        else if (Object.keys(filter)[0] === '_or') {
+            const subfilter = Object.values(filter)[0];
+            return subfilter.some((subFilter) => {
+                return passesFilter(item, subFilter);
+            });
+        }
+        else {
+            const schema = generateJoi(filter);
+            const { error } = schema.validate(item);
+            return error === undefined;
+        }
+    }
+}

package/dist/utils/filter-items.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/generate-hash.d.ts

@@ -0,0 +1 @@
+export declare function generateHash(stringToHash: string): Promise<string>;

package/dist/utils/generate-hash.js

@@ -0,0 +1,9 @@
+import argon2 from 'argon2';
+import { getConfigFromEnv } from './get-config-from-env.js';
+export function generateHash(stringToHash) {
+    const argon2HashConfigOptions = getConfigFromEnv('HASH_', 'HASH_RAW'); // Disallow the HASH_RAW option, see https://github.com/directus/directus/discussions/7670#discussioncomment-1255805
+    // associatedData, if specified, must be passed as a Buffer to argon2.hash, see https://github.com/ranisalt/node-argon2/wiki/Options#associateddata
+    'associatedData' in argon2HashConfigOptions &&
+        (argon2HashConfigOptions['associatedData'] = Buffer.from(argon2HashConfigOptions['associatedData']));
+    return argon2.hash(stringToHash, argon2HashConfigOptions);
+}

package/dist/utils/get-accountability-for-role.d.ts

@@ -0,0 +1,7 @@
+import type { Accountability, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function getAccountabilityForRole(role: null | string, context: {
+    accountability: null | Accountability;
+    schema: SchemaOverview;
+    database: Knex;
+}): Promise<Accountability>;

package/dist/utils/get-accountability-for-role.js

@@ -0,0 +1,41 @@
+import { InvalidConfigException } from '../exceptions/index.js';
+import { getPermissions } from './get-permissions.js';
+export async function getAccountabilityForRole(role, context) {
+    let generatedAccountability = context.accountability;
+    if (role === null) {
+        generatedAccountability = {
+            role: null,
+            user: null,
+            admin: false,
+            app: false,
+        };
+        generatedAccountability.permissions = await getPermissions(generatedAccountability, context.schema);
+    }
+    else if (role === 'system') {
+        generatedAccountability = {
+            user: null,
+            role: null,
+            admin: true,
+            app: true,
+            permissions: [],
+        };
+    }
+    else {
+        const roleInfo = await context.database
+            .select(['app_access', 'admin_access'])
+            .from('directus_roles')
+            .where({ id: role })
+            .first();
+        if (!roleInfo) {
+            throw new InvalidConfigException(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
+        }
+        generatedAccountability = {
+            role,
+            user: null,
+            admin: roleInfo.admin_access === 1 || roleInfo.admin_access === '1' || roleInfo.admin_access === true,
+            app: roleInfo.app_access === 1 || roleInfo.app_access === '1' || roleInfo.app_access === true,
+        };
+        generatedAccountability.permissions = await getPermissions(generatedAccountability, context.schema);
+    }
+    return generatedAccountability;
+}

package/dist/utils/get-ast-from-query.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate an AST based on a given collection and query
+ */
+import type { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AST } from '../types/index.js';
+type GetASTOptions = {
+    accountability?: Accountability | null;
+    action?: PermissionsAction;
+    knex?: Knex;
+};
+export default function getASTFromQuery(collection: string, query: Query, schema: SchemaOverview, options?: GetASTOptions): Promise<AST>;
+export {};

package/dist/utils/get-ast-from-query.js

@@ -0,0 +1,297 @@
+/**
+ * Generate an AST based on a given collection and query
+ */
+import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+import { cloneDeep, isEmpty, mapKeys, omitBy, uniq } from 'lodash-es';
+import { getRelationType } from '../utils/get-relation-type.js';
+export default async function getASTFromQuery(collection, query, schema, options) {
+    query = cloneDeep(query);
+    const accountability = options?.accountability;
+    const action = options?.action || 'read';
+    const permissions = accountability && accountability.admin !== true
+        ? accountability?.permissions?.filter((permission) => {
+            return permission.action === action;
+        }) ?? []
+        : null;
+    const ast = {
+        type: 'root',
+        name: collection,
+        query: query,
+        children: [],
+    };
+    let fields = ['*'];
+    if (query.fields) {
+        fields = query.fields;
+    }
+    /**
+     * When using aggregate functions, you can't have any other regular fields
+     * selected. This makes sure you never end up in a non-aggregate fields selection error
+     */
+    if (Object.keys(query.aggregate || {}).length > 0) {
+        fields = [];
+    }
+    /**
+     * Similarly, when grouping on a specific field, you can't have other non-aggregated fields.
+     * The group query will override the fields query
+     */
+    if (query.group) {
+        fields = query.group;
+    }
+    fields = uniq(fields);
+    const deep = query.deep || {};
+    // Prevent fields/deep from showing up in the query object in further use
+    delete query.fields;
+    delete query.deep;
+    if (!query.sort) {
+        // We'll default to the primary key for the standard sort output
+        let sortField = schema.collections[collection].primary;
+        // If a custom manual sort field is configured, use that
+        if (schema.collections[collection]?.sortField) {
+            sortField = schema.collections[collection].sortField;
+        }
+        // When group by is used, default to the first column provided in the group by clause
+        if (query.group?.[0]) {
+            sortField = query.group[0];
+        }
+        query.sort = [sortField];
+    }
+    // When no group by is supplied, but an aggregate function is used, only a single row will be
+    // returned. In those cases, we'll ignore the sort field altogether
+    if (query.aggregate && Object.keys(query.aggregate).length && !query.group?.[0]) {
+        delete query.sort;
+    }
+    ast.children = await parseFields(collection, fields, deep);
+    return ast;
+    async function parseFields(parentCollection, fields, deep) {
+        if (!fields)
+            return [];
+        fields = await convertWildcards(parentCollection, fields);
+        if (!fields || !Array.isArray(fields))
+            return [];
+        const children = [];
+        const relationalStructure = Object.create(null);
+        for (const fieldKey of fields) {
+            let name = fieldKey;
+            if (query.alias) {
+                // check for field alias (is is one of the key)
+                if (name in query.alias) {
+                    name = query.alias[fieldKey];
+                }
+            }
+            const isRelational = name.includes('.') ||
+                // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
+                // anything
+                !!schema.relations.find((relation) => relation.related_collection === parentCollection && relation.meta?.one_field === name);
+            if (isRelational) {
+                // field is relational
+                const parts = fieldKey.split('.');
+                let rootField = parts[0];
+                let collectionScope = null;
+                // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
+                if (rootField.includes(':')) {
+                    const [key, scope] = rootField.split(':');
+                    rootField = key;
+                    collectionScope = scope;
+                }
+                if (rootField in relationalStructure === false) {
+                    if (collectionScope) {
+                        relationalStructure[rootField] = { [collectionScope]: [] };
+                    }
+                    else {
+                        relationalStructure[rootField] = [];
+                    }
+                }
+                if (parts.length > 1) {
+                    const childKey = parts.slice(1).join('.');
+                    if (collectionScope) {
+                        if (collectionScope in relationalStructure[rootField] === false) {
+                            relationalStructure[rootField][collectionScope] = [];
+                        }
+                        relationalStructure[rootField][collectionScope].push(childKey);
+                    }
+                    else {
+                        relationalStructure[rootField].push(childKey);
+                    }
+                }
+            }
+            else {
+                if (fieldKey.includes('(') && fieldKey.includes(')')) {
+                    const columnName = fieldKey.match(REGEX_BETWEEN_PARENS)[1];
+                    const foundField = schema.collections[parentCollection].fields[columnName];
+                    if (foundField && foundField.type === 'alias') {
+                        const foundRelation = schema.relations.find((relation) => relation.related_collection === parentCollection && relation.meta?.one_field === columnName);
+                        if (foundRelation) {
+                            children.push({
+                                type: 'functionField',
+                                name,
+                                fieldKey,
+                                query: {},
+                                relatedCollection: foundRelation.collection,
+                            });
+                            continue;
+                        }
+                    }
+                }
+                children.push({ type: 'field', name, fieldKey });
+            }
+        }
+        for (const [fieldKey, nestedFields] of Object.entries(relationalStructure)) {
+            let fieldName = fieldKey;
+            if (query.alias && fieldKey in query.alias) {
+                fieldName = query.alias[fieldKey];
+            }
+            const relatedCollection = getRelatedCollection(parentCollection, fieldName);
+            const relation = getRelation(parentCollection, fieldName);
+            if (!relation)
+                continue;
+            const relationType = getRelationType({
+                relation,
+                collection: parentCollection,
+                field: fieldName,
+            });
+            if (!relationType)
+                continue;
+            let child = null;
+            if (relationType === 'a2o') {
+                const allowedCollections = relation.meta.one_allowed_collections.filter((collection) => {
+                    if (!permissions)
+                        return true;
+                    return permissions.some((permission) => permission.collection === collection);
+                });
+                child = {
+                    type: 'a2o',
+                    names: allowedCollections,
+                    children: {},
+                    query: {},
+                    relatedKey: {},
+                    parentKey: schema.collections[parentCollection].primary,
+                    fieldKey: fieldKey,
+                    relation: relation,
+                };
+                for (const relatedCollection of allowedCollections) {
+                    child.children[relatedCollection] = await parseFields(relatedCollection, Array.isArray(nestedFields) ? nestedFields : nestedFields[relatedCollection] || [], deep?.[`${fieldKey}:${relatedCollection}`]);
+                    child.query[relatedCollection] = getDeepQuery(deep?.[`${fieldKey}:${relatedCollection}`] || {});
+                    child.relatedKey[relatedCollection] = schema.collections[relatedCollection].primary;
+                }
+            }
+            else if (relatedCollection) {
+                if (permissions && permissions.some((permission) => permission.collection === relatedCollection) === false) {
+                    continue;
+                }
+                // update query alias for children parseFields
+                const deepAlias = getDeepQuery(deep?.[fieldKey] || {})?.['alias'];
+                if (!isEmpty(deepAlias))
+                    query.alias = deepAlias;
+                child = {
+                    type: relationType,
+                    name: relatedCollection,
+                    fieldKey: fieldKey,
+                    parentKey: schema.collections[parentCollection].primary,
+                    relatedKey: schema.collections[relatedCollection].primary,
+                    relation: relation,
+                    query: getDeepQuery(deep?.[fieldKey] || {}),
+                    children: await parseFields(relatedCollection, nestedFields, deep?.[fieldKey] || {}),
+                };
+                if (relationType === 'o2m' && !child.query.sort) {
+                    child.query.sort = [relation.meta?.sort_field || schema.collections[relation.collection].primary];
+                }
+            }
+            if (child) {
+                children.push(child);
+            }
+        }
+        // Deduplicate any children fields that are included both as a regular field, and as a nested m2o field
+        const nestedCollectionNodes = children.filter((childNode) => childNode.type !== 'field');
+        return children.filter((childNode) => {
+            const existsAsNestedRelational = !!nestedCollectionNodes.find((nestedCollectionNode) => childNode.fieldKey === nestedCollectionNode.fieldKey);
+            if (childNode.type === 'field' && existsAsNestedRelational)
+                return false;
+            return true;
+        });
+    }
+    async function convertWildcards(parentCollection, fields) {
+        fields = cloneDeep(fields);
+        const fieldsInCollection = Object.entries(schema.collections[parentCollection].fields).map(([name]) => name);
+        let allowedFields = fieldsInCollection;
+        if (permissions) {
+            const permittedFields = permissions.find((permission) => parentCollection === permission.collection)?.fields;
+            if (permittedFields !== undefined)
+                allowedFields = permittedFields;
+        }
+        if (!allowedFields || allowedFields.length === 0)
+            return [];
+        // In case of full read permissions
+        if (allowedFields[0] === '*')
+            allowedFields = fieldsInCollection;
+        for (let index = 0; index < fields.length; index++) {
+            const fieldKey = fields[index];
+            if (fieldKey.includes('*') === false)
+                continue;
+            if (fieldKey === '*') {
+                const aliases = Object.keys(query.alias ?? {});
+                // Set to all fields in collection
+                if (allowedFields.includes('*')) {
+                    fields.splice(index, 1, ...fieldsInCollection, ...aliases);
+                }
+                else {
+                    // Set to all allowed fields
+                    const allowedAliases = aliases.filter((fieldKey) => {
+                        const name = query.alias[fieldKey];
+                        return allowedFields.includes(name);
+                    });
+                    fields.splice(index, 1, ...allowedFields, ...allowedAliases);
+                }
+            }
+            // Swap *.* case for *,<relational-field>.*,<another-relational>.*
+            if (fieldKey.includes('.') && fieldKey.split('.')[0] === '*') {
+                const parts = fieldKey.split('.');
+                const relationalFields = allowedFields.includes('*')
+                    ? schema.relations
+                        .filter((relation) => relation.collection === parentCollection || relation.related_collection === parentCollection)
+                        .map((relation) => {
+                        const isMany = relation.collection === parentCollection;
+                        return isMany ? relation.field : relation.meta?.one_field;
+                    })
+                    : allowedFields.filter((fieldKey) => !!getRelation(parentCollection, fieldKey));
+                const nonRelationalFields = allowedFields.filter((fieldKey) => relationalFields.includes(fieldKey) === false);
+                const aliasFields = Object.keys(query.alias ?? {}).map((fieldKey) => {
+                    const name = query.alias[fieldKey];
+                    if (relationalFields.includes(name)) {
+                        return `${fieldKey}.${parts.slice(1).join('.')}`;
+                    }
+                    return fieldKey;
+                });
+                fields.splice(index, 1, ...[
+                    ...relationalFields.map((relationalField) => {
+                        return `${relationalField}.${parts.slice(1).join('.')}`;
+                    }),
+                    ...nonRelationalFields,
+                    ...aliasFields,
+                ]);
+            }
+        }
+        return fields;
+    }
+    function getRelation(collection, field) {
+        const relation = schema.relations.find((relation) => {
+            return ((relation.collection === collection && relation.field === field) ||
+                (relation.related_collection === collection && relation.meta?.one_field === field));
+        });
+        return relation;
+    }
+    function getRelatedCollection(collection, field) {
+        const relation = getRelation(collection, field);
+        if (!relation)
+            return null;
+        if (relation.collection === collection && relation.field === field) {
+            return relation.related_collection || null;
+        }
+        if (relation.related_collection === collection && relation.meta?.one_field === field) {
+            return relation.collection || null;
+        }
+        return null;
+    }
+}
+function getDeepQuery(query) {
+    return mapKeys(omitBy(query, (_value, key) => key.startsWith('_') === false), (_value, key) => key.substring(1));
+}

package/dist/utils/get-auth-providers.d.ts

@@ -0,0 +1,8 @@
+interface AuthProvider {
+    label: string;
+    name: string;
+    driver: string;
+    icon?: string;
+}
+export declare function getAuthProviders(): AuthProvider[];
+export {};

package/dist/utils/get-auth-providers.js

@@ -0,0 +1,12 @@
+import { toArray } from '@directus/utils';
+import env from '../env.js';
+export function getAuthProviders() {
+    return toArray(env['AUTH_PROVIDERS'])
+        .filter((provider) => provider && env[`AUTH_${provider.toUpperCase()}_DRIVER`])
+        .map((provider) => ({
+        name: provider,
+        label: env[`AUTH_${provider.toUpperCase()}_LABEL`],
+        driver: env[`AUTH_${provider.toUpperCase()}_DRIVER`],
+        icon: env[`AUTH_${provider.toUpperCase()}_ICON`],
+    }));
+}

package/dist/utils/get-auth-providers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-cache-headers.d.ts

@@ -0,0 +1,10 @@
+import type { Request } from 'express';
+/**
+ * Returns the Cache-Control header for the current request
+ *
+ * @param req Express request object
+ * @param ttl TTL of the cache in ms
+ * @param globalCacheSettings Whether requests are affected by the global cache settings (i.e. for dynamic API requests)
+ * @param personalized Whether requests depend on the authentication status of users
+ */
+export declare function getCacheControlHeader(req: Request, ttl: number | undefined, globalCacheSettings: boolean, personalized: boolean): string;

package/dist/utils/get-cache-headers.js

@@ -0,0 +1,36 @@
+import env from '../env.js';
+import { shouldSkipCache } from './should-skip-cache.js';
+/**
+ * Returns the Cache-Control header for the current request
+ *
+ * @param req Express request object
+ * @param ttl TTL of the cache in ms
+ * @param globalCacheSettings Whether requests are affected by the global cache settings (i.e. for dynamic API requests)
+ * @param personalized Whether requests depend on the authentication status of users
+ */
+export function getCacheControlHeader(req, ttl, globalCacheSettings, personalized) {
+    // When the user explicitly asked to skip the cache
+    if (shouldSkipCache(req))
+        return 'no-store';
+    // When the resource / current request shouldn't be cached
+    if (ttl === undefined || ttl < 0)
+        return 'no-cache';
+    // When the API cache can invalidate at any moment
+    if (globalCacheSettings && env['CACHE_AUTO_PURGE'] === true)
+        return 'no-cache';
+    const headerValues = [];
+    // When caching depends on the authentication status of the users
+    if (personalized) {
+        // Allow response to be stored in shared cache (public) or local cache only (private)
+        const access = !!req.accountability?.role === false ? 'public' : 'private';
+        headerValues.push(access);
+    }
+    // Cache control header uses seconds for everything
+    const ttlSeconds = Math.round(ttl / 1000);
+    headerValues.push(`max-age=${ttlSeconds}`);
+    // When the s-maxage flag should be included
+    if (globalCacheSettings && Number.isInteger(env['CACHE_CONTROL_S_MAXAGE']) && env['CACHE_CONTROL_S_MAXAGE'] >= 0) {
+        headerValues.push(`s-maxage=${env['CACHE_CONTROL_S_MAXAGE']}`);
+    }
+    return headerValues.join(', ');
+}

package/dist/utils/get-cache-headers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-cache-key.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from 'express';
+export declare function getCacheKey(req: Request): string;

package/dist/utils/get-cache-key.js

@@ -0,0 +1,14 @@
+import hash from 'object-hash';
+import url from 'url';
+import { getGraphqlQueryAndVariables } from './get-graphql-query-and-variables.js';
+export function getCacheKey(req) {
+    const path = url.parse(req.originalUrl).pathname;
+    const isGraphQl = path?.startsWith('/graphql');
+    const info = {
+        user: req.accountability?.user || null,
+        path,
+        query: isGraphQl ? getGraphqlQueryAndVariables(req) : req.sanitizedQuery,
+    };
+    const key = hash(info);
+    return key;
+}

package/dist/utils/get-cache-key.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/get-collection-from-alias.d.ts

@@ -0,0 +1,6 @@
+import type { AliasMap } from './get-column-path.js';
+/**
+ * Extract the collection of an alias within an aliasMap
+ * For example: 'ljnsv.name' -> 'authors'
+ */
+export declare function getCollectionFromAlias(alias: string, aliasMap: AliasMap): string | undefined;

package/dist/utils/get-collection-from-alias.js

@@ -0,0 +1,12 @@
+/**
+ * Extract the collection of an alias within an aliasMap
+ * For example: 'ljnsv.name' -> 'authors'
+ */
+export function getCollectionFromAlias(alias, aliasMap) {
+    for (const aliasValue of Object.values(aliasMap)) {
+        if (aliasValue.alias === alias) {
+            return aliasValue.collection;
+        }
+    }
+    return undefined;
+}