@directus/api 9.25.0

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

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

package/dist/utils/get-column-path.d.ts

@@ -0,0 +1,26 @@
+import type { Relation, SchemaOverview } from '@directus/types';
+export type AliasMap = {
+    [key: string]: {
+        alias: string;
+        collection: string;
+    };
+};
+export type ColPathProps = {
+    path: string[];
+    collection: string;
+    aliasMap: AliasMap;
+    relations: Relation[];
+    schema?: SchemaOverview;
+};
+export type ColPathResult = {
+    columnPath: string;
+    targetCollection: string;
+    addNestedPkField: string | undefined;
+};
+/**
+ * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
+ * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ * Also returns the target collection of the column: 'directus_roles'
+ * If the last filter path is an alias field, a nested PK is appended to the path
+ */
+export declare function getColumnPath({ path, collection, aliasMap, relations, schema }: ColPathProps): ColPathResult;

package/dist/utils/get-column-path.js

@@ -0,0 +1,61 @@
+import { InvalidQueryException } from '../exceptions/index.js';
+import { getRelationInfo } from './get-relation-info.js';
+/**
+ * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
+ * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ * Also returns the target collection of the column: 'directus_roles'
+ * If the last filter path is an alias field, a nested PK is appended to the path
+ */
+export function getColumnPath({ path, collection, aliasMap, relations, schema }) {
+    return followRelation(path);
+    function followRelation(pathParts, parentCollection = collection, parentFields, addNestedPkField) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
+        if (!relation) {
+            throw new InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
+        }
+        const alias = parentFields ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias : aliasMap[pathParts[0]]?.alias;
+        const remainingParts = pathParts.slice(1);
+        let parent;
+        if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new InvalidQueryException(`You have to provide a collection scope when sorting on a many-to-any item`);
+            }
+            parent = pathScope;
+        }
+        else if (relationType === 'm2o') {
+            parent = relation.related_collection;
+        }
+        else {
+            parent = relation.collection;
+        }
+        // Top level alias field
+        if (schema && !((remainingParts[0] ?? parent).includes('(') && (remainingParts[0] ?? parent).includes(')'))) {
+            if (remainingParts.length === 0) {
+                remainingParts.push(schema.collections[parent].primary);
+                addNestedPkField = schema.collections[parent].primary;
+            }
+            // Nested level alias field
+            else if (remainingParts.length === 1 &&
+                schema.collections[parent].fields[remainingParts[0]].type === 'alias') {
+                remainingParts.push(schema.collections[relation.related_collection].primary);
+                addNestedPkField = schema.collections[relation.related_collection].primary;
+            }
+        }
+        if (remainingParts.length === 1) {
+            return {
+                columnPath: `${alias || parent}.${remainingParts[0]}`,
+                targetCollection: parent,
+                addNestedPkField,
+            };
+        }
+        if (remainingParts.length) {
+            return followRelation(remainingParts, parent, `${parentFields ? parentFields + '.' : ''}${pathParts[0]}`, addNestedPkField);
+        }
+        return { columnPath: '', targetCollection: '', addNestedPkField };
+    }
+}

package/dist/utils/get-column-path.test.d.ts

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

package/dist/utils/get-column.d.ts

@@ -0,0 +1,20 @@
+import type { Query, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+type GetColumnOptions = {
+    query?: Query | undefined;
+    originalCollectionName?: string | undefined;
+};
+/**
+ * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
+ * column is replaced with the appropriate SQL
+ *
+ * @param knex Current knex / transaction instance
+ * @param table Collection or alias in which column resides
+ * @param column name of the column
+ * @param alias Whether or not to add a SQL AS statement
+ * @param schema For retrieval of the column type
+ * @param options Optional parameters
+ * @returns Knex raw instance
+ */
+export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, options?: GetColumnOptions): Knex.Raw;
+export {};

package/dist/utils/get-column.js

@@ -0,0 +1,48 @@
+import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+import { getFunctionsForType } from '@directus/utils';
+import { getFunctions } from '../database/helpers/index.js';
+import { InvalidQueryException } from '../exceptions/index.js';
+import { applyFunctionToColumnName } from './apply-function-to-column-name.js';
+/**
+ * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
+ * column is replaced with the appropriate SQL
+ *
+ * @param knex Current knex / transaction instance
+ * @param table Collection or alias in which column resides
+ * @param column name of the column
+ * @param alias Whether or not to add a SQL AS statement
+ * @param schema For retrieval of the column type
+ * @param options Optional parameters
+ * @returns Knex raw instance
+ */
+export function getColumn(knex, table, column, alias = applyFunctionToColumnName(column), schema, options) {
+    const fn = getFunctions(knex, schema);
+    if (column.includes('(') && column.includes(')')) {
+        const functionName = column.split('(')[0];
+        const columnName = column.match(REGEX_BETWEEN_PARENS)[1];
+        if (functionName in fn) {
+            const collectionName = options?.originalCollectionName || table;
+            const type = schema?.collections[collectionName]?.fields?.[columnName]?.type ?? 'unknown';
+            const allowedFunctions = getFunctionsForType(type);
+            if (allowedFunctions.includes(functionName) === false) {
+                throw new InvalidQueryException(`Invalid function specified "${functionName}"`);
+            }
+            const result = fn[functionName](table, columnName, {
+                type,
+                query: options?.query,
+                originalCollectionName: options?.originalCollectionName,
+            });
+            if (alias) {
+                return knex.raw(result + ' AS ??', [alias]);
+            }
+            return result;
+        }
+        else {
+            throw new InvalidQueryException(`Invalid function specified "${functionName}"`);
+        }
+    }
+    if (alias && column !== alias) {
+        return knex.ref(`${table}.${column}`).as(alias);
+    }
+    return knex.ref(`${table}.${column}`);
+}

package/dist/utils/get-config-from-env.d.ts

@@ -0,0 +1 @@
+export declare function getConfigFromEnv(prefix: string, omitPrefix?: string | string[], type?: 'camelcase' | 'underscore'): Record<string, any>;

package/dist/utils/get-config-from-env.js

@@ -0,0 +1,41 @@
+import camelcase from 'camelcase';
+import { set } from 'lodash-es';
+import { getEnv } from '../env.js';
+export function getConfigFromEnv(prefix, omitPrefix, type = 'camelcase') {
+    const env = getEnv();
+    const config = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key.toLowerCase().startsWith(prefix.toLowerCase()) === false)
+            continue;
+        if (omitPrefix) {
+            let matches = false;
+            if (Array.isArray(omitPrefix)) {
+                matches = omitPrefix.some((prefix) => key.toLowerCase().startsWith(prefix.toLowerCase()));
+            }
+            else {
+                matches = key.toLowerCase().startsWith(omitPrefix.toLowerCase());
+            }
+            if (matches)
+                continue;
+        }
+        if (key.includes('__')) {
+            const path = key
+                .split('__')
+                .map((key, index) => (index === 0 ? transform(transform(key.slice(prefix.length))) : transform(key)));
+            set(config, path.join('.'), value);
+        }
+        else {
+            config[transform(key.slice(prefix.length))] = value;
+        }
+    }
+    return config;
+    function transform(key) {
+        if (type === 'camelcase') {
+            return camelcase(key, { locale: false });
+        }
+        else if (type === 'underscore') {
+            return key.toLowerCase();
+        }
+        return key;
+    }
+}

package/dist/utils/get-config-from-env.test.d.ts

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

package/dist/utils/get-date-formatted.d.ts

@@ -0,0 +1 @@
+export declare function getDateFormatted(): string;

package/dist/utils/get-date-formatted.js

@@ -0,0 +1,10 @@
+export function getDateFormatted() {
+    const date = new Date();
+    let month = String(date.getMonth() + 1);
+    if (month.length === 1)
+        month = '0' + month;
+    let day = String(date.getDate());
+    if (day.length === 1)
+        day = '0' + day;
+    return `${date.getFullYear()}${month}${day}-${date.getHours()}${date.getMinutes()}${date.getSeconds()}`;
+}

package/dist/utils/get-date-formatted.test.d.ts

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

package/dist/utils/get-default-index-name.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate an index name for a given collection + fields combination.
+ *
+ * Is based on the default index name generation of knex, but limits the index to a maximum of 64
+ * characters (the max length for MySQL and MariaDB).
+ *
+ * @see
+ * https://github.com/knex/knex/blob/fff6eb15d7088d4198650a2c6e673dedaf3b8f36/lib/schema/tablecompiler.js#L282-L297
+ */
+export declare function getDefaultIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;

package/dist/utils/get-default-index-name.js

@@ -0,0 +1,21 @@
+import { getSimpleHash } from '@directus/utils';
+/**
+ * Generate an index name for a given collection + fields combination.
+ *
+ * Is based on the default index name generation of knex, but limits the index to a maximum of 64
+ * characters (the max length for MySQL and MariaDB).
+ *
+ * @see
+ * https://github.com/knex/knex/blob/fff6eb15d7088d4198650a2c6e673dedaf3b8f36/lib/schema/tablecompiler.js#L282-L297
+ */
+export function getDefaultIndexName(type, collection, fields) {
+    if (!Array.isArray(fields))
+        fields = fields ? [fields] : [];
+    const table = collection.replace(/\.|-/g, '_');
+    const indexName = (table + '_' + fields.join('_') + '_' + type).toLowerCase();
+    if (indexName.length <= 60)
+        return indexName;
+    const suffix = `__${getSimpleHash(indexName)}_${type}`;
+    const prefix = indexName.substring(0, 60 - suffix.length);
+    return `${prefix}${suffix}`;
+}

package/dist/utils/get-default-value.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaOverview } from '@directus/schema/types/overview';
+import type { Column } from '@directus/schema';
+export default function getDefaultValue(column: SchemaOverview[string]['columns'][string] | Column): string | boolean | number | Record<string, any> | any[] | null;

package/dist/utils/get-default-value.js

@@ -0,0 +1,56 @@
+import { parseJSON } from '@directus/utils';
+import env from '../env.js';
+import logger from '../logger.js';
+import getLocalType from './get-local-type.js';
+export default function getDefaultValue(column) {
+    const type = getLocalType(column);
+    const defaultValue = column.default_value ?? null;
+    if (defaultValue === null)
+        return null;
+    if (defaultValue === '0000-00-00 00:00:00')
+        return null;
+    switch (type) {
+        case 'bigInteger':
+        case 'integer':
+        case 'decimal':
+        case 'float':
+            return Number.isNaN(Number(defaultValue)) === false ? Number(defaultValue) : defaultValue;
+        case 'boolean':
+            return castToBoolean(defaultValue);
+        case 'json':
+            return castToObject(defaultValue);
+        default:
+            return defaultValue;
+    }
+}
+function castToBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 0 || value === '0')
+        return false;
+    if (value === 1 || value === '1')
+        return true;
+    if (value === 'false' || value === false)
+        return false;
+    if (value === 'true' || value === true)
+        return true;
+    return Boolean(value);
+}
+function castToObject(value) {
+    if (!value)
+        return value;
+    if (typeof value === 'object')
+        return value;
+    if (typeof value === 'string') {
+        try {
+            return parseJSON(value);
+        }
+        catch (err) {
+            if (env['NODE_ENV'] === 'development') {
+                logger.error(err);
+            }
+            return value;
+        }
+    }
+    return {};
+}

package/dist/utils/get-graphql-query-and-variables.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from 'express';
+export declare function getGraphqlQueryAndVariables(req: Request): Pick<any, "query" | "variables">;

package/dist/utils/get-graphql-query-and-variables.js

@@ -0,0 +1,5 @@
+import { pick } from 'lodash-es';
+export function getGraphqlQueryAndVariables(req) {
+    const isGet = req.method?.toLowerCase() === 'get';
+    return pick(isGet ? req.query : req.body, ['query', 'variables']);
+}

package/dist/utils/get-graphql-query-and-variables.test.d.ts

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

package/dist/utils/get-graphql-type.d.ts

@@ -0,0 +1,3 @@
+import type { Type } from '@directus/types';
+import { GraphQLList, GraphQLScalarType, GraphQLType } from 'graphql';
+export declare function getGraphQLType(localType: Type | 'alias' | 'unknown', special: string[]): GraphQLScalarType | GraphQLList<GraphQLType>;

package/dist/utils/get-graphql-type.js

@@ -0,0 +1,36 @@
+import { GraphQLBoolean, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLString, } from 'graphql';
+import { GraphQLJSON } from 'graphql-compose';
+import { GraphQLBigInt } from '../services/graphql/types/bigint.js';
+import { GraphQLDate } from '../services/graphql/types/date.js';
+import { GraphQLGeoJSON } from '../services/graphql/types/geojson.js';
+import { GraphQLHash } from '../services/graphql/types/hash.js';
+export function getGraphQLType(localType, special) {
+    if (special.includes('conceal')) {
+        return GraphQLHash;
+    }
+    switch (localType) {
+        case 'boolean':
+            return GraphQLBoolean;
+        case 'bigInteger':
+            return GraphQLBigInt;
+        case 'integer':
+            return GraphQLInt;
+        case 'decimal':
+        case 'float':
+            return GraphQLFloat;
+        case 'csv':
+            return new GraphQLList(GraphQLString);
+        case 'json':
+            return GraphQLJSON;
+        case 'geometry':
+            return GraphQLGeoJSON;
+        case 'timestamp':
+        case 'dateTime':
+        case 'date':
+            return GraphQLDate;
+        case 'hash':
+            return GraphQLHash;
+        default:
+            return GraphQLString;
+    }
+}

package/dist/utils/get-ip-from-req.d.ts

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

package/dist/utils/get-ip-from-req.js

@@ -0,0 +1,17 @@
+import { isIP } from 'net';
+import env from '../env.js';
+import logger from '../logger.js';
+export function getIPFromReq(req) {
+    let ip = req.ip;
+    if (env['IP_CUSTOM_HEADER']) {
+        const customIPHeaderValue = req.get(env['IP_CUSTOM_HEADER']);
+        if (typeof customIPHeaderValue === 'string' && isIP(customIPHeaderValue) !== 0) {
+            ip = customIPHeaderValue;
+        }
+        else {
+            logger.warn(`Custom IP header didn't return valid IP address: ${JSON.stringify(customIPHeaderValue)}`);
+        }
+    }
+    // IP addresses starting with ::ffff: are IPv4 addresses in IPv6 format. We can strip the prefix to get back to IPv4
+    return ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+}

package/dist/utils/get-local-type.d.ts

@@ -0,0 +1,9 @@
+import type { FieldMeta, Type } from '@directus/types';
+export default function getLocalType(column?: {
+    data_type: string;
+    numeric_precision?: null | number;
+    numeric_scale?: null | number;
+    max_length?: null | number;
+}, field?: {
+    special?: FieldMeta['special'];
+}): Type | 'unknown';

package/dist/utils/get-local-type.js

@@ -0,0 +1,128 @@
+const localTypeMap = {
+    // Shared
+    boolean: 'boolean',
+    tinyint: 'integer',
+    smallint: 'integer',
+    mediumint: 'integer',
+    int: 'integer',
+    integer: 'integer',
+    serial: 'integer',
+    bigint: 'bigInteger',
+    bigserial: 'bigInteger',
+    clob: 'text',
+    tinytext: 'text',
+    mediumtext: 'text',
+    longtext: 'text',
+    text: 'text',
+    varchar: 'string',
+    longvarchar: 'string',
+    varchar2: 'string',
+    nvarchar: 'string',
+    image: 'binary',
+    ntext: 'text',
+    char: 'string',
+    date: 'date',
+    datetime: 'dateTime',
+    dateTime: 'dateTime',
+    timestamp: 'timestamp',
+    time: 'time',
+    float: 'float',
+    double: 'float',
+    'double precision': 'float',
+    real: 'float',
+    decimal: 'decimal',
+    numeric: 'integer',
+    // Geometries
+    geometry: 'geometry',
+    point: 'geometry.Point',
+    linestring: 'geometry.LineString',
+    polygon: 'geometry.Polygon',
+    multipoint: 'geometry.MultiPoint',
+    multilinestring: 'geometry.MultiLineString',
+    multipolygon: 'geometry.MultiPolygon',
+    // MySQL
+    string: 'text',
+    year: 'integer',
+    blob: 'binary',
+    mediumblob: 'binary',
+    'int unsigned': 'integer',
+    'tinyint unsigned': 'integer',
+    'smallint unsigned': 'integer',
+    'mediumint unsigned': 'integer',
+    'bigint unsigned': 'integer',
+    // MS SQL
+    bit: 'boolean',
+    smallmoney: 'float',
+    money: 'float',
+    datetimeoffset: 'timestamp',
+    datetime2: 'dateTime',
+    smalldatetime: 'dateTime',
+    nchar: 'text',
+    binary: 'binary',
+    varbinary: 'binary',
+    uniqueidentifier: 'uuid',
+    // Postgres
+    json: 'json',
+    jsonb: 'json',
+    uuid: 'uuid',
+    int2: 'integer',
+    serial4: 'integer',
+    int4: 'integer',
+    serial8: 'integer',
+    int8: 'integer',
+    bool: 'boolean',
+    'character varying': 'string',
+    character: 'string',
+    interval: 'string',
+    _varchar: 'string',
+    bpchar: 'string',
+    timestamptz: 'timestamp',
+    'timestamp with time zone': 'timestamp',
+    'timestamp with local time zone': 'timestamp',
+    'timestamp without time zone': 'dateTime',
+    'timestamp without local time zone': 'dateTime',
+    timetz: 'time',
+    'time with time zone': 'time',
+    'time without time zone': 'time',
+    float4: 'float',
+    float8: 'float',
+    citext: 'text',
+    // Oracle
+    number: 'integer',
+    sdo_geometry: 'geometry',
+    // SQLite
+    integerfirst: 'integer',
+};
+export default function getLocalType(column, field) {
+    if (!column)
+        return 'alias';
+    const dataType = column.data_type.toLowerCase();
+    const type = localTypeMap[dataType.split('(')[0]];
+    const special = field?.special;
+    if (special) {
+        if (special.includes('cast-json'))
+            return 'json';
+        if (special.includes('hash'))
+            return 'hash';
+        if (special.includes('cast-csv'))
+            return 'csv';
+        if (special.includes('uuid') || special.includes('file'))
+            return 'uuid';
+        if (special.includes('cast-timestamp'))
+            return 'timestamp';
+        if (special.includes('cast-datetime'))
+            return 'dateTime';
+        if (type?.startsWith('geometry')) {
+            return special[0] || 'geometry';
+        }
+    }
+    /** Handle Postgres numeric decimals */
+    if (dataType === 'numeric' && column.numeric_precision !== null && column.numeric_scale !== null) {
+        return 'decimal';
+    }
+    /** Handle MS SQL varchar(MAX) (eg TEXT) types */
+    if (column.data_type === 'nvarchar' && column.max_length === -1) {
+        return 'text';
+    }
+    return type ?? 'unknown';
+}

package/dist/utils/get-milliseconds.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Safely parse human readable time format into milliseconds
+ */
+export declare function getMilliseconds<T>(value: unknown, fallback?: T): number | T;

package/dist/utils/get-milliseconds.js

@@ -0,0 +1,7 @@
+import ms from 'ms';
+export function getMilliseconds(value, fallback = undefined) {
+    if ((typeof value !== 'string' && typeof value !== 'number') || value === '') {
+        return fallback;
+    }
+    return ms(String(value)) ?? fallback;
+}

package/dist/utils/get-milliseconds.test.d.ts

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

package/dist/utils/get-module-default.d.ts

@@ -0,0 +1,3 @@
+export default function getModuleDefault<T extends object>(mod: T | {
+    default: T;
+}): T;

package/dist/utils/get-module-default.js

@@ -0,0 +1,6 @@
+export default function getModuleDefault(mod) {
+    if ('default' in mod) {
+        return mod.default;
+    }
+    return mod;
+}

package/dist/utils/get-os-info.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get current host OS information
+ *
+ * @returns Object of OS type and version
+ */
+export declare function getOSInfo(): {
+    osType: string;
+    osVersion: string;
+};

package/dist/utils/get-os-info.js

@@ -0,0 +1,40 @@
+import os from 'os';
+/**
+ * Get current host OS information
+ *
+ * @returns Object of OS type and version
+ */
+export function getOSInfo() {
+    const osType = os.type() === 'Darwin' ? 'macOS' : os.type();
+    const osVersion = osType === 'macOS' ? macosRelease() : os.release();
+    return { osType, osVersion };
+}
+/**
+ * Get the name and version of a macOS release from the Darwin version.
+ * Lifted from `macos-release`.
+ */
+function macosRelease() {
+    const release = Number(os.release().split('.')[0]);
+    const nameMap = new Map([
+        [22, ['Ventura', '13']],
+        [21, ['Monterey', '12']],
+        [20, ['Big Sur', '11']],
+        [19, ['Catalina', '10.15']],
+        [18, ['Mojave', '10.14']],
+        [17, ['High Sierra', '10.13']],
+        [16, ['Sierra', '10.12']],
+        [15, ['El Capitan', '10.11']],
+        [14, ['Yosemite', '10.10']],
+        [13, ['Mavericks', '10.9']],
+        [12, ['Mountain Lion', '10.8']],
+        [11, ['Lion', '10.7']],
+        [10, ['Snow Leopard', '10.6']],
+        [9, ['Leopard', '10.5']],
+        [8, ['Tiger', '10.4']],
+        [7, ['Panther', '10.3']],
+        [6, ['Jaguar', '10.2']],
+        [5, ['Puma', '10.1']],
+    ]);
+    const current = nameMap.get(release);
+    return current ? `${current[0]} (${current[1]})` : 'Unknown';
+}

package/dist/utils/get-permissions.d.ts

@@ -0,0 +1,2 @@
+import type { Accountability, Permission, SchemaOverview } from '@directus/types';
+export declare function getPermissions(accountability: Accountability, schema: SchemaOverview): Promise<Permission[]>;