directus 9.24.0 → 9.25.0

package/dist/services/shares.js

@@ -1,136 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharesService = void 0;
-const argon2_1 = __importDefault(require("argon2"));
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const env_1 = __importDefault(require("../env"));
-const exceptions_1 = require("../exceptions");
-const get_milliseconds_1 = require("../utils/get-milliseconds");
-const md_1 = require("../utils/md");
-const url_1 = require("../utils/url");
-const user_name_1 = require("../utils/user-name");
-const authorization_1 = require("./authorization");
-const items_1 = require("./items");
-const mail_1 = require("./mail");
-const users_1 = require("./users");
-class SharesService extends items_1.ItemsService {
-    authorizationService;
-    constructor(options) {
-        super('directus_shares', options);
-        this.authorizationService = new authorization_1.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 exceptions_1.InvalidCredentialsException();
-        }
-        if (record.share_password && !(await argon2_1.default.verify(record.share_password, payload['password']))) {
-            throw new exceptions_1.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 = jsonwebtoken_1.default.sign(tokenPayload, env_1.default['SECRET'], {
-            expiresIn: env_1.default['ACCESS_TOKEN_TTL'],
-            issuer: 'directus',
-        });
-        const refreshToken = nanoid(64);
-        const refreshTokenExpiration = new Date(Date.now() + (0, get_milliseconds_1.getMilliseconds)(env_1.default['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: (0, get_milliseconds_1.getMilliseconds)(env_1.default['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 exceptions_1.ForbiddenException();
-        const share = await this.readOne(payload.share, { fields: ['collection'] });
-        const usersService = new users_1.UsersService({
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const mailService = new mail_1.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!
-
-${(0, user_name_1.userName)(userInfo)} has invited you to view an item in ${share['collection']}.
-
-[Open](${new url_1.Url(env_1.default['PUBLIC_URL']).addPath('admin', 'shared', payload.share).toString()})
-`;
-        for (const email of payload.emails) {
-            await mailService.send({
-                template: {
-                    name: 'base',
-                    data: {
-                        html: (0, md_1.md)(message),
-                    },
-                },
-                to: email,
-                subject: `${(0, user_name_1.userName)(userInfo)} has shared an item with you`,
-            });
-        }
-    }
-}
-exports.SharesService = SharesService;

package/dist/services/specifications.d.ts

@@ -1,53 +0,0 @@
-import type { Knex } from 'knex';
-import type { OpenAPIObject } from 'openapi3-ts';
-import type { Accountability, SchemaOverview } from '@directus/shared/types';
-import type { AbstractServiceOptions } from '../types';
-import { CollectionsService } from './collections';
-import { FieldsService } from './fields';
-import { GraphQLService } from './graphql';
-import { RelationsService } from './relations';
-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

@@ -1,500 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpecificationService = void 0;
-const specs_1 = __importDefault(require("@directus/specs"));
-const lodash_1 = require("lodash");
-const package_json_1 = require("../../package.json");
-const constants_1 = require("../constants");
-const database_1 = __importDefault(require("../database"));
-const env_1 = __importDefault(require("../env"));
-const get_relation_type_1 = require("../utils/get-relation-type");
-const collections_1 = require("./collections");
-const fields_1 = require("./fields");
-const graphql_1 = require("./graphql");
-const relations_1 = require("./relations");
-// @ts-ignore
-const format_title_1 = __importDefault(require("@directus/format-title"));
-class SpecificationService {
-    accountability;
-    knex;
-    schema;
-    fieldsService;
-    collectionsService;
-    relationsService;
-    oas;
-    graphql;
-    constructor(options) {
-        this.accountability = options.accountability || null;
-        this.knex = options.knex || (0, database_1.default)();
-        this.schema = options.schema;
-        this.fieldsService = new fields_1.FieldsService(options);
-        this.collectionsService = new collections_1.CollectionsService(options);
-        this.relationsService = new relations_1.RelationsService(options);
-        this.oas = new OASSpecsService(options, {
-            fieldsService: this.fieldsService,
-            collectionsService: this.collectionsService,
-            relationsService: this.relationsService,
-        });
-        this.graphql = new GraphQLSpecsService(options);
-    }
-}
-exports.SpecificationService = SpecificationService;
-class OASSpecsService {
-    accountability;
-    knex;
-    schema;
-    fieldsService;
-    collectionsService;
-    relationsService;
-    constructor(options, { fieldsService, collectionsService, relationsService, }) {
-        this.accountability = options.accountability || null;
-        this.knex = options.knex || (0, database_1.default)();
-        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: package_json_1.version,
-            },
-            servers: [
-                {
-                    url: env_1.default['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 = (0, lodash_1.cloneDeep)(specs_1.default.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 specs_1.default.tags) {
-                    if (tag['x-collection'] === collection.collection) {
-                        tags.push(tag);
-                        break;
-                    }
-                }
-            }
-            else {
-                const tag = {
-                    name: 'Items' + (0, format_title_1.default)(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(specs_1.default.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 = (0, lodash_1.cloneDeep)(specs_1.default.paths['/items/{collection}']);
-                const detailBase = (0, lodash_1.cloneDeep)(specs_1.default.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] = (0, lodash_1.mergeWith)((0, lodash_1.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] = (0, lodash_1.mergeWith)((0, lodash_1.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 = (0, lodash_1.cloneDeep)(specs_1.default.components);
-        if (!components)
-            components = {};
-        components.schemas = {};
-        // Always includes the schemas with these names
-        if (specs_1.default.components?.schemas !== null) {
-            for (const schemaName of constants_1.OAS_REQUIRED_SCHEMAS) {
-                if (specs_1.default.components.schemas[schemaName] !== null) {
-                    components.schemas[schemaName] = (0, lodash_1.cloneDeep)(specs_1.default.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 = (0, lodash_1.cloneDeep)(specs_1.default.components.schemas[tag.name]);
-                schemaComponent.properties = {};
-                for (const field of fieldsInCollection) {
-                    schemaComponent.properties[field.field] =
-                        (0, lodash_1.cloneDeep)(specs_1.default.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 = (0, get_relation_type_1.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 || (0, database_1.default)();
-        this.schema = options.schema;
-        this.items = new graphql_1.GraphQLService({ ...options, scope: 'items' });
-        this.system = new graphql_1.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

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