@directus/api 9.25.0

package/dist/services/shares.js

@@ -0,0 +1,129 @@
+import argon2 from 'argon2';
+import jwt from 'jsonwebtoken';
+import env from '../env.js';
+import { ForbiddenException, InvalidCredentialsException } from '../exceptions/index.js';
+import { getMilliseconds } from '../utils/get-milliseconds.js';
+import { md } from '../utils/md.js';
+import { Url } from '../utils/url.js';
+import { userName } from '../utils/user-name.js';
+import { AuthorizationService } from './authorization.js';
+import { ItemsService } from './items.js';
+import { MailService } from './mail/index.js';
+import { UsersService } from './users.js';
+export class SharesService extends ItemsService {
+    authorizationService;
+    constructor(options) {
+        super('directus_shares', options);
+        this.authorizationService = new AuthorizationService({
+            accountability: this.accountability,
+            knex: this.knex,
+            schema: this.schema,
+        });
+    }
+    async createOne(data, opts) {
+        await this.authorizationService.checkAccess('share', data['collection'], data['item']);
+        return super.createOne(data, opts);
+    }
+    async login(payload) {
+        const { nanoid } = await import('nanoid');
+        const record = await this.knex
+            .select({
+            share_id: 'id',
+            share_role: 'role',
+            share_item: 'item',
+            share_collection: 'collection',
+            share_start: 'date_start',
+            share_end: 'date_end',
+            share_times_used: 'times_used',
+            share_max_uses: 'max_uses',
+            share_password: 'password',
+        })
+            .from('directus_shares')
+            .where('id', payload['share'])
+            .andWhere((subQuery) => {
+            subQuery.whereNull('date_end').orWhere('date_end', '>=', new Date());
+        })
+            .andWhere((subQuery) => {
+            subQuery.whereNull('date_start').orWhere('date_start', '<=', new Date());
+        })
+            .andWhere((subQuery) => {
+            subQuery.whereNull('max_uses').orWhere('max_uses', '>=', this.knex.ref('times_used'));
+        })
+            .first();
+        if (!record) {
+            throw new InvalidCredentialsException();
+        }
+        if (record.share_password && !(await argon2.verify(record.share_password, payload['password']))) {
+            throw new InvalidCredentialsException();
+        }
+        await this.knex('directus_shares')
+            .update({ times_used: record.share_times_used + 1 })
+            .where('id', record.share_id);
+        const tokenPayload = {
+            app_access: false,
+            admin_access: false,
+            role: record.share_role,
+            share: record.share_id,
+            share_scope: {
+                item: record.share_item,
+                collection: record.share_collection,
+            },
+        };
+        const accessToken = jwt.sign(tokenPayload, env['SECRET'], {
+            expiresIn: env['ACCESS_TOKEN_TTL'],
+            issuer: 'directus',
+        });
+        const refreshToken = nanoid(64);
+        const refreshTokenExpiration = new Date(Date.now() + getMilliseconds(env['REFRESH_TOKEN_TTL'], 0));
+        await this.knex('directus_sessions').insert({
+            token: refreshToken,
+            expires: refreshTokenExpiration,
+            ip: this.accountability?.ip,
+            user_agent: this.accountability?.userAgent,
+            origin: this.accountability?.origin,
+            share: record.share_id,
+        });
+        await this.knex('directus_sessions').delete().where('expires', '<', new Date());
+        return {
+            accessToken,
+            refreshToken,
+            expires: getMilliseconds(env['ACCESS_TOKEN_TTL']),
+        };
+    }
+    /**
+     * Send a link to the given share ID to the given email(s). Note: you can only send a link to a share
+     * if you have read access to that particular share
+     */
+    async invite(payload) {
+        if (!this.accountability?.user)
+            throw new ForbiddenException();
+        const share = await this.readOne(payload.share, { fields: ['collection'] });
+        const usersService = new UsersService({
+            knex: this.knex,
+            schema: this.schema,
+        });
+        const mailService = new MailService({ schema: this.schema, accountability: this.accountability });
+        const userInfo = await usersService.readOne(this.accountability.user, {
+            fields: ['first_name', 'last_name', 'email', 'id'],
+        });
+        const message = `
+Hello!
+
+${userName(userInfo)} has invited you to view an item in ${share['collection']}.
+
+[Open](${new Url(env['PUBLIC_URL']).addPath('admin', 'shared', payload.share).toString()})
+`;
+        for (const email of payload.emails) {
+            await mailService.send({
+                template: {
+                    name: 'base',
+                    data: {
+                        html: md(message),
+                    },
+                },
+                to: email,
+                subject: `${userName(userInfo)} has shared an item with you`,
+            });
+        }
+    }
+}

package/dist/services/specifications.d.ts

@@ -0,0 +1,53 @@
+import type { Knex } from 'knex';
+import type { OpenAPIObject } from 'openapi3-ts';
+import type { Accountability, SchemaOverview } from '@directus/types';
+import type { AbstractServiceOptions } from '../types/index.js';
+import { CollectionsService } from './collections.js';
+import { FieldsService } from './fields.js';
+import { GraphQLService } from './graphql/index.js';
+import { RelationsService } from './relations.js';
+export declare class SpecificationService {
+    accountability: Accountability | null;
+    knex: Knex;
+    schema: SchemaOverview;
+    fieldsService: FieldsService;
+    collectionsService: CollectionsService;
+    relationsService: RelationsService;
+    oas: OASSpecsService;
+    graphql: GraphQLSpecsService;
+    constructor(options: AbstractServiceOptions);
+}
+interface SpecificationSubService {
+    generate: (_?: any) => Promise<any>;
+}
+declare class OASSpecsService implements SpecificationSubService {
+    accountability: Accountability | null;
+    knex: Knex;
+    schema: SchemaOverview;
+    fieldsService: FieldsService;
+    collectionsService: CollectionsService;
+    relationsService: RelationsService;
+    constructor(options: AbstractServiceOptions, { fieldsService, collectionsService, relationsService, }: {
+        fieldsService: FieldsService;
+        collectionsService: CollectionsService;
+        relationsService: RelationsService;
+    });
+    generate(): Promise<OpenAPIObject>;
+    private generateTags;
+    private generatePaths;
+    private generateComponents;
+    private filterCollectionFromParams;
+    private getActionForMethod;
+    private generateField;
+    private fieldTypes;
+}
+declare class GraphQLSpecsService implements SpecificationSubService {
+    accountability: Accountability | null;
+    knex: Knex;
+    schema: SchemaOverview;
+    items: GraphQLService;
+    system: GraphQLService;
+    constructor(options: AbstractServiceOptions);
+    generate(scope: 'items' | 'system'): Promise<string | import("graphql").GraphQLSchema | null>;
+}
+export {};

package/dist/services/specifications.js

@@ -0,0 +1,492 @@
+import { spec } from '@directus/specs';
+import { cloneDeep, mergeWith } from 'lodash-es';
+import { version } from '../utils/package.js';
+import { OAS_REQUIRED_SCHEMAS } from '../constants.js';
+import getDatabase from '../database/index.js';
+import env from '../env.js';
+import { getRelationType } from '../utils/get-relation-type.js';
+import { CollectionsService } from './collections.js';
+import { FieldsService } from './fields.js';
+import { GraphQLService } from './graphql/index.js';
+import { RelationsService } from './relations.js';
+import formatTitle from '@directus/format-title';
+export class SpecificationService {
+    accountability;
+    knex;
+    schema;
+    fieldsService;
+    collectionsService;
+    relationsService;
+    oas;
+    graphql;
+    constructor(options) {
+        this.accountability = options.accountability || null;
+        this.knex = options.knex || getDatabase();
+        this.schema = options.schema;
+        this.fieldsService = new FieldsService(options);
+        this.collectionsService = new CollectionsService(options);
+        this.relationsService = new RelationsService(options);
+        this.oas = new OASSpecsService(options, {
+            fieldsService: this.fieldsService,
+            collectionsService: this.collectionsService,
+            relationsService: this.relationsService,
+        });
+        this.graphql = new GraphQLSpecsService(options);
+    }
+}
+class OASSpecsService {
+    accountability;
+    knex;
+    schema;
+    fieldsService;
+    collectionsService;
+    relationsService;
+    constructor(options, { fieldsService, collectionsService, relationsService, }) {
+        this.accountability = options.accountability || null;
+        this.knex = options.knex || getDatabase();
+        this.schema = options.schema;
+        this.fieldsService = fieldsService;
+        this.collectionsService = collectionsService;
+        this.relationsService = relationsService;
+    }
+    async generate() {
+        const collections = await this.collectionsService.readByQuery();
+        const fields = await this.fieldsService.readAll();
+        const relations = (await this.relationsService.readAll());
+        const permissions = this.accountability?.permissions ?? [];
+        const tags = await this.generateTags(collections);
+        const paths = await this.generatePaths(permissions, tags);
+        const components = await this.generateComponents(collections, fields, relations, tags);
+        const spec = {
+            openapi: '3.0.1',
+            info: {
+                title: 'Dynamic API Specification',
+                description: 'This is a dynamically generated API specification for all endpoints existing on the current project.',
+                version: version,
+            },
+            servers: [
+                {
+                    url: env['PUBLIC_URL'],
+                    description: 'Your current Directus instance.',
+                },
+            ],
+            paths,
+        };
+        if (tags)
+            spec.tags = tags;
+        if (components)
+            spec.components = components;
+        return spec;
+    }
+    async generateTags(collections) {
+        const systemTags = cloneDeep(spec.tags);
+        const tags = [];
+        // System tags that don't have an associated collection are always readable to the user
+        for (const systemTag of systemTags) {
+            if (!systemTag['x-collection']) {
+                tags.push(systemTag);
+            }
+        }
+        for (const collection of collections) {
+            const isSystem = collection.collection.startsWith('directus_');
+            // If the collection is one of the system collections, pull the tag from the static spec
+            if (isSystem) {
+                for (const tag of spec.tags) {
+                    if (tag['x-collection'] === collection.collection) {
+                        tags.push(tag);
+                        break;
+                    }
+                }
+            }
+            else {
+                const tag = {
+                    name: 'Items' + formatTitle(collection.collection).replace(/ /g, ''),
+                    'x-collection': collection.collection,
+                };
+                if (collection.meta?.note) {
+                    tag.description = collection.meta.note;
+                }
+                tags.push(tag);
+            }
+        }
+        // Filter out the generic Items information
+        return tags.filter((tag) => tag.name !== 'Items');
+    }
+    async generatePaths(permissions, tags) {
+        const paths = {};
+        if (!tags)
+            return paths;
+        for (const tag of tags) {
+            const isSystem = 'x-collection' in tag === false || tag['x-collection'].startsWith('directus_');
+            if (isSystem) {
+                for (const [path, pathItem] of Object.entries(spec.paths)) {
+                    for (const [method, operation] of Object.entries(pathItem)) {
+                        if (operation.tags?.includes(tag.name)) {
+                            if (!paths[path]) {
+                                paths[path] = {};
+                            }
+                            const hasPermission = this.accountability?.admin === true ||
+                                'x-collection' in tag === false ||
+                                !!permissions.find((permission) => permission.collection === tag['x-collection'] &&
+                                    permission.action === this.getActionForMethod(method));
+                            if (hasPermission) {
+                                if ('parameters' in pathItem) {
+                                    paths[path][method] = {
+                                        ...operation,
+                                        parameters: [...(pathItem.parameters ?? []), ...(operation?.parameters ?? [])],
+                                    };
+                                }
+                                else {
+                                    paths[path][method] = operation;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const listBase = cloneDeep(spec.paths['/items/{collection}']);
+                const detailBase = cloneDeep(spec.paths['/items/{collection}/{id}']);
+                const collection = tag['x-collection'];
+                for (const method of ['post', 'get', 'patch', 'delete']) {
+                    const hasPermission = this.accountability?.admin === true ||
+                        !!permissions.find((permission) => permission.collection === collection && permission.action === this.getActionForMethod(method));
+                    if (hasPermission) {
+                        if (!paths[`/items/${collection}`])
+                            paths[`/items/${collection}`] = {};
+                        if (!paths[`/items/${collection}/{id}`])
+                            paths[`/items/${collection}/{id}`] = {};
+                        if (listBase[method]) {
+                            paths[`/items/${collection}`][method] = mergeWith(cloneDeep(listBase[method]), {
+                                description: listBase[method].description.replace('item', collection + ' item'),
+                                tags: [tag.name],
+                                parameters: 'parameters' in listBase ? this.filterCollectionFromParams(listBase.parameters) : [],
+                                operationId: `${this.getActionForMethod(method)}${tag.name}`,
+                                requestBody: ['get', 'delete'].includes(method)
+                                    ? undefined
+                                    : {
+                                        content: {
+                                            'application/json': {
+                                                schema: {
+                                                    oneOf: [
+                                                        {
+                                                            type: 'array',
+                                                            items: {
+                                                                $ref: `#/components/schemas/${tag.name}`,
+                                                            },
+                                                        },
+                                                        {
+                                                            $ref: `#/components/schemas/${tag.name}`,
+                                                        },
+                                                    ],
+                                                },
+                                            },
+                                        },
+                                    },
+                                responses: {
+                                    '200': {
+                                        content: method === 'delete'
+                                            ? undefined
+                                            : {
+                                                'application/json': {
+                                                    schema: {
+                                                        properties: {
+                                                            data: {
+                                                                items: {
+                                                                    $ref: `#/components/schemas/${tag.name}`,
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                    },
+                                },
+                            }, (obj, src) => {
+                                if (Array.isArray(obj))
+                                    return obj.concat(src);
+                                return undefined;
+                            });
+                        }
+                        if (detailBase[method]) {
+                            paths[`/items/${collection}/{id}`][method] = mergeWith(cloneDeep(detailBase[method]), {
+                                description: detailBase[method].description.replace('item', collection + ' item'),
+                                tags: [tag.name],
+                                operationId: `${this.getActionForMethod(method)}Single${tag.name}`,
+                                parameters: 'parameters' in detailBase ? this.filterCollectionFromParams(detailBase.parameters) : [],
+                                requestBody: ['get', 'delete'].includes(method)
+                                    ? undefined
+                                    : {
+                                        content: {
+                                            'application/json': {
+                                                schema: {
+                                                    $ref: `#/components/schemas/${tag.name}`,
+                                                },
+                                            },
+                                        },
+                                    },
+                                responses: {
+                                    '200': {
+                                        content: method === 'delete'
+                                            ? undefined
+                                            : {
+                                                'application/json': {
+                                                    schema: {
+                                                        properties: {
+                                                            data: {
+                                                                $ref: `#/components/schemas/${tag.name}`,
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                    },
+                                },
+                            }, (obj, src) => {
+                                if (Array.isArray(obj))
+                                    return obj.concat(src);
+                                return undefined;
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    async generateComponents(collections, fields, relations, tags) {
+        let components = cloneDeep(spec.components);
+        if (!components)
+            components = {};
+        components.schemas = {};
+        // Always includes the schemas with these names
+        if (spec.components?.schemas !== null) {
+            for (const schemaName of OAS_REQUIRED_SCHEMAS) {
+                if (spec.components.schemas[schemaName] !== null) {
+                    components.schemas[schemaName] = cloneDeep(spec.components.schemas[schemaName]);
+                }
+            }
+        }
+        if (!tags)
+            return;
+        for (const collection of collections) {
+            const tag = tags.find((tag) => tag['x-collection'] === collection.collection);
+            if (!tag)
+                continue;
+            const isSystem = collection.collection.startsWith('directus_');
+            const fieldsInCollection = fields.filter((field) => field.collection === collection.collection);
+            if (isSystem) {
+                const schemaComponent = cloneDeep(spec.components.schemas[tag.name]);
+                schemaComponent.properties = {};
+                for (const field of fieldsInCollection) {
+                    schemaComponent.properties[field.field] =
+                        cloneDeep(spec.components.schemas[tag.name].properties[field.field]) || this.generateField(field, relations, tags, fields);
+                }
+                components.schemas[tag.name] = schemaComponent;
+            }
+            else {
+                const schemaComponent = {
+                    type: 'object',
+                    properties: {},
+                    'x-collection': collection.collection,
+                };
+                for (const field of fieldsInCollection) {
+                    schemaComponent.properties[field.field] = this.generateField(field, relations, tags, fields);
+                }
+                components.schemas[tag.name] = schemaComponent;
+            }
+        }
+        return components;
+    }
+    filterCollectionFromParams(parameters) {
+        return parameters.filter((param) => param?.$ref !== '#/components/parameters/Collection');
+    }
+    getActionForMethod(method) {
+        switch (method) {
+            case 'post':
+                return 'create';
+            case 'patch':
+                return 'update';
+            case 'delete':
+                return 'delete';
+            case 'get':
+            default:
+                return 'read';
+        }
+    }
+    generateField(field, relations, tags, fields) {
+        let propertyObject = {};
+        if (field.schema && 'is_nullable' in field.schema) {
+            propertyObject.nullable = field.schema.is_nullable;
+        }
+        if (field.meta?.note) {
+            propertyObject.description = field.meta.note;
+        }
+        const relation = relations.find((relation) => (relation.collection === field.collection && relation.field === field.field) ||
+            (relation.related_collection === field.collection && relation.meta?.one_field === field.field));
+        if (!relation) {
+            propertyObject = {
+                ...propertyObject,
+                ...this.fieldTypes[field.type],
+            };
+        }
+        else {
+            const relationType = getRelationType({
+                relation,
+                field: field.field,
+                collection: field.collection,
+            });
+            if (relationType === 'm2o') {
+                const relatedTag = tags.find((tag) => tag['x-collection'] === relation.related_collection);
+                const relatedPrimaryKeyField = fields.find((field) => field.collection === relation.related_collection && field.schema?.is_primary_key);
+                if (!relatedTag || !relatedPrimaryKeyField)
+                    return propertyObject;
+                propertyObject.oneOf = [
+                    {
+                        ...this.fieldTypes[relatedPrimaryKeyField.type],
+                    },
+                    {
+                        $ref: `#/components/schemas/${relatedTag.name}`,
+                    },
+                ];
+            }
+            else if (relationType === 'o2m') {
+                const relatedTag = tags.find((tag) => tag['x-collection'] === relation.collection);
+                const relatedPrimaryKeyField = fields.find((field) => field.collection === relation.collection && field.schema?.is_primary_key);
+                if (!relatedTag || !relatedPrimaryKeyField)
+                    return propertyObject;
+                propertyObject.type = 'array';
+                propertyObject.items = {
+                    oneOf: [
+                        {
+                            ...this.fieldTypes[relatedPrimaryKeyField.type],
+                        },
+                        {
+                            $ref: `#/components/schemas/${relatedTag.name}`,
+                        },
+                    ],
+                };
+            }
+            else if (relationType === 'a2o') {
+                const relatedTags = tags.filter((tag) => relation.meta.one_allowed_collections.includes(tag['x-collection']));
+                propertyObject.type = 'array';
+                propertyObject.items = {
+                    oneOf: [
+                        {
+                            type: 'string',
+                        },
+                        relatedTags.map((tag) => ({
+                            $ref: `#/components/schemas/${tag.name}`,
+                        })),
+                    ],
+                };
+            }
+        }
+        return propertyObject;
+    }
+    fieldTypes = {
+        alias: {
+            type: 'string',
+        },
+        bigInteger: {
+            type: 'integer',
+            format: 'int64',
+        },
+        binary: {
+            type: 'string',
+            format: 'binary',
+        },
+        boolean: {
+            type: 'boolean',
+        },
+        csv: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+        date: {
+            type: 'string',
+            format: 'date',
+        },
+        dateTime: {
+            type: 'string',
+            format: 'date-time',
+        },
+        decimal: {
+            type: 'number',
+        },
+        float: {
+            type: 'number',
+            format: 'float',
+        },
+        hash: {
+            type: 'string',
+        },
+        integer: {
+            type: 'integer',
+        },
+        json: {},
+        string: {
+            type: 'string',
+        },
+        text: {
+            type: 'string',
+        },
+        time: {
+            type: 'string',
+            format: 'time',
+        },
+        timestamp: {
+            type: 'string',
+            format: 'timestamp',
+        },
+        unknown: {},
+        uuid: {
+            type: 'string',
+            format: 'uuid',
+        },
+        geometry: {
+            type: 'object',
+        },
+        'geometry.Point': {
+            type: 'object',
+        },
+        'geometry.LineString': {
+            type: 'object',
+        },
+        'geometry.Polygon': {
+            type: 'object',
+        },
+        'geometry.MultiPoint': {
+            type: 'object',
+        },
+        'geometry.MultiLineString': {
+            type: 'object',
+        },
+        'geometry.MultiPolygon': {
+            type: 'object',
+        },
+    };
+}
+class GraphQLSpecsService {
+    accountability;
+    knex;
+    schema;
+    items;
+    system;
+    constructor(options) {
+        this.accountability = options.accountability || null;
+        this.knex = options.knex || getDatabase();
+        this.schema = options.schema;
+        this.items = new GraphQLService({ ...options, scope: 'items' });
+        this.system = new GraphQLService({ ...options, scope: 'system' });
+    }
+    async generate(scope) {
+        if (scope === 'items')
+            return this.items.getSchema('sdl');
+        if (scope === 'system')
+            return this.system.getSchema('sdl');
+        return null;
+    }
+}

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

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

package/dist/services/tfa.d.ts

@@ -0,0 +1,12 @@
+import type { Knex } from 'knex';
+import type { AbstractServiceOptions, PrimaryKey } from '../types/index.js';
+import { ItemsService } from './items.js';
+export declare class TFAService {
+    knex: Knex;
+    itemsService: ItemsService;
+    constructor(options: AbstractServiceOptions);
+    verifyOTP(key: PrimaryKey, otp: string, secret?: string): Promise<boolean>;
+    generateTFA(key: PrimaryKey): Promise<Record<string, string>>;
+    enableTFA(key: PrimaryKey, otp: string, secret: string): Promise<void>;
+    disableTFA(key: PrimaryKey): Promise<void>;
+}