directus 9.23.4 → 9.25.0

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

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateFieldDepth = void 0;
-const lodash_1 = require("lodash");
-/**
- * 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
- * ```
- */
-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 (!(0, lodash_1.isPlainObject)(nestedValue) && !(0, lodash_1.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;
-}
-exports.calculateFieldDepth = calculateFieldDepth;

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

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

package/dist/utils/compress.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="node" />
-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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decompress = exports.compress = void 0;
-const snappy_1 = require("snappy");
-const utils_1 = require("@directus/shared/utils");
-async function compress(raw) {
-    if (!raw)
-        return raw;
-    return await (0, snappy_1.compress)((0, utils_1.compress)(raw));
-}
-exports.compress = compress;
-async function decompress(compressed) {
-    if (!compressed)
-        return compressed;
-    return (0, utils_1.decompress)((await (0, snappy_1.uncompress)(compressed, { asBuffer: false })));
-}
-exports.decompress = decompress;

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

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

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.constructFlowTree = void 0;
-const lodash_1 = require("lodash");
-function constructFlowTree(flow) {
-    const rootOperation = flow.operations.find((operation) => operation.id === flow.operation) ?? null;
-    const operationTree = constructOperationTree(rootOperation, flow.operations);
-    const flowTree = {
-        ...(0, lodash_1.omit)(flow, 'operations'),
-        operation: operationTree,
-        options: flow.options ?? {},
-    };
-    return flowTree;
-}
-exports.constructFlowTree = constructFlowTree;
-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 = {
-        ...(0, lodash_1.omit)(root, 'flow'),
-        resolve: constructOperationTree(resolveOperation, operations),
-        reject: constructOperationTree(rejectOperation, operations),
-    };
-    return operationTree;
-}

package/dist/utils/dynamic-import.d.ts

@@ -1 +0,0 @@
-export declare const dynamicImport: (mod: string) => Promise<any>;

package/dist/utils/dynamic-import.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dynamicImport = void 0;
-const dynamicImport = async (mod) => {
-    return process.env['VITEST'] ? await import(mod) : require(mod);
-};
-exports.dynamicImport = dynamicImport;

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

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

package/dist/utils/filter-items.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterItems = void 0;
-const utils_1 = require("@directus/shared/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
- */
-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 = (0, utils_1.generateJoi)(filter);
-            const { error } = schema.validate(item);
-            return error === undefined;
-        }
-    }
-}
-exports.filterItems = filterItems;

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

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

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

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

package/dist/utils/generate-hash.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateHash = void 0;
-const argon2_1 = __importDefault(require("argon2"));
-const get_config_from_env_1 = require("./get-config-from-env");
-function generateHash(stringToHash) {
-    const argon2HashConfigOptions = (0, get_config_from_env_1.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_1.default.hash(stringToHash, argon2HashConfigOptions);
-}
-exports.generateHash = generateHash;

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

@@ -1,7 +0,0 @@
-import type { Accountability, SchemaOverview } from '@directus/shared/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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAccountabilityForRole = void 0;
-const exceptions_1 = require("../exceptions");
-const get_permissions_1 = require("./get-permissions");
-async function getAccountabilityForRole(role, context) {
-    let generatedAccountability = context.accountability;
-    if (role === null) {
-        generatedAccountability = {
-            role: null,
-            user: null,
-            admin: false,
-            app: false,
-        };
-        generatedAccountability.permissions = await (0, get_permissions_1.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 exceptions_1.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 (0, get_permissions_1.getPermissions)(generatedAccountability, context.schema);
-    }
-    return generatedAccountability;
-}
-exports.getAccountabilityForRole = getAccountabilityForRole;

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

@@ -1,13 +0,0 @@
-/**
- * Generate an AST based on a given collection and query
- */
-import type { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/shared/types';
-import type { Knex } from 'knex';
-import type { AST } from '../types';
-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

@@ -1,300 +0,0 @@
-"use strict";
-/**
- * Generate an AST based on a given collection and query
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("@directus/shared/constants");
-const lodash_1 = require("lodash");
-const get_relation_type_1 = require("../utils/get-relation-type");
-async function getASTFromQuery(collection, query, schema, options) {
-    query = (0, lodash_1.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 = (0, lodash_1.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(constants_1.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 = (0, get_relation_type_1.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 (!(0, lodash_1.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 = (0, lodash_1.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;
-    }
-}
-exports.default = getASTFromQuery;
-function getDeepQuery(query) {
-    return (0, lodash_1.mapKeys)((0, lodash_1.omitBy)(query, (value, key) => key.startsWith('_') === false), (value, key) => key.substring(1));
-}

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

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

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

@@ -1,19 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuthProviders = void 0;
-const utils_1 = require("@directus/shared/utils");
-const env_1 = __importDefault(require("../env"));
-function getAuthProviders() {
-    return (0, utils_1.toArray)(env_1.default['AUTH_PROVIDERS'])
-        .filter((provider) => provider && env_1.default[`AUTH_${provider.toUpperCase()}_DRIVER`])
-        .map((provider) => ({
-        name: provider,
-        label: env_1.default[`AUTH_${provider.toUpperCase()}_LABEL`],
-        driver: env_1.default[`AUTH_${provider.toUpperCase()}_DRIVER`],
-        icon: env_1.default[`AUTH_${provider.toUpperCase()}_ICON`],
-    }));
-}
-exports.getAuthProviders = getAuthProviders;

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

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

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

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