@directus/api 9.25.0

package/dist/utils/sanitize-query.test.d.ts

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

package/dist/utils/sanitize-schema.d.ts

@@ -0,0 +1,26 @@
+import type { Column } from '@directus/schema';
+import type { Field, Relation } from '@directus/types';
+import type { Collection } from '../types/index.js';
+/**
+ * Pick certain database vendor specific collection properties that should be compared when performing diff
+ *
+ * @param collection collection to sanitize
+ * @returns sanitized collection
+ */
+export declare function sanitizeCollection(collection: Collection | undefined): Partial<Collection> | undefined;
+/**
+ * Pick certain database vendor specific field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
+ * @returns sanitized field
+ */
+export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
+export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "name" | "numeric_precision" | "numeric_scale" | "data_type" | "default_value" | "max_length" | "is_nullable" | "is_unique" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment" | "foreign_key_table" | "foreign_key_column">;
+/**
+ * Pick certain database vendor specific relation properties that should be compared when performing diff
+ *
+ * @param relation relation to sanitize
+ * @returns sanitized relation
+ */
+export declare function sanitizeRelation(relation: Relation | undefined): Partial<Relation> | undefined;

package/dist/utils/sanitize-schema.js

@@ -0,0 +1,87 @@
+import { pick } from 'lodash-es';
+/**
+ * Pick certain database vendor specific collection properties that should be compared when performing diff
+ *
+ * @param collection collection to sanitize
+ * @returns sanitized collection
+ */
+export function sanitizeCollection(collection) {
+    if (!collection)
+        return collection;
+    return pick(collection, ['collection', 'fields', 'meta', 'schema.name']);
+}
+/**
+ * Pick certain database vendor specific field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
+ * @returns sanitized field
+ */
+export function sanitizeField(field, sanitizeAllSchema = false) {
+    if (!field)
+        return field;
+    const defaultPaths = ['collection', 'field', 'type', 'meta', 'name', 'children'];
+    const pickedPaths = sanitizeAllSchema
+        ? defaultPaths
+        : [
+            ...defaultPaths,
+            'schema.name',
+            'schema.table',
+            'schema.data_type',
+            'schema.default_value',
+            'schema.max_length',
+            'schema.numeric_precision',
+            'schema.numeric_scale',
+            'schema.is_nullable',
+            'schema.is_unique',
+            'schema.is_primary_key',
+            'schema.is_generated',
+            'schema.generation_expression',
+            'schema.has_auto_increment',
+            'schema.foreign_key_table',
+            'schema.foreign_key_column',
+        ];
+    return pick(field, pickedPaths);
+}
+export function sanitizeColumn(column) {
+    return pick(column, [
+        'name',
+        'table',
+        'data_type',
+        'default_value',
+        'max_length',
+        'numeric_precision',
+        'numeric_scale',
+        'is_nullable',
+        'is_unique',
+        'is_primary_key',
+        'is_generated',
+        'generation_expression',
+        'has_auto_increment',
+        'foreign_key_table',
+        'foreign_key_column',
+    ]);
+}
+/**
+ * Pick certain database vendor specific relation properties that should be compared when performing diff
+ *
+ * @param relation relation to sanitize
+ * @returns sanitized relation
+ */
+export function sanitizeRelation(relation) {
+    if (!relation)
+        return relation;
+    return pick(relation, [
+        'collection',
+        'field',
+        'related_collection',
+        'meta',
+        'schema.table',
+        'schema.column',
+        'schema.foreign_key_table',
+        'schema.foreign_key_column',
+        'schema.constraint_name',
+        'schema.on_update',
+        'schema.on_delete',
+    ]);
+}

package/dist/utils/sanitize-schema.test.d.ts

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

package/dist/utils/should-skip-cache.d.ts

@@ -0,0 +1,7 @@
+import type { Request } from 'express';
+/**
+ * Whether to skip caching for the current request
+ *
+ * @param req Express request object
+ */
+export declare function shouldSkipCache(req: Request): boolean;

package/dist/utils/should-skip-cache.js

@@ -0,0 +1,26 @@
+import { getEnv } from '../env.js';
+import { Url } from './url.js';
+/**
+ * Whether to skip caching for the current request
+ *
+ * @param req Express request object
+ */
+export function shouldSkipCache(req) {
+    const env = getEnv();
+    // Always skip cache for requests coming from the data studio based on Referer header
+    const referer = req.get('Referer');
+    if (referer) {
+        const adminUrl = new Url(env['PUBLIC_URL']).addPath('admin');
+        if (adminUrl.isRootRelative()) {
+            const refererUrl = new Url(referer);
+            if (refererUrl.path.join('/').startsWith(adminUrl.path.join('/')))
+                return true;
+        }
+        else if (referer.startsWith(adminUrl.toString())) {
+            return true;
+        }
+    }
+    if (env['CACHE_SKIP_ALLOWED'] && req.get('cache-control')?.includes('no-store'))
+        return true;
+    return false;
+}

package/dist/utils/should-skip-cache.test.d.ts

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

package/dist/utils/stall.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Wait a specific time to meet the stall ms. Useful in cases where you need to make sure that every
+ * path in a function takes at least X ms (for example authenticate).
+ *
+ * @param {number} ms - Stall time to wait until
+ * @param {number} start - Current start time of the function
+ *
+ * @example
+ *
+ * ```js
+ * const STALL_TIME = 100;
+ *
+ * // Function will always take (at least) 100ms
+ * async function doSomething() {
+ *   const timeStart = performance.now();
+ *
+ *   if (something === true) {
+ *     await heavy();
+ *   }
+ *
+ *   stall(STALL_TIME, timeStart);
+ *   return 'result';
+ * }
+ * ```
+ */
+export declare function stall(ms: number, start: number): Promise<void>;

package/dist/utils/stall.js

@@ -0,0 +1,34 @@
+import { performance } from 'perf_hooks';
+/**
+ * Wait a specific time to meet the stall ms. Useful in cases where you need to make sure that every
+ * path in a function takes at least X ms (for example authenticate).
+ *
+ * @param {number} ms - Stall time to wait until
+ * @param {number} start - Current start time of the function
+ *
+ * @example
+ *
+ * ```js
+ * const STALL_TIME = 100;
+ *
+ * // Function will always take (at least) 100ms
+ * async function doSomething() {
+ *   const timeStart = performance.now();
+ *
+ *   if (something === true) {
+ *     await heavy();
+ *   }
+ *
+ *   stall(STALL_TIME, timeStart);
+ *   return 'result';
+ * }
+ * ```
+ */
+export async function stall(ms, start) {
+    const now = performance.now();
+    const timeElapsed = now - start;
+    const timeRemaining = ms - timeElapsed;
+    if (timeRemaining <= 0)
+        return;
+    return new Promise((resolve) => setTimeout(resolve, timeRemaining));
+}

package/dist/utils/stall.test.d.ts

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

package/dist/utils/strip-function.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Strip the function declarations from a list of fields
+ */
+export declare function stripFunction(field: string): string;

package/dist/utils/strip-function.js

@@ -0,0 +1,12 @@
+import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+/**
+ * Strip the function declarations from a list of fields
+ */
+export function stripFunction(field) {
+    if (field.includes('(') && field.includes(')')) {
+        return field.match(REGEX_BETWEEN_PARENS)?.[1]?.trim() ?? field;
+    }
+    else {
+        return field;
+    }
+}

package/dist/utils/strip-function.test.d.ts

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

package/dist/utils/telemetry.d.ts

@@ -0,0 +1 @@
+export declare function collectTelemetry(): Promise<void>;

package/dist/utils/telemetry.js

@@ -0,0 +1,23 @@
+import mid from 'node-machine-id';
+import env from '../env.js';
+import logger from '../logger.js';
+import { version } from './package.js';
+export async function collectTelemetry() {
+    const axios = (await import('axios')).default;
+    if (env['TELEMETRY'] !== false) {
+        try {
+            await axios.post('https://telemetry.directus.io/', {
+                version: version,
+                public_url: env['PUBLIC_URL'],
+                project_id: env['KEY'],
+                machine_id: await mid.machineId(),
+                db_client: env['DB_CLIENT'],
+            });
+        }
+        catch (err) {
+            if (env['NODE_ENV'] === 'development') {
+                logger.error(err);
+            }
+        }
+    }
+}

package/dist/utils/transformations.d.ts

@@ -0,0 +1,6 @@
+import type { File, Transformation, TransformationParams } from '../types/index.js';
+export declare function resolvePreset(input: TransformationParams, file: File): Transformation[];
+/**
+ * Try to extract a file format from an array of `Transformation`'s.
+ */
+export declare function maybeExtractFormat(transforms: Transformation[]): string | undefined;

package/dist/utils/transformations.js

@@ -0,0 +1,30 @@
+export function resolvePreset(input, file) {
+    const transforms = input.transforms ?? [];
+    if (input.format || input.quality)
+        transforms.push([
+            'toFormat',
+            input.format || file.type.split('/')[1],
+            {
+                quality: input.quality ? Number(input.quality) : undefined,
+            },
+        ]);
+    if (input.width || input.height)
+        transforms.push([
+            'resize',
+            {
+                width: input.width ? Number(input.width) : undefined,
+                height: input.height ? Number(input.height) : undefined,
+                fit: input.fit,
+                withoutEnlargement: input.withoutEnlargement ? Boolean(input.withoutEnlargement) : undefined,
+            },
+        ]);
+    return transforms;
+}
+/**
+ * Try to extract a file format from an array of `Transformation`'s.
+ */
+export function maybeExtractFormat(transforms) {
+    const toFormats = transforms.filter((t) => t[0] === 'toFormat');
+    const lastToFormat = toFormats[toFormats.length - 1];
+    return lastToFormat ? lastToFormat[1]?.toString() : undefined;
+}

package/dist/utils/url.d.ts

@@ -0,0 +1,17 @@
+export declare class Url {
+    protocol: string | null;
+    host: string | null;
+    port: string | null;
+    path: string[];
+    query: Record<string, string>;
+    hash: string | null;
+    constructor(url: string);
+    isAbsolute(): boolean;
+    isProtocolRelative(): boolean;
+    isRootRelative(): boolean;
+    addPath(...paths: (string | number)[]): Url;
+    setQuery(key: string, value: string): Url;
+    toString({ rootRelative }?: {
+        rootRelative: boolean;
+    }): string;
+}

package/dist/utils/url.js

@@ -0,0 +1,59 @@
+import { URL } from 'url';
+export class Url {
+    protocol;
+    host;
+    port;
+    path;
+    query;
+    hash;
+    constructor(url) {
+        const parsedUrl = new URL(url, 'http://localhost');
+        const isProtocolRelative = /^\/\//.test(url);
+        const isRootRelative = /^\/$|^\/[^/]/.test(url);
+        const isPathRelative = /^\./.test(url);
+        this.protocol =
+            !isProtocolRelative && !isRootRelative && !isPathRelative
+                ? parsedUrl.protocol.substring(0, parsedUrl.protocol.length - 1)
+                : null;
+        this.host = !isRootRelative && !isPathRelative ? parsedUrl.hostname : null;
+        this.port = parsedUrl.port !== '' ? parsedUrl.port : null;
+        this.path = parsedUrl.pathname.split('/').filter((p) => p !== '');
+        this.query = Object.fromEntries(parsedUrl.searchParams.entries());
+        this.hash = parsedUrl.hash !== '' ? parsedUrl.hash.substring(1) : null;
+    }
+    isAbsolute() {
+        return this.protocol !== null && this.host !== null;
+    }
+    isProtocolRelative() {
+        return this.protocol === null && this.host !== null;
+    }
+    isRootRelative() {
+        return this.protocol === null && this.host === null;
+    }
+    addPath(...paths) {
+        const pathToAdd = paths.flatMap((p) => String(p).split('/')).filter((p) => p !== '');
+        for (const pathSegment of pathToAdd) {
+            if (pathSegment === '..') {
+                this.path.pop();
+            }
+            else if (pathSegment !== '.') {
+                this.path.push(pathSegment);
+            }
+        }
+        return this;
+    }
+    setQuery(key, value) {
+        this.query[key] = value;
+        return this;
+    }
+    toString({ rootRelative } = { rootRelative: false }) {
+        const protocol = this.protocol !== null ? `${this.protocol}:` : '';
+        const host = this.host ?? '';
+        const port = this.port !== null ? `:${this.port}` : '';
+        const origin = `${this.host !== null ? `${protocol}//` : ''}${host}${port}`;
+        const path = this.path.length ? `/${this.path.join('/')}` : '';
+        const query = Object.keys(this.query).length !== 0 ? `?${new URLSearchParams(this.query).toString()}` : '';
+        const hash = this.hash !== null ? `#${this.hash}` : '';
+        return `${!rootRelative ? origin : ''}${path}${query}${hash}`;
+    }
+}

package/dist/utils/url.test.d.ts

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

package/dist/utils/user-name.d.ts

@@ -0,0 +1,2 @@
+import type { User } from '@directus/types';
+export declare function userName(user: Partial<User>): string;

package/dist/utils/user-name.js

@@ -0,0 +1,15 @@
+export function userName(user) {
+    if (!user) {
+        return 'Unknown User';
+    }
+    if (user.first_name && user.last_name) {
+        return `${user.first_name} ${user.last_name}`;
+    }
+    if (user.first_name) {
+        return user.first_name;
+    }
+    if (user.email) {
+        return user.email;
+    }
+    return 'Unknown User';
+}

package/dist/utils/user-name.test.d.ts

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

package/dist/utils/validate-diff.d.ts

@@ -0,0 +1,7 @@
+import { SnapshotDiffWithHash, SnapshotWithHash } from '../types/snapshot.js';
+/**
+ * Validates the diff against the current schema snapshot.
+ *
+ * @returns True if the diff can be applied (valid & not empty).
+ */
+export declare function validateApplyDiff(applyDiff: SnapshotDiffWithHash, currentSnapshotWithHash: SnapshotWithHash): boolean;

package/dist/utils/validate-diff.js

@@ -0,0 +1,110 @@
+import Joi from 'joi';
+import { InvalidPayloadException } from '../exceptions/invalid-payload.js';
+import { DiffKind } from '../types/snapshot.js';
+const deepDiffSchema = Joi.object({
+    kind: Joi.string()
+        .valid(...Object.values(DiffKind))
+        .required(),
+    path: Joi.array().items(Joi.alternatives().try(Joi.string(), Joi.number())),
+    lhs: Joi.any().when('kind', { is: [DiffKind.NEW, DiffKind.ARRAY], then: Joi.optional(), otherwise: Joi.required() }),
+    rhs: Joi.any().when('kind', {
+        is: [DiffKind.DELETE, DiffKind.ARRAY],
+        then: Joi.optional(),
+        otherwise: Joi.required(),
+    }),
+    index: Joi.number().when('kind', { is: DiffKind.ARRAY, then: Joi.required() }),
+    item: Joi.link('#deepdiff').when('kind', { is: DiffKind.ARRAY, then: Joi.required() }),
+}).id('deepdiff');
+const applyJoiSchema = Joi.object({
+    hash: Joi.string().required(),
+    diff: Joi.object({
+        collections: Joi.array()
+            .items(Joi.object({
+            collection: Joi.string().required(),
+            diff: Joi.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+        fields: Joi.array()
+            .items(Joi.object({
+            collection: Joi.string().required(),
+            field: Joi.string().required(),
+            diff: Joi.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+        relations: Joi.array()
+            .items(Joi.object({
+            collection: Joi.string().required(),
+            field: Joi.string().required(),
+            related_collection: Joi.string().allow(null),
+            diff: Joi.array().items(deepDiffSchema).required(),
+        }))
+            .required(),
+    }).required(),
+});
+/**
+ * Validates the diff against the current schema snapshot.
+ *
+ * @returns True if the diff can be applied (valid & not empty).
+ */
+export function validateApplyDiff(applyDiff, currentSnapshotWithHash) {
+    const { error } = applyJoiSchema.validate(applyDiff);
+    if (error)
+        throw new InvalidPayloadException(error.message);
+    // No changes to apply
+    if (applyDiff.diff.collections.length === 0 &&
+        applyDiff.diff.fields.length === 0 &&
+        applyDiff.diff.relations.length === 0) {
+        return false;
+    }
+    // Diff can be applied due to matching hash
+    if (applyDiff.hash === currentSnapshotWithHash.hash)
+        return true;
+    for (const diffCollection of applyDiff.diff.collections) {
+        const collection = diffCollection.collection;
+        if (diffCollection.diff[0]?.kind === DiffKind.NEW) {
+            const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
+            if (existingCollection) {
+                throw new InvalidPayloadException(`Provided diff is trying to create collection "${collection}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffCollection.diff[0]?.kind === DiffKind.DELETE) {
+            const existingCollection = currentSnapshotWithHash.collections.find((c) => c.collection === diffCollection.collection);
+            if (!existingCollection) {
+                throw new InvalidPayloadException(`Provided diff is trying to delete collection "${collection}" but it does not exist. Please generate a new diff and try again.`);
+            }
+        }
+    }
+    for (const diffField of applyDiff.diff.fields) {
+        const field = `${diffField.collection}.${diffField.field}`;
+        if (diffField.diff[0]?.kind === DiffKind.NEW) {
+            const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
+            if (existingField) {
+                throw new InvalidPayloadException(`Provided diff is trying to create field "${field}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffField.diff[0]?.kind === DiffKind.DELETE) {
+            const existingField = currentSnapshotWithHash.fields.find((f) => f.collection === diffField.collection && f.field === diffField.field);
+            if (!existingField) {
+                throw new InvalidPayloadException(`Provided diff is trying to delete field "${field}" but it does not exist. Please generate a new diff and try again.`);
+            }
+        }
+    }
+    for (const diffRelation of applyDiff.diff.relations) {
+        let relation = `${diffRelation.collection}.${diffRelation.field}`;
+        if (diffRelation.related_collection)
+            relation += `-> ${diffRelation.related_collection}`;
+        if (diffRelation.diff[0]?.kind === DiffKind.NEW) {
+            const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
+            if (existingRelation) {
+                throw new InvalidPayloadException(`Provided diff is trying to create relation "${relation}" but it already exists. Please generate a new diff and try again.`);
+            }
+        }
+        else if (diffRelation.diff[0]?.kind === DiffKind.DELETE) {
+            const existingRelation = currentSnapshotWithHash.relations.find((r) => r.collection === diffRelation.collection && r.field === diffRelation.field);
+            if (!existingRelation) {
+                throw new InvalidPayloadException(`Provided diff is trying to delete relation "${relation}" but it does not exist. Please generate a new diff and try again.`);
+            }
+        }
+    }
+    throw new InvalidPayloadException(`Provided hash does not match the current instance's schema hash, indicating the schema has changed after this diff was generated. Please generate a new diff and try again.`);
+}

package/dist/utils/validate-diff.test.d.ts

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

package/dist/utils/validate-env.d.ts

@@ -0,0 +1 @@
+export declare function validateEnv(requiredKeys: string[]): void;

package/dist/utils/validate-env.js

@@ -0,0 +1,11 @@
+import { getEnv } from '../env.js';
+import logger from '../logger.js';
+export function validateEnv(requiredKeys) {
+    const env = getEnv();
+    for (const requiredKey of requiredKeys) {
+        if (requiredKey in env === false) {
+            logger.error(`"${requiredKey}" Environment Variable is missing.`);
+            process.exit(1);
+        }
+    }
+}

package/dist/utils/validate-env.test.d.ts

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

package/dist/utils/validate-keys.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaOverview } from '@directus/types';
+import type { PrimaryKey } from '../types/index.js';
+/**
+ * Validate keys based on its type
+ */
+export declare function validateKeys(schema: SchemaOverview, collection: string, keyField: string, keys: PrimaryKey | PrimaryKey[]): void;

package/dist/utils/validate-keys.js

@@ -0,0 +1,21 @@
+import validateUUID from 'uuid-validate';
+import { ForbiddenException } from '../exceptions/forbidden.js';
+/**
+ * Validate keys based on its type
+ */
+export function validateKeys(schema, collection, keyField, keys) {
+    if (Array.isArray(keys)) {
+        for (const key of keys) {
+            validateKeys(schema, collection, keyField, key);
+        }
+    }
+    else {
+        const primaryKeyFieldType = schema.collections[collection]?.fields[keyField]?.type;
+        if (primaryKeyFieldType === 'uuid' && !validateUUID(String(keys))) {
+            throw new ForbiddenException();
+        }
+        else if (primaryKeyFieldType === 'integer' && !Number.isInteger(Number(keys))) {
+            throw new ForbiddenException();
+        }
+    }
+}

package/dist/utils/validate-keys.test.d.ts

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

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

@@ -0,0 +1,2 @@
+import type { Query } from '@directus/types';
+export declare function validateQuery(query: Query): Query;