@directus/api 9.25.0

package/dist/start.d.ts

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

package/dist/start.js

@@ -0,0 +1,2 @@
+import { startServer } from './server.js';
+startServer();

package/dist/storage/get-storage-driver.d.ts

@@ -0,0 +1,3 @@
+import type { Driver } from '@directus/storage';
+export declare const _aliasMap: Record<string, string>;
+export declare const getStorageDriver: (driverName: string) => Promise<typeof Driver>;

package/dist/storage/get-storage-driver.js

@@ -0,0 +1,16 @@
+export const _aliasMap = {
+    local: '@directus/storage-driver-local',
+    s3: '@directus/storage-driver-s3',
+    gcs: '@directus/storage-driver-gcs',
+    azure: '@directus/storage-driver-azure',
+    cloudinary: '@directus/storage-driver-cloudinary',
+};
+export const getStorageDriver = async (driverName) => {
+    if (driverName in _aliasMap) {
+        driverName = _aliasMap[driverName];
+    }
+    else {
+        throw new Error(`Driver "${driverName}" doesn't exist.`);
+    }
+    return (await import(driverName)).default;
+};

package/dist/storage/get-storage-driver.test.d.ts

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

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+import type { StorageManager } from '@directus/storage';
+export declare const _cache: {
+    storage: any | null;
+};
+export declare const getStorage: () => Promise<StorageManager>;

package/dist/storage/index.js

@@ -0,0 +1,16 @@
+import { validateEnv } from '../utils/validate-env.js';
+import { registerDrivers } from './register-drivers.js';
+import { registerLocations } from './register-locations.js';
+export const _cache = {
+    storage: null,
+};
+export const getStorage = async () => {
+    if (_cache.storage)
+        return _cache.storage;
+    const { StorageManager } = await import('@directus/storage');
+    validateEnv(['STORAGE_LOCATIONS']);
+    _cache.storage = new StorageManager();
+    await registerDrivers(_cache.storage);
+    await registerLocations(_cache.storage);
+    return _cache.storage;
+};

package/dist/storage/index.test.d.ts

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

package/dist/storage/register-drivers.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerDrivers: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-drivers.js

@@ -0,0 +1,18 @@
+import { getEnv } from '../env.js';
+import { getStorageDriver } from './get-storage-driver.js';
+export const registerDrivers = async (storage) => {
+    const env = getEnv();
+    const usedDrivers = [];
+    for (const [key, value] of Object.entries(env)) {
+        if ((key.startsWith('STORAGE_') && key.endsWith('_DRIVER')) === false)
+            continue;
+        if (value && usedDrivers.includes(value) === false)
+            usedDrivers.push(value);
+    }
+    for (const driverName of usedDrivers) {
+        const storageDriver = await getStorageDriver(driverName);
+        if (storageDriver) {
+            storage.registerDriver(driverName, storageDriver);
+        }
+    }
+};

package/dist/storage/register-drivers.test.d.ts

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

package/dist/storage/register-locations.d.ts

@@ -0,0 +1,2 @@
+import type { StorageManager } from '@directus/storage';
+export declare const registerLocations: (storage: StorageManager) => Promise<void>;

package/dist/storage/register-locations.js

@@ -0,0 +1,13 @@
+import { toArray } from '@directus/utils';
+import { getEnv } from '../env.js';
+import { getConfigFromEnv } from '../utils/get-config-from-env.js';
+export const registerLocations = async (storage) => {
+    const env = getEnv();
+    const locations = toArray(env['STORAGE_LOCATIONS']);
+    locations.forEach((location) => {
+        location = location.trim();
+        const driverConfig = getConfigFromEnv(`STORAGE_${location.toUpperCase()}_`);
+        const { driver, ...options } = driverConfig;
+        storage.registerLocation(location, { driver, options });
+    });
+};

package/dist/storage/register-locations.test.d.ts

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

package/dist/types/assets.d.ts

@@ -0,0 +1,15 @@
+import type { ResizeOptions, Sharp } from 'sharp';
+export declare const TransformationMethods: readonly ["toFormat", "jpeg", "png", "tiff", "webp", "avif", "resize", "extend", "extract", "trim", "rotate", "flip", "flop", "sharpen", "median", "blur", "flatten", "gamma", "negate", "normalise", "normalize", "clahe", "convolve", "threshold", "linear", "recomb", "modulate", "tint", "greyscale", "grayscale", "toColorspace", "toColourspace", "removeAlpha", "ensureAlpha", "extractChannel", "bandbool"];
+type AllowedSharpMethods = Pick<Sharp, (typeof TransformationMethods)[number]>;
+export type TransformationMap = {
+    [M in keyof AllowedSharpMethods]: readonly [M, ...Parameters<AllowedSharpMethods[M]>];
+};
+export type Transformation = TransformationMap[keyof TransformationMap];
+export type TransformationResize = Pick<ResizeOptions, 'width' | 'height' | 'fit' | 'withoutEnlargement'>;
+export type TransformationParams = {
+    key?: string;
+    transforms?: Transformation[];
+    format?: 'auto' | 'jpg' | 'jpeg' | 'png' | 'webp' | 'tiff' | 'avif';
+    quality?: number;
+} & TransformationResize;
+export {};

package/dist/types/assets.js

@@ -0,0 +1,51 @@
+// List of allowed sharp methods to expose.
+//
+// This is a literal, so we can use it to validate request parameters.
+export const TransformationMethods /*: readonly (keyof Sharp)[]*/ = [
+    // Output options
+    // https://sharp.pixelplumbing.com/api-output
+    'toFormat',
+    'jpeg',
+    'png',
+    'tiff',
+    'webp',
+    'avif',
+    // Resizing
+    // https://sharp.pixelplumbing.com/api-resize
+    'resize',
+    'extend',
+    'extract',
+    'trim',
+    // Image operations
+    // https://sharp.pixelplumbing.com/api-operation
+    'rotate',
+    'flip',
+    'flop',
+    'sharpen',
+    'median',
+    'blur',
+    'flatten',
+    'gamma',
+    'negate',
+    'normalise',
+    'normalize',
+    'clahe',
+    'convolve',
+    'threshold',
+    'linear',
+    'recomb',
+    'modulate',
+    // Color manipulation
+    // https://sharp.pixelplumbing.com/api-colour
+    'tint',
+    'greyscale',
+    'grayscale',
+    'toColorspace',
+    'toColourspace',
+    // Channel manipulation
+    // https://sharp.pixelplumbing.com/api-channel
+    'removeAlpha',
+    'ensureAlpha',
+    'extractChannel',
+    'bandbool',
+];

package/dist/types/ast.d.ts

@@ -0,0 +1,56 @@
+import type { Query, Relation } from '@directus/types';
+export type M2ONode = {
+    type: 'm2o';
+    name: string;
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
+    query: Query;
+    fieldKey: string;
+    relation: Relation;
+    parentKey: string;
+    relatedKey: string;
+};
+export type A2MNode = {
+    type: 'a2o';
+    names: string[];
+    children: {
+        [collection: string]: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
+    };
+    query: {
+        [collection: string]: Query;
+    };
+    relatedKey: {
+        [collection: string]: string;
+    };
+    fieldKey: string;
+    relation: Relation;
+    parentKey: string;
+};
+export type O2MNode = {
+    type: 'o2m';
+    name: string;
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
+    query: Query;
+    fieldKey: string;
+    relation: Relation;
+    parentKey: string;
+    relatedKey: string;
+};
+export type NestedCollectionNode = M2ONode | O2MNode | A2MNode;
+export type FieldNode = {
+    type: 'field';
+    name: string;
+    fieldKey: string;
+};
+export type FunctionFieldNode = {
+    type: 'functionField';
+    name: string;
+    fieldKey: string;
+    query: Query;
+    relatedCollection: string;
+};
+export type AST = {
+    type: 'root';
+    name: string;
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
+    query: Query;
+};

package/dist/types/ast.js

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

package/dist/types/auth.d.ts

@@ -0,0 +1,54 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export interface AuthDriverOptions {
+    knex: Knex;
+    schema: SchemaOverview;
+}
+export interface User {
+    id: string;
+    first_name: string | null;
+    last_name: string | null;
+    email: string | null;
+    password: string | null;
+    status: 'active' | 'suspended' | 'invited';
+    role: string | null;
+    provider: string;
+    external_identifier: string | null;
+    auth_data: string | Record<string, unknown> | null;
+    app_access: boolean;
+    admin_access: boolean;
+}
+export type AuthData = Record<string, any> | null;
+export interface Session {
+    token: string;
+    expires: Date;
+    share: string;
+}
+export type DirectusTokenPayload = {
+    id?: string;
+    role: string | null;
+    app_access: boolean | number;
+    admin_access: boolean | number;
+    share?: string;
+    share_scope?: {
+        collection: string;
+        item: string;
+    };
+};
+export type ShareData = {
+    share_id: string;
+    share_role: string;
+    share_item: string;
+    share_collection: string;
+    share_start: Date;
+    share_end: Date;
+    share_times_used: number;
+    share_max_uses?: number;
+    share_password?: string;
+};
+export type LoginResult = {
+    accessToken: any;
+    refreshToken: any;
+    expires: any;
+    id?: any;
+};

package/dist/types/auth.js

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

package/dist/types/collection.d.ts

@@ -0,0 +1,19 @@
+import type { Field } from '@directus/types';
+import type { Table } from '@directus/schema';
+export type CollectionMeta = {
+    collection: string;
+    note: string | null;
+    hidden: boolean;
+    singleton: boolean;
+    icon: string | null;
+    translations: Record<string, string>;
+    item_duplication_fields: string[] | null;
+    accountability: 'all' | 'accountability' | null;
+    group: string | null;
+};
+export type Collection = {
+    collection: string;
+    fields?: Field[];
+    meta: CollectionMeta | null;
+    schema: Table | null;
+};

package/dist/types/collection.js

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

package/dist/types/database.d.ts

@@ -0,0 +1,3 @@
+export type Driver = 'mysql' | 'pg' | 'cockroachdb' | 'sqlite3' | 'oracledb' | 'mssql';
+export declare const DatabaseClients: readonly ["mysql", "postgres", "cockroachdb", "sqlite", "oracle", "mssql", "redshift"];
+export type DatabaseClient = (typeof DatabaseClients)[number];

package/dist/types/database.js

@@ -0,0 +1 @@
+export const DatabaseClients = ['mysql', 'postgres', 'cockroachdb', 'sqlite', 'oracle', 'mssql', 'redshift'];

package/dist/types/events.d.ts

@@ -0,0 +1,18 @@
+import type { ActionHandler, FilterHandler, InitHandler } from '@directus/types';
+import type { ScheduledTask } from 'node-cron';
+export type EventHandler = {
+    type: 'filter';
+    name: string;
+    handler: FilterHandler;
+} | {
+    type: 'action';
+    name: string;
+    handler: ActionHandler;
+} | {
+    type: 'init';
+    name: string;
+    handler: InitHandler;
+} | {
+    type: 'schedule';
+    task: ScheduledTask;
+};

package/dist/types/events.js

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

package/dist/types/files.d.ts

@@ -0,0 +1,29 @@
+export type File = {
+    id: string;
+    storage: string;
+    filename_disk: string;
+    filename_download: string;
+    title: string | null;
+    type: string | null;
+    folder: string | null;
+    uploaded_by: string | null;
+    uploaded_on: Date;
+    charset: string | null;
+    filesize: number;
+    width: number | null;
+    height: number | null;
+    duration: number | null;
+    embed: string | null;
+    description: string | null;
+    location: string | null;
+    tags: string | null;
+    metadata: Record<string, any> | null;
+};
+export type Metadata = {
+    height?: number | undefined;
+    width?: number | undefined;
+    description?: string | undefined;
+    title?: string | undefined;
+    tags?: any | undefined;
+    metadata?: any | undefined;
+};

package/dist/types/files.js

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

package/dist/types/graphql.d.ts

@@ -0,0 +1,14 @@
+import type { Request, Response } from 'express';
+import type { DocumentNode } from 'graphql';
+export interface GraphQLParams {
+    query: string | null;
+    variables: {
+        readonly [name: string]: unknown;
+    } | null;
+    operationName: string | null;
+    document: DocumentNode;
+    contextValue: {
+        req?: Request;
+        res?: Response;
+    };
+}

package/dist/types/graphql.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+export * from './assets.js';
+export * from './ast.js';
+export * from './auth.js';
+export * from './collection.js';
+export * from './database.js';
+export * from './events.js';
+export * from './files.js';
+export * from './graphql.js';
+export * from './items.js';
+export * from './meta.js';
+export * from './migration.js';
+export * from './revision.js';
+export * from './services.js';
+export * from './snapshot.js';
+export * from './webhooks.js';

package/dist/types/index.js

@@ -0,0 +1,15 @@
+export * from './assets.js';
+export * from './ast.js';
+export * from './auth.js';
+export * from './collection.js';
+export * from './database.js';
+export * from './events.js';
+export * from './files.js';
+export * from './graphql.js';
+export * from './items.js';
+export * from './meta.js';
+export * from './migration.js';
+export * from './revision.js';
+export * from './services.js';
+export * from './snapshot.js';
+export * from './webhooks.js';

package/dist/types/items.d.ts

@@ -0,0 +1,55 @@
+/**
+ * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
+ * expecting an item vs any other generic object.
+ */
+import type { BaseException } from '@directus/exceptions';
+import type { EventContext } from '@directus/types';
+import type { MutationTracker } from '../services/items.js';
+export type Item = Record<string, any>;
+export type PrimaryKey = string | number;
+export type Alterations = {
+    create: {
+        [key: string]: any;
+    }[];
+    update: {
+        [key: string]: any;
+    }[];
+    delete: (number | string)[];
+};
+export type MutationOptions = {
+    /**
+     * Callback function that's fired whenever a revision is made in the mutation
+     */
+    onRevisionCreate?: ((pk: PrimaryKey) => void) | undefined;
+    /**
+     * Flag to disable the auto purging of the cache. Is ignored when CACHE_AUTO_PURGE isn't enabled.
+     */
+    autoPurgeCache?: false | undefined;
+    /**
+     * Flag to disable the auto purging of the system cache.
+     */
+    autoPurgeSystemCache?: false | undefined;
+    /**
+     * Allow disabling the emitting of hooks. Useful if a custom hook is fired (like files.upload)
+     */
+    emitEvents?: boolean | undefined;
+    /**
+     * To bypass the emitting of action events if emitEvents is enabled
+     * Can be used to queue up the nested events from item service's create, update and delete
+     */
+    bypassEmitAction?: ((params: ActionEventParams) => void) | undefined;
+    /**
+     * To bypass limits so that functions would work as intended
+     */
+    bypassLimits?: boolean | undefined;
+    /**
+     * To keep track of mutation limits
+     */
+    mutationTracker?: MutationTracker | undefined;
+    preMutationException?: BaseException | undefined;
+};
+export type ActionEventParams = {
+    event: string | string[];
+    meta: Record<string, any>;
+    context: EventContext;
+};

package/dist/types/items.js

@@ -0,0 +1,5 @@
+/**
+ * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
+ * expecting an item vs any other generic object.
+ */
+export {};

package/dist/types/meta.d.ts

@@ -0,0 +1,4 @@
+export declare enum Meta {
+    TOTAL_COUNT = "total_count",
+    FILTER_COUNT = "filter_count"
+}

package/dist/types/meta.js

@@ -0,0 +1,5 @@
+export var Meta;
+(function (Meta) {
+    Meta["TOTAL_COUNT"] = "total_count";
+    Meta["FILTER_COUNT"] = "filter_count";
+})(Meta || (Meta = {}));

package/dist/types/migration.d.ts

@@ -0,0 +1,5 @@
+export type Migration = {
+    version: string;
+    name: string;
+    timestamp: Date;
+};

package/dist/types/migration.js

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

package/dist/types/revision.d.ts

@@ -0,0 +1,7 @@
+export type Revision = {
+    activity: number;
+    collection: string;
+    item: string | number;
+    data: null | Record<string, any>;
+    delta: null | Record<string, any>;
+};

package/dist/types/revision.js

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

package/dist/types/services.d.ts

@@ -0,0 +1,21 @@
+import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { Item, PrimaryKey } from './items.js';
+export type AbstractServiceOptions = {
+    knex?: Knex;
+    accountability?: Accountability | null | undefined;
+    schema: SchemaOverview;
+};
+export interface AbstractService {
+    knex: Knex;
+    accountability: Accountability | null | undefined;
+    createOne(data: Partial<Item>): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[]): Promise<PrimaryKey[]>;
+    readOne(key: PrimaryKey, query?: Query): Promise<Item>;
+    readMany(keys: PrimaryKey[], query?: Query): Promise<Item[]>;
+    readByQuery(query: Query): Promise<Item[]>;
+    updateOne(key: PrimaryKey, data: Partial<Item>): Promise<PrimaryKey>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>): Promise<PrimaryKey[]>;
+    deleteOne(key: PrimaryKey): Promise<PrimaryKey>;
+    deleteMany(keys: PrimaryKey[]): Promise<PrimaryKey[]>;
+}

package/dist/types/services.js

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

package/dist/types/snapshot.d.ts

@@ -0,0 +1,55 @@
+import type { Field, FieldMeta, Relation, RelationMeta } from '@directus/types';
+import type { Diff } from 'deep-diff';
+import type { Collection } from './collection.js';
+import type { DatabaseClient } from './database.js';
+export type Snapshot = {
+    version: number;
+    directus: string;
+    vendor?: DatabaseClient;
+    collections: Collection[];
+    fields: SnapshotField[];
+    relations: SnapshotRelation[];
+};
+export type SnapshotField = Field & {
+    meta: Omit<FieldMeta, 'id'>;
+};
+export type SnapshotRelation = Relation & {
+    meta: Omit<RelationMeta, 'id'>;
+};
+export type SnapshotWithHash = Snapshot & {
+    hash: string;
+};
+export type SnapshotDiff = {
+    collections: {
+        collection: string;
+        diff: Diff<Collection | undefined>[];
+    }[];
+    fields: {
+        collection: string;
+        field: string;
+        diff: Diff<SnapshotField | undefined>[];
+    }[];
+    relations: {
+        collection: string;
+        field: string;
+        related_collection: string | null;
+        diff: Diff<SnapshotRelation | undefined>[];
+    }[];
+};
+export type SnapshotDiffWithHash = {
+    hash: string;
+    diff: SnapshotDiff;
+};
+/**
+ * Indicates the kind of change based on comparisons by deep-diff package
+ */
+export declare const DiffKind: {
+    /** indicates a newly added property/element */
+    readonly NEW: "N";
+    /** indicates a property/element was deleted */
+    readonly DELETE: "D";
+    /** indicates a property/element was edited */
+    readonly EDIT: "E";
+    /** indicates a change occurred within an array */
+    readonly ARRAY: "A";
+};

package/dist/types/snapshot.js

@@ -0,0 +1,13 @@
+/**
+ * Indicates the kind of change based on comparisons by deep-diff package
+ */
+export const DiffKind = {
+    /** indicates a newly added property/element */
+    NEW: 'N',
+    /** indicates a property/element was deleted */
+    DELETE: 'D',
+    /** indicates a property/element was edited */
+    EDIT: 'E',
+    /** indicates a change occurred within an array */
+    ARRAY: 'A',
+};

package/dist/types/webhooks.d.ts

@@ -0,0 +1,15 @@
+export type Webhook = {
+    id: number;
+    name: string;
+    method: 'GET' | 'POST';
+    url: string;
+    status: 'active' | 'inactive';
+    data: boolean;
+    actions: string[];
+    collections: string[];
+    headers: WebhookHeader[];
+};
+export type WebhookHeader = {
+    header: string;
+    value: string;
+};

package/dist/types/webhooks.js

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