@directus/api 13.1.0-beta.0 → 13.1.1

package/dist/services/branches.js

@@ -1,205 +0,0 @@
-import Joi from 'joi';
-import { assign, pick } from 'lodash-es';
-import objectHash from 'object-hash';
-import getDatabase from '../database/index.js';
-import emitter from '../emitter.js';
-import { InvalidPayloadError, UnprocessableContentError } from '../errors/index.js';
-import { ActivityService } from './activity.js';
-import { AuthorizationService } from './authorization.js';
-import { CollectionsService } from './collections.js';
-import { ItemsService } from './items.js';
-import { PayloadService } from './payload.js';
-import { RevisionsService } from './revisions.js';
-const branchUpdateSchema = Joi.object({
-    name: Joi.string(),
-});
-export class BranchesService extends ItemsService {
-    authorizationService;
-    collectionsService;
-    constructor(options) {
-        super('directus_branches', options);
-        this.authorizationService = new AuthorizationService({
-            accountability: this.accountability,
-            knex: this.knex,
-            schema: this.schema,
-        });
-        this.collectionsService = new CollectionsService({
-            accountability: this.accountability,
-            knex: this.knex,
-            schema: this.schema,
-        });
-    }
-    async validateCreateData(data) {
-        if (!data['name'])
-            throw new InvalidPayloadError({ reason: `"name" is required` });
-        // Reserves the "main" branch name for the branch query parameter
-        if (data['name'] === 'main')
-            throw new InvalidPayloadError({ reason: `"main" is a reserved branch name` });
-        if (!data['collection']) {
-            throw new InvalidPayloadError({ reason: `"collection" is required` });
-        }
-        if (!data['item'])
-            throw new InvalidPayloadError({ reason: `"item" is required` });
-        // will throw an error if the collection does not exist or the accountability does not have permission to read it
-        const existingCollection = await this.collectionsService.readOne(data['collection']);
-        if (!existingCollection.meta?.branches_enabled) {
-            throw new UnprocessableContentError({
-                reason: `Branch feature is not enabled for collection "${data['collection']}"`,
-            });
-        }
-        const existingBranches = await super.readByQuery({
-            fields: ['name', 'collection', 'item'],
-            filter: { name: { _eq: data['name'] }, collection: { _eq: data['collection'] }, item: { _eq: data['item'] } },
-        });
-        if (existingBranches.length > 0) {
-            throw new UnprocessableContentError({
-                reason: `Branch "${data['name']}" already exists for item "${data['item']}" in collection "${data['collection']}"`,
-            });
-        }
-        // will throw an error if the accountability does not have permission to read the item
-        await this.authorizationService.checkAccess('read', data['collection'], data['item']);
-    }
-    async validateUpdateData(data) {
-        // Only allow updates on "name" field
-        const { error } = branchUpdateSchema.validate(data);
-        if (error)
-            throw new InvalidPayloadError({ reason: error.message });
-        // Reserves the "main" branch name for the branch query parameter
-        if ('name' in data && data['name'] === 'main') {
-            throw new InvalidPayloadError({ reason: `"main" is a reserved branch name` });
-        }
-    }
-    async getMainBranchItem(collection, item, query) {
-        // will throw an error if the accountability does not have permission to read the item
-        await this.authorizationService.checkAccess('read', collection, item);
-        const itemsService = new ItemsService(collection, {
-            knex: this.knex,
-            accountability: this.accountability,
-            schema: this.schema,
-        });
-        return await itemsService.readOne(item, query);
-    }
-    async verifyHash(collection, item, hash) {
-        const mainBranchItem = await this.getMainBranchItem(collection, item);
-        const mainHash = objectHash(mainBranchItem);
-        return { outdated: hash !== mainHash, mainHash };
-    }
-    async getBranchCommits(key) {
-        const revisionsService = new RevisionsService({
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const result = await revisionsService.readByQuery({
-            filter: { branch: { _eq: key } },
-        });
-        return result.map((revision) => revision['delta']);
-    }
-    async createOne(data, opts) {
-        await this.validateCreateData(data);
-        const mainBranchItem = await this.getMainBranchItem(data['collection'], data['item']);
-        data['hash'] = objectHash(mainBranchItem);
-        return super.createOne(data, opts);
-    }
-    async createMany(data, opts) {
-        if (!Array.isArray(data)) {
-            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
-        }
-        for (const item of data) {
-            await this.validateCreateData(item);
-            const mainBranchItem = await this.getMainBranchItem(item['collection'], item['item']);
-            item['hash'] = objectHash(mainBranchItem);
-        }
-        return super.createMany(data, opts);
-    }
-    async updateBatch(data, opts) {
-        if (!Array.isArray(data)) {
-            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
-        }
-        for (const item of data) {
-            await this.validateUpdateData(item);
-        }
-        return super.updateBatch(data, opts);
-    }
-    async updateMany(keys, data, opts) {
-        await this.validateUpdateData(data);
-        return super.updateMany(keys, data, opts);
-    }
-    async updateByQuery(query, data, opts) {
-        await this.validateUpdateData(data);
-        return super.updateByQuery(query, data, opts);
-    }
-    async commit(key, data) {
-        const branch = await super.readOne(key);
-        const payloadService = new PayloadService(this.collection, {
-            accountability: this.accountability,
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const activityService = new ActivityService({
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const revisionsService = new RevisionsService({
-            knex: this.knex,
-            schema: this.schema,
-        });
-        const activity = await activityService.createOne({
-            action: 'commit',
-            user: this.accountability?.user ?? null,
-            collection: branch['collection'],
-            ip: this.accountability?.ip ?? null,
-            user_agent: this.accountability?.userAgent ?? null,
-            origin: this.accountability?.origin ?? null,
-            item: branch['item'],
-        });
-        const revisionDelta = await payloadService.prepareDelta(data);
-        await revisionsService.createOne({
-            activity,
-            branch: key,
-            collection: branch['collection'],
-            item: branch['item'],
-            data: revisionDelta,
-            delta: revisionDelta,
-        });
-        return data;
-    }
-    async merge(branch, mainHash, fields) {
-        const { id, collection, item } = (await this.readOne(branch));
-        // will throw an error if the accountability does not have permission to update the item
-        await this.authorizationService.checkAccess('update', collection, item);
-        const { outdated } = await this.verifyHash(collection, item, mainHash);
-        if (outdated) {
-            throw new UnprocessableContentError({
-                reason: `Main branch has changed since this branch was last updated`,
-            });
-        }
-        const commits = await this.getBranchCommits(id);
-        const branchResult = assign({}, ...commits);
-        const payloadToUpdate = fields ? pick(branchResult, fields) : branchResult;
-        const itemsService = new ItemsService(collection, {
-            accountability: this.accountability,
-            schema: this.schema,
-        });
-        const payloadAfterHooks = await emitter.emitFilter(['items.merge', `${collection}.items.merge`], payloadToUpdate, {
-            collection,
-            item,
-            branch,
-        }, {
-            database: getDatabase(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        const updatedItemKey = await itemsService.updateOne(item, payloadAfterHooks);
-        emitter.emitAction(['items.merge', `${collection}.items.merge`], {
-            payload: payloadAfterHooks,
-            collection,
-            item: updatedItemKey,
-            branch,
-        }, {
-            database: getDatabase(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        return updatedItemKey;
-    }
-}