@directus/api 9.25.0

package/dist/services/files.js

@@ -0,0 +1,273 @@
+import formatTitle from '@directus/format-title';
+import { toArray } from '@directus/utils';
+import encodeURL from 'encodeurl';
+import exif from 'exif-reader';
+import { parse as parseIcc } from 'icc';
+import { clone, pick } from 'lodash-es';
+import { extension } from 'mime-types';
+import { pipeline } from 'node:stream/promises';
+import path from 'path';
+import sharp from 'sharp';
+import url from 'url';
+import { SUPPORTED_IMAGE_METADATA_FORMATS } from '../constants.js';
+import emitter from '../emitter.js';
+import env from '../env.js';
+import { ForbiddenException, InvalidPayloadException, ServiceUnavailableException } from '../exceptions/index.js';
+import logger from '../logger.js';
+import { getAxios } from '../request/index.js';
+import { getStorage } from '../storage/index.js';
+import { parseIptc, parseXmp } from '../utils/parse-image-metadata.js';
+import { ItemsService } from './items.js';
+export class FilesService extends ItemsService {
+    constructor(options) {
+        super('directus_files', options);
+    }
+    /**
+     * Upload a single new file to the configured storage adapter
+     */
+    async uploadOne(stream, data, primaryKey, opts) {
+        const storage = await getStorage();
+        let existingFile = {};
+        if (primaryKey !== undefined) {
+            existingFile =
+                (await this.knex
+                    .select('folder', 'filename_download')
+                    .from('directus_files')
+                    .where({ id: primaryKey })
+                    .first()) ?? {};
+        }
+        const payload = { ...existingFile, ...clone(data) };
+        if ('folder' in payload === false) {
+            const settings = await this.knex.select('storage_default_folder').from('directus_settings').first();
+            if (settings?.storage_default_folder) {
+                payload.folder = settings.storage_default_folder;
+            }
+        }
+        if (primaryKey !== undefined) {
+            await this.updateOne(primaryKey, payload, { emitEvents: false });
+            // If the file you're uploading already exists, we'll consider this upload a replace. In that case, we'll
+            // delete the previously saved file and thumbnails to ensure they're generated fresh
+            const disk = storage.location(payload.storage);
+            for await (const filepath of disk.list(String(primaryKey))) {
+                await disk.delete(filepath);
+            }
+        }
+        else {
+            primaryKey = await this.createOne(payload, { emitEvents: false });
+        }
+        const fileExtension = path.extname(payload.filename_download) || (payload.type && '.' + extension(payload.type)) || '';
+        payload.filename_disk = primaryKey + (fileExtension || '');
+        if (!payload.type) {
+            payload.type = 'application/octet-stream';
+        }
+        try {
+            await storage.location(data.storage).write(payload.filename_disk, stream, payload.type);
+        }
+        catch (err) {
+            logger.warn(`Couldn't save file ${payload.filename_disk}`);
+            logger.warn(err);
+            throw new ServiceUnavailableException(`Couldn't save file ${payload.filename_disk}`, { service: 'files' });
+        }
+        const { size } = await storage.location(data.storage).stat(payload.filename_disk);
+        payload.filesize = size;
+        if (SUPPORTED_IMAGE_METADATA_FORMATS.includes(payload.type)) {
+            const stream = await storage.location(data.storage).read(payload.filename_disk);
+            const { height, width, description, title, tags, metadata } = await this.getMetadata(stream);
+            payload.height ??= height ?? null;
+            payload.width ??= width ?? null;
+            payload.description ??= description ?? null;
+            payload.title ??= title ?? null;
+            payload.tags ??= tags ?? null;
+            payload.metadata ??= metadata ?? null;
+        }
+        // We do this in a service without accountability. Even if you don't have update permissions to the file,
+        // we still want to be able to set the extracted values from the file on create
+        const sudoService = new ItemsService('directus_files', {
+            knex: this.knex,
+            schema: this.schema,
+        });
+        await sudoService.updateOne(primaryKey, payload, { emitEvents: false });
+        if (this.cache && env['CACHE_AUTO_PURGE'] && opts?.autoPurgeCache !== false) {
+            await this.cache.clear();
+        }
+        if (opts?.emitEvents !== false) {
+            emitter.emitAction('files.upload', {
+                payload,
+                key: primaryKey,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
+        return primaryKey;
+    }
+    /**
+     * Extract metadata from a buffer's content
+     */
+    async getMetadata(stream, allowList = env['FILE_METADATA_ALLOW_LIST']) {
+        return new Promise((resolve, reject) => {
+            pipeline(stream, sharp().metadata(async (err, sharpMetadata) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const metadata = {};
+                if (sharpMetadata.orientation && sharpMetadata.orientation >= 5) {
+                    metadata.height = sharpMetadata.width;
+                    metadata.width = sharpMetadata.height;
+                }
+                else {
+                    metadata.width = sharpMetadata.width;
+                    metadata.height = sharpMetadata.height;
+                }
+                // Backward-compatible layout as it used to be with 'exifr'
+                const fullMetadata = {};
+                if (sharpMetadata.exif) {
+                    try {
+                        const { image, thumbnail, interoperability, ...rest } = exif(sharpMetadata.exif);
+                        if (image) {
+                            fullMetadata.ifd0 = image;
+                        }
+                        if (thumbnail) {
+                            fullMetadata.ifd1 = thumbnail;
+                        }
+                        if (interoperability) {
+                            fullMetadata.interop = interoperability;
+                        }
+                        Object.assign(fullMetadata, rest);
+                    }
+                    catch (err) {
+                        logger.warn(`Couldn't extract EXIF metadata from file`);
+                        logger.warn(err);
+                    }
+                }
+                if (sharpMetadata.icc) {
+                    try {
+                        fullMetadata.icc = parseIcc(sharpMetadata.icc);
+                    }
+                    catch (err) {
+                        logger.warn(`Couldn't extract ICC profile data from file`);
+                        logger.warn(err);
+                    }
+                }
+                if (sharpMetadata.iptc) {
+                    try {
+                        fullMetadata.iptc = parseIptc(sharpMetadata.iptc);
+                    }
+                    catch (err) {
+                        logger.warn(`Couldn't extract IPTC Photo Metadata from file`);
+                        logger.warn(err);
+                    }
+                }
+                if (sharpMetadata.xmp) {
+                    try {
+                        fullMetadata.xmp = parseXmp(sharpMetadata.xmp);
+                    }
+                    catch (err) {
+                        logger.warn(`Couldn't extract XMP data from file`);
+                        logger.warn(err);
+                    }
+                }
+                if (fullMetadata?.iptc?.['Caption'] && typeof fullMetadata.iptc['Caption'] === 'string') {
+                    metadata.description = fullMetadata.iptc?.['Caption'];
+                }
+                if (fullMetadata?.iptc?.['Headline'] && typeof fullMetadata.iptc['Headline'] === 'string') {
+                    metadata.title = fullMetadata.iptc['Headline'];
+                }
+                if (fullMetadata?.iptc?.['Keywords']) {
+                    metadata.tags = fullMetadata.iptc['Keywords'];
+                }
+                if (allowList === '*' || allowList?.[0] === '*') {
+                    metadata.metadata = fullMetadata;
+                }
+                else {
+                    metadata.metadata = pick(fullMetadata, allowList);
+                }
+                // Fix (incorrectly parsed?) values starting / ending with spaces,
+                // limited to one level and string values only
+                for (const section of Object.keys(metadata.metadata)) {
+                    for (const [key, value] of Object.entries(metadata.metadata[section])) {
+                        if (typeof value === 'string') {
+                            metadata.metadata[section][key] = value.trim();
+                        }
+                    }
+                }
+                resolve(metadata);
+            }));
+        });
+    }
+    /**
+     * Import a single file from an external URL
+     */
+    async importOne(importURL, body) {
+        const fileCreatePermissions = this.accountability?.permissions?.find((permission) => permission.collection === 'directus_files' && permission.action === 'create');
+        if (this.accountability && this.accountability?.admin !== true && !fileCreatePermissions) {
+            throw new ForbiddenException();
+        }
+        let fileResponse;
+        try {
+            const axios = await getAxios();
+            fileResponse = await axios.get(encodeURL(importURL), {
+                responseType: 'stream',
+            });
+        }
+        catch (err) {
+            logger.warn(err, `Couldn't fetch file from URL "${importURL}"`);
+            throw new ServiceUnavailableException(`Couldn't fetch file from url "${importURL}"`, {
+                service: 'external-file',
+            });
+        }
+        const parsedURL = url.parse(fileResponse.request.res.responseUrl);
+        const filename = decodeURI(path.basename(parsedURL.pathname));
+        const payload = {
+            filename_download: filename,
+            storage: toArray(env['STORAGE_LOCATIONS'])[0],
+            type: fileResponse.headers['content-type'],
+            title: formatTitle(filename),
+            ...(body || {}),
+        };
+        return await this.uploadOne(fileResponse.data, payload);
+    }
+    /**
+     * Create a file (only applicable when it is not a multipart/data POST request)
+     * Useful for associating metadata with existing file in storage
+     */
+    async createOne(data, opts) {
+        if (!data.type) {
+            throw new InvalidPayloadException(`"type" is required`);
+        }
+        const key = await super.createOne(data, opts);
+        return key;
+    }
+    /**
+     * Delete a file
+     */
+    async deleteOne(key, opts) {
+        await this.deleteMany([key], opts);
+        return key;
+    }
+    /**
+     * Delete multiple files
+     */
+    async deleteMany(keys, opts) {
+        const storage = await getStorage();
+        const files = await super.readMany(keys, { fields: ['id', 'storage'], limit: -1 });
+        if (!files) {
+            throw new ForbiddenException();
+        }
+        await super.deleteMany(keys);
+        for (const file of files) {
+            const disk = storage.location(file['storage']);
+            // Delete file + thumbnails
+            for await (const filepath of disk.list(file['id'])) {
+                await disk.delete(filepath);
+            }
+        }
+        if (this.cache && env['CACHE_AUTO_PURGE'] && opts?.autoPurgeCache !== false) {
+            await this.cache.clear();
+        }
+        return keys;
+    }
+}

package/dist/services/files.test.d.ts

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

package/dist/services/flows.d.ts

@@ -0,0 +1,11 @@
+import type { FlowRaw } from '@directus/types';
+import type { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types/index.js';
+import { ItemsService } from './items.js';
+export declare class FlowsService extends ItemsService<FlowRaw> {
+    constructor(options: AbstractServiceOptions);
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateBatch(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+}

package/dist/services/flows.js

@@ -0,0 +1,39 @@
+import { getFlowManager } from '../flows.js';
+import { ItemsService } from './items.js';
+export class FlowsService extends ItemsService {
+    constructor(options) {
+        super('directus_flows', options);
+    }
+    async createOne(data, opts) {
+        const flowManager = getFlowManager();
+        const result = await super.createOne(data, opts);
+        await flowManager.reload();
+        return result;
+    }
+    async createMany(data, opts) {
+        const flowManager = getFlowManager();
+        const result = await super.createMany(data, opts);
+        await flowManager.reload();
+        return result;
+    }
+    async updateBatch(data, opts) {
+        const flowManager = getFlowManager();
+        const result = await super.updateBatch(data, opts);
+        await flowManager.reload();
+        return result;
+    }
+    async updateMany(keys, data, opts) {
+        const flowManager = getFlowManager();
+        const result = await super.updateMany(keys, data, opts);
+        await flowManager.reload();
+        return result;
+    }
+    async deleteMany(keys, opts) {
+        const flowManager = getFlowManager();
+        // this is to prevent foreign key constraint error on directus_operations resolve/reject during cascade deletion
+        await this.knex('directus_operations').update({ resolve: null, reject: null }).whereIn('flow', keys);
+        const result = await super.deleteMany(keys, opts);
+        await flowManager.reload();
+        return result;
+    }
+}

package/dist/services/folders.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractServiceOptions } from '../types/index.js';
+import { ItemsService } from './items.js';
+export declare class FoldersService extends ItemsService {
+    constructor(options: AbstractServiceOptions);
+}

package/dist/services/folders.js

@@ -0,0 +1,6 @@
+import { ItemsService } from './items.js';
+export class FoldersService extends ItemsService {
+    constructor(options) {
+        super('directus_folders', options);
+    }
+}

package/dist/services/graphql/index.d.ts

@@ -0,0 +1,86 @@
+import type { BaseException } from '@directus/exceptions';
+import type { Accountability, Filter, Query, SchemaOverview } from '@directus/types';
+import { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLError, GraphQLResolveInfo, GraphQLSchema, SelectionNode } from 'graphql';
+import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, GraphQLParams, Item } from '../../types/index.js';
+import { ItemsService } from '../items.js';
+export declare class GraphQLService {
+    accountability: Accountability | null;
+    knex: Knex;
+    schema: SchemaOverview;
+    scope: 'items' | 'system';
+    constructor(options: AbstractServiceOptions & {
+        scope: 'items' | 'system';
+    });
+    /**
+     * Execute a GraphQL structure
+     */
+    execute({ document, variables, operationName, contextValue, }: GraphQLParams): Promise<FormattedExecutionResult>;
+    /**
+     * Generate the GraphQL schema. Pulls from the schema information generated by the get-schema util.
+     */
+    getSchema(): GraphQLSchema;
+    getSchema(type: 'schema'): GraphQLSchema;
+    getSchema(type: 'sdl'): GraphQLSchema | string;
+    /**
+     * Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
+     * Directus' query structure which is then executed by the services.
+     */
+    resolveQuery(info: GraphQLResolveInfo): Promise<Partial<Item> | null>;
+    resolveMutation(args: Record<string, any>, info: GraphQLResolveInfo): Promise<Partial<Item> | boolean | undefined>;
+    /**
+     * Execute the read action on the correct service. Checks for singleton as well.
+     */
+    read(collection: string, query: Query): Promise<Partial<Item>>;
+    /**
+     * Upsert and read singleton item
+     */
+    upsertSingleton(collection: string, body: Record<string, any> | Record<string, any>[], query: Query): Promise<Partial<Item> | boolean>;
+    /**
+     * GraphQL's regular resolver `args` variable only contains the "top-level" arguments. Seeing that we convert the
+     * whole nested tree into one big query using Directus' own query resolver, we want to have a nested structure of
+     * arguments for the whole resolving tree, which can later be transformed into Directus' AST using `deep`.
+     * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
+     * of arguments
+     */
+    parseArgs(args: readonly ArgumentNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;
+    /**
+     * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
+     * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
+     */
+    getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues']): Query;
+    /**
+     * Resolve the aggregation query based on the requested aggregated fields
+     */
+    getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[]): Query;
+    /**
+     * Replace functions from GraphQL format to Directus-Filter format
+     */
+    replaceFuncs(filter: Filter): Filter;
+    /**
+     * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
+     */
+    formatError(error: BaseException | BaseException[]): GraphQLError;
+    /**
+     * Select the correct service for the given collection. This allows the individual services to run
+     * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
+     */
+    getService(collection: string): ItemsService;
+    /**
+     * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
+     * Effectively merges the selections with the fragments used in those selections
+     */
+    replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;
+    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes, }: {
+        CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+        ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+        UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+        DeleteCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
+    }, schema: {
+        create: SchemaOverview;
+        read: SchemaOverview;
+        update: SchemaOverview;
+        delete: SchemaOverview;
+    }): SchemaComposer<any>;
+}