@directus/api 9.25.0

package/dist/services/graphql/types/bigint.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLBigInt: GraphQLScalarType<string | number, unknown>;

package/dist/services/graphql/types/bigint.js

@@ -0,0 +1,36 @@
+import { GraphQLScalarType, Kind } from 'graphql';
+export const GraphQLBigInt = new GraphQLScalarType({
+    name: 'GraphQLBigInt',
+    description: 'BigInt value',
+    serialize(value) {
+        if (!value)
+            return value;
+        if (typeof value === 'string')
+            return value;
+        if (typeof value !== 'number') {
+            throw new Error('Value must be a Number');
+        }
+        return value.toString();
+    },
+    parseValue(value) {
+        if (typeof value !== 'string') {
+            throw new Error('Value must be a String');
+        }
+        return parseNumberValue(value);
+    },
+    parseLiteral(ast) {
+        if (ast.kind !== Kind.STRING) {
+            throw new Error('Value must be a String');
+        }
+        return parseNumberValue(ast.value);
+    },
+});
+function parseNumberValue(input) {
+    if (!/[+-]?([0-9]+[.])?[0-9]+/.test(input))
+        return input;
+    const value = parseInt(input);
+    if (isNaN(value) || value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
+        throw new Error('Invalid GraphQLBigInt');
+    }
+    return value;
+}

package/dist/services/graphql/types/date.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLDate: GraphQLScalarType<string, string>;

package/dist/services/graphql/types/date.js

@@ -0,0 +1,6 @@
+import { GraphQLString, GraphQLScalarType } from 'graphql';
+export const GraphQLDate = new GraphQLScalarType({
+    ...GraphQLString,
+    name: 'Date',
+    description: 'ISO8601 Date values',
+});

package/dist/services/graphql/types/geojson.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLGeoJSON: GraphQLScalarType<unknown, unknown>;

package/dist/services/graphql/types/geojson.js

@@ -0,0 +1,7 @@
+import { GraphQLScalarType } from 'graphql';
+import { GraphQLJSON } from 'graphql-compose';
+export const GraphQLGeoJSON = new GraphQLScalarType({
+    ...GraphQLJSON,
+    name: 'GraphQLGeoJSON',
+    description: 'GeoJSON value',
+});

package/dist/services/graphql/types/hash.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLHash: GraphQLScalarType<string, string>;

package/dist/services/graphql/types/hash.js

@@ -0,0 +1,6 @@
+import { GraphQLString, GraphQLScalarType } from 'graphql';
+export const GraphQLHash = new GraphQLScalarType({
+    ...GraphQLString,
+    name: 'Hash',
+    description: 'Hashed string values',
+});

package/dist/services/graphql/types/string-or-float.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLScalarType } from 'graphql';
+/**
+ * Adopted from https://kamranicus.com/handling-multiple-scalar-types-in-graphql/
+ */
+export declare const GraphQLStringOrFloat: GraphQLScalarType<string | number, string | number>;

package/dist/services/graphql/types/string-or-float.js

@@ -0,0 +1,31 @@
+import { GraphQLScalarType, Kind } from 'graphql';
+/**
+ * Adopted from https://kamranicus.com/handling-multiple-scalar-types-in-graphql/
+ */
+export const GraphQLStringOrFloat = new GraphQLScalarType({
+    name: 'GraphQLStringOrFloat',
+    description: 'A Float or a String',
+    serialize(value) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new Error('Value must be either a String or a Float');
+        }
+        return value;
+    },
+    parseValue(value) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new Error('Value must be either a String or a Float');
+        }
+        return value;
+    },
+    parseLiteral(ast) {
+        switch (ast.kind) {
+            case Kind.INT:
+            case Kind.FLOAT:
+                return Number(ast.value);
+            case Kind.STRING:
+                return ast.value;
+            default:
+                throw new Error('Value must be either a String or a Float');
+        }
+    },
+});

package/dist/services/graphql/types/void.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLVoid: GraphQLScalarType<null, null>;

package/dist/services/graphql/types/void.js

@@ -0,0 +1,14 @@
+import { GraphQLScalarType } from 'graphql';
+export const GraphQLVoid = new GraphQLScalarType({
+    name: 'Void',
+    description: 'Represents NULL values',
+    serialize() {
+        return null;
+    },
+    parseValue() {
+        return null;
+    },
+    parseLiteral() {
+        return null;
+    },
+});

package/dist/services/graphql/utils/add-path-to-validation-error.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLError } from 'graphql';
+export declare function addPathToValidationError(validationError: GraphQLError): GraphQLError;

package/dist/services/graphql/utils/add-path-to-validation-error.js

@@ -0,0 +1,15 @@
+import { locatedError } from 'graphql';
+export function addPathToValidationError(validationError) {
+    const token = validationError.nodes?.[0]?.loc?.startToken;
+    if (!token)
+        return validationError;
+    let prev = token;
+    const queryRegex = /query_[A-Za-z0-9]{8}/;
+    while (prev) {
+        if (prev.kind === 'Name' && prev.value && queryRegex.test(prev.value)) {
+            return locatedError(validationError, validationError.nodes, [prev.value]);
+        }
+        prev = prev.prev;
+    }
+    return locatedError(validationError, validationError.nodes);
+}

package/dist/services/graphql/utils/process-error.d.ts

@@ -0,0 +1,4 @@
+import type { Accountability } from '@directus/types';
+import type { GraphQLError, GraphQLFormattedError } from 'graphql';
+declare const processError: (accountability: Accountability | null, error: Readonly<GraphQLError>) => GraphQLFormattedError;
+export default processError;

package/dist/services/graphql/utils/process-error.js

@@ -0,0 +1,41 @@
+import { BaseException } from '@directus/exceptions';
+import logger from '../../../logger.js';
+const processError = (accountability, error) => {
+    logger.error(error);
+    const { originalError } = error;
+    if (originalError instanceof BaseException) {
+        return {
+            message: originalError.message,
+            extensions: {
+                code: originalError.code,
+                ...originalError.extensions,
+            },
+        };
+    }
+    else {
+        if (accountability?.admin === true) {
+            const graphqlFormattedError = {
+                message: error.message,
+                extensions: {
+                    code: 'INTERNAL_SERVER_ERROR',
+                },
+            };
+            if (error.locations) {
+                graphqlFormattedError.locations = error.locations;
+            }
+            if (error.path) {
+                graphqlFormattedError.path = error.path;
+            }
+            return graphqlFormattedError;
+        }
+        else {
+            return {
+                message: 'An unexpected error occurred.',
+                extensions: {
+                    code: 'INTERNAL_SERVER_ERROR',
+                },
+            };
+        }
+    }
+};
+export default processError;

package/dist/services/graphql/utils/process-error.test.d.ts

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

package/dist/services/import-export.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Accountability, Query, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { Readable } from 'node:stream';
+import type { AbstractServiceOptions, File } from '../types/index.js';
+type ExportFormat = 'csv' | 'json' | 'xml' | 'yaml';
+export declare class ImportService {
+    knex: Knex;
+    accountability: Accountability | null;
+    schema: SchemaOverview;
+    constructor(options: AbstractServiceOptions);
+    import(collection: string, mimetype: string, stream: Readable): Promise<void>;
+    importJSON(collection: string, stream: Readable): Promise<void>;
+    importCSV(collection: string, stream: Readable): Promise<void>;
+}
+export declare class ExportService {
+    knex: Knex;
+    accountability: Accountability | null;
+    schema: SchemaOverview;
+    constructor(options: AbstractServiceOptions);
+    /**
+     * Export the query results as a named file. Will query in batches, and keep appending a tmp file
+     * until all the data is retrieved. Uploads the result as a new file using the regular
+     * FilesService upload method.
+     */
+    exportToFile(collection: string, query: Partial<Query>, format: ExportFormat, options?: {
+        file?: Partial<File>;
+    }): Promise<void>;
+    /**
+     * Transform a given input object / array to the given type
+     */
+    transform(input: Record<string, any>[], format: ExportFormat, options?: {
+        includeHeader?: boolean;
+        includeFooter?: boolean;
+    }): string;
+}
+export {};

package/dist/services/import-export.js

@@ -0,0 +1,293 @@
+import { parseJSON, toArray } from '@directus/utils';
+import { queue } from 'async';
+import csv from 'csv-parser';
+import destroyStream from 'destroy';
+import { dump as toYAML } from 'js-yaml';
+import { parse as toXML } from 'js2xmlparser';
+import { Parser as CSVParser, transforms as CSVTransforms } from 'json2csv';
+import { set, transform } from 'lodash-es';
+import { createReadStream } from 'node:fs';
+import { appendFile } from 'node:fs/promises';
+import StreamArray from 'stream-json/streamers/StreamArray.js';
+import stripBomStream from 'strip-bom-stream';
+import { file as createTmpFile } from 'tmp-promise';
+import getDatabase from '../database/index.js';
+import emitter from '../emitter.js';
+import env from '../env.js';
+import { ForbiddenException, InvalidPayloadException, ServiceUnavailableException, UnsupportedMediaTypeException, } from '../exceptions/index.js';
+import logger from '../logger.js';
+import { getDateFormatted } from '../utils/get-date-formatted.js';
+import { FilesService } from './files.js';
+import { ItemsService } from './items.js';
+import { NotificationsService } from './notifications.js';
+export class ImportService {
+    knex;
+    accountability;
+    schema;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+    }
+    async import(collection, mimetype, stream) {
+        if (this.accountability?.admin !== true && collection.startsWith('directus_'))
+            throw new ForbiddenException();
+        const createPermissions = this.accountability?.permissions?.find((permission) => permission.collection === collection && permission.action === 'create');
+        const updatePermissions = this.accountability?.permissions?.find((permission) => permission.collection === collection && permission.action === 'update');
+        if (this.accountability?.admin !== true && (!createPermissions || !updatePermissions)) {
+            throw new ForbiddenException();
+        }
+        switch (mimetype) {
+            case 'application/json':
+                return await this.importJSON(collection, stream);
+            case 'text/csv':
+            case 'application/vnd.ms-excel':
+                return await this.importCSV(collection, stream);
+            default:
+                throw new UnsupportedMediaTypeException(`Can't import files of type "${mimetype}"`);
+        }
+    }
+    importJSON(collection, stream) {
+        const extractJSON = StreamArray.withParser();
+        const nestedActionEvents = [];
+        return this.knex.transaction((trx) => {
+            const service = new ItemsService(collection, {
+                knex: trx,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+            const saveQueue = queue(async (value) => {
+                return await service.upsertOne(value, { bypassEmitAction: (params) => nestedActionEvents.push(params) });
+            });
+            return new Promise((resolve, reject) => {
+                stream.pipe(extractJSON);
+                extractJSON.on('data', ({ value }) => {
+                    saveQueue.push(value);
+                });
+                extractJSON.on('error', (err) => {
+                    destroyStream(stream);
+                    destroyStream(extractJSON);
+                    reject(new InvalidPayloadException(err.message));
+                });
+                saveQueue.error((err) => {
+                    reject(err);
+                });
+                extractJSON.on('end', () => {
+                    saveQueue.drain(() => {
+                        for (const nestedActionEvent of nestedActionEvents) {
+                            emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                        }
+                        return resolve();
+                    });
+                });
+            });
+        });
+    }
+    importCSV(collection, stream) {
+        const nestedActionEvents = [];
+        return this.knex.transaction((trx) => {
+            const service = new ItemsService(collection, {
+                knex: trx,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+            const saveQueue = queue(async (value) => {
+                return await service.upsertOne(value, { bypassEmitAction: (action) => nestedActionEvents.push(action) });
+            });
+            return new Promise((resolve, reject) => {
+                stream
+                    .pipe(stripBomStream())
+                    .pipe(csv())
+                    .on('data', (value) => {
+                    const obj = transform(value, (result, value, key) => {
+                        if (value.length === 0) {
+                            delete result[key];
+                        }
+                        else {
+                            try {
+                                const parsedJson = parseJSON(value);
+                                if (typeof parsedJson === 'number') {
+                                    set(result, key, value);
+                                }
+                                else {
+                                    set(result, key, parsedJson);
+                                }
+                            }
+                            catch {
+                                set(result, key, value);
+                            }
+                        }
+                    });
+                    saveQueue.push(obj);
+                })
+                    .on('error', (err) => {
+                    destroyStream(stream);
+                    reject(new InvalidPayloadException(err.message));
+                })
+                    .on('end', () => {
+                    saveQueue.drain(() => {
+                        for (const nestedActionEvent of nestedActionEvents) {
+                            emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                        }
+                        return resolve();
+                    });
+                });
+                saveQueue.error((err) => {
+                    reject(err);
+                });
+            });
+        });
+    }
+}
+export class ExportService {
+    knex;
+    accountability;
+    schema;
+    constructor(options) {
+        this.knex = options.knex || getDatabase();
+        this.accountability = options.accountability || null;
+        this.schema = options.schema;
+    }
+    /**
+     * Export the query results as a named file. Will query in batches, and keep appending a tmp file
+     * until all the data is retrieved. Uploads the result as a new file using the regular
+     * FilesService upload method.
+     */
+    async exportToFile(collection, query, format, options) {
+        try {
+            const mimeTypes = {
+                csv: 'text/csv',
+                json: 'application/json',
+                xml: 'text/xml',
+                yaml: 'text/yaml',
+            };
+            const database = getDatabase();
+            const { path, cleanup } = await createTmpFile();
+            await database.transaction(async (trx) => {
+                const service = new ItemsService(collection, {
+                    accountability: this.accountability,
+                    schema: this.schema,
+                    knex: trx,
+                });
+                const totalCount = await service
+                    .readByQuery({
+                    ...query,
+                    aggregate: {
+                        count: ['*'],
+                    },
+                })
+                    .then((result) => Number(result?.[0]?.['count'] ?? 0));
+                const count = query.limit ? Math.min(totalCount, query.limit) : totalCount;
+                const requestedLimit = query.limit ?? -1;
+                const batchesRequired = Math.ceil(count / env['EXPORT_BATCH_SIZE']);
+                let readCount = 0;
+                for (let batch = 0; batch < batchesRequired; batch++) {
+                    let limit = env['EXPORT_BATCH_SIZE'];
+                    if (requestedLimit > 0 && env['EXPORT_BATCH_SIZE'] > requestedLimit - readCount) {
+                        limit = requestedLimit - readCount;
+                    }
+                    const result = await service.readByQuery({
+                        ...query,
+                        limit,
+                        offset: batch * env['EXPORT_BATCH_SIZE'],
+                    });
+                    readCount += result.length;
+                    if (result.length) {
+                        await appendFile(path, this.transform(result, format, {
+                            includeHeader: batch === 0,
+                            includeFooter: batch + 1 === batchesRequired,
+                        }));
+                    }
+                }
+            });
+            const filesService = new FilesService({
+                accountability: this.accountability,
+                schema: this.schema,
+            });
+            const storage = toArray(env['STORAGE_LOCATIONS'])[0];
+            const title = `export-${collection}-${getDateFormatted()}`;
+            const filename = `${title}.${format}`;
+            const fileWithDefaults = {
+                ...(options?.file ?? {}),
+                title: options?.file?.title ?? title,
+                filename_download: options?.file?.filename_download ?? filename,
+                storage: options?.file?.storage ?? storage,
+                type: mimeTypes[format],
+            };
+            const savedFile = await filesService.uploadOne(createReadStream(path), fileWithDefaults);
+            if (this.accountability?.user) {
+                const notificationsService = new NotificationsService({
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                await notificationsService.createOne({
+                    recipient: this.accountability.user,
+                    sender: this.accountability.user,
+                    subject: `Your export of ${collection} is ready`,
+                    collection: `directus_files`,
+                    item: savedFile,
+                });
+            }
+            await cleanup();
+        }
+        catch (err) {
+            logger.error(err, `Couldn't export ${collection}: ${err.message}`);
+            if (this.accountability?.user) {
+                const notificationsService = new NotificationsService({
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                await notificationsService.createOne({
+                    recipient: this.accountability.user,
+                    sender: this.accountability.user,
+                    subject: `Your export of ${collection} failed`,
+                    message: `Please contact your system administrator for more information.`,
+                });
+            }
+        }
+    }
+    /**
+     * Transform a given input object / array to the given type
+     */
+    transform(input, format, options) {
+        if (format === 'json') {
+            let string = JSON.stringify(input || null, null, '\t');
+            if (options?.includeHeader === false)
+                string = string.split('\n').slice(1).join('\n');
+            if (options?.includeFooter === false) {
+                const lines = string.split('\n');
+                string = lines.slice(0, lines.length - 1).join('\n');
+                string += ',\n';
+            }
+            return string;
+        }
+        if (format === 'xml') {
+            let string = toXML('data', input);
+            if (options?.includeHeader === false)
+                string = string.split('\n').slice(2).join('\n');
+            if (options?.includeFooter === false) {
+                const lines = string.split('\n');
+                string = lines.slice(0, lines.length - 1).join('\n');
+                string += '\n';
+            }
+            return string;
+        }
+        if (format === 'csv') {
+            if (input.length === 0)
+                return '';
+            const parser = new CSVParser({
+                transforms: [CSVTransforms.flatten({ separator: '.' })],
+                header: options?.includeHeader !== false,
+            });
+            let string = parser.parse(input);
+            if (options?.includeHeader === false) {
+                string = '\n' + string;
+            }
+            return string;
+        }
+        if (format === 'yaml') {
+            return toYAML(input);
+        }
+        throw new ServiceUnavailableException(`Illegal export type used: "${format}"`, { service: 'export' });
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,33 @@
+export * from './activity.js';
+export * from './assets.js';
+export * from './authentication.js';
+export * from './authorization.js';
+export * from './collections.js';
+export * from './dashboards.js';
+export * from './fields.js';
+export * from './files.js';
+export * from './flows.js';
+export * from './folders.js';
+export * from './graphql/index.js';
+export * from './import-export.js';
+export * from './items.js';
+export * from './mail/index.js';
+export * from './meta.js';
+export * from './notifications.js';
+export * from './operations.js';
+export * from './panels.js';
+export * from './payload.js';
+export * from './permissions.js';
+export * from './presets.js';
+export * from './relations.js';
+export * from './revisions.js';
+export * from './roles.js';
+export * from './schema.js';
+export * from './server.js';
+export * from './settings.js';
+export * from './shares.js';
+export * from './specifications.js';
+export * from './tfa.js';
+export * from './users.js';
+export * from './utils.js';
+export * from './webhooks.js';

package/dist/services/index.js

@@ -0,0 +1,33 @@
+export * from './activity.js';
+export * from './assets.js';
+export * from './authentication.js';
+export * from './authorization.js';
+export * from './collections.js';
+export * from './dashboards.js';
+export * from './fields.js';
+export * from './files.js';
+export * from './flows.js';
+export * from './folders.js';
+export * from './graphql/index.js';
+export * from './import-export.js';
+export * from './items.js';
+export * from './mail/index.js';
+export * from './meta.js';
+export * from './notifications.js';
+export * from './operations.js';
+export * from './panels.js';
+export * from './payload.js';
+export * from './permissions.js';
+export * from './presets.js';
+export * from './relations.js';
+export * from './revisions.js';
+export * from './roles.js';
+export * from './schema.js';
+export * from './server.js';
+export * from './settings.js';
+export * from './shares.js';
+export * from './specifications.js';
+export * from './tfa.js';
+export * from './users.js';
+export * from './utils.js';
+export * from './webhooks.js';