directus 9.15.1 → 9.17.0

package/dist/services/payload.d.ts

@@ -1,7 +1,7 @@
 import { Accountability, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 import { Helpers } from '../database/helpers';
-import { AbstractServiceOptions, Item, PrimaryKey } from '../types';
+import { AbstractServiceOptions, ActionEventParams, Item, MutationOptions, PrimaryKey } from '../types';
 declare type Action = 'create' | 'read' | 'update';
 declare type Transformers = {
     [type: string]: (context: {
@@ -44,22 +44,25 @@ export declare class PayloadService {
     /**
      * Recursively save/update all nested related Any-to-One items
      */
-    processA2O(data: Partial<Item>): Promise<{
+    processA2O(data: Partial<Item>, opts?: MutationOptions): Promise<{
         payload: Partial<Item>;
         revisions: PrimaryKey[];
+        nestedActionEvents: ActionEventParams[];
     }>;
     /**
      * Save/update all nested related m2o items inside the payload
      */
-    processM2O(data: Partial<Item>): Promise<{
+    processM2O(data: Partial<Item>, opts?: MutationOptions): Promise<{
         payload: Partial<Item>;
         revisions: PrimaryKey[];
+        nestedActionEvents: ActionEventParams[];
     }>;
     /**
      * Recursively save/update all nested related o2m items
      */
-    processO2M(data: Partial<Item>, parent: PrimaryKey): Promise<{
+    processO2M(data: Partial<Item>, parent: PrimaryKey, opts?: MutationOptions): Promise<{
         revisions: PrimaryKey[];
+        nestedActionEvents: ActionEventParams[];
     }>;
     /**
      * Transforms the input partial payload to match the output structure, to have consistency

package/dist/services/payload.js

@@ -300,12 +300,13 @@ class PayloadService {
     /**
      * Recursively save/update all nested related Any-to-One items
      */
-    async processA2O(data) {
+    async processA2O(data, opts) {
         var _a, _b;
         const relations = this.schema.relations.filter((relation) => {
             return relation.collection === this.collection;
         });
         const revisions = [];
+        const nestedActionEvents = [];
         const payload = (0, lodash_1.cloneDeep)(data);
         // Only process related records that are actually in the payload
         const relationsToProcess = relations.filter((relation) => {
@@ -345,26 +346,31 @@ class PayloadService {
                 if (Object.keys(fieldsToUpdate).length > 0) {
                     await itemsService.updateOne(relatedPrimaryKey, relatedRecord, {
                         onRevisionCreate: (pk) => revisions.push(pk),
+                        bypassEmitAction: (params) => nestedActionEvents.push(params),
+                        emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                     });
                 }
             }
             else {
                 relatedPrimaryKey = await itemsService.createOne(relatedRecord, {
                     onRevisionCreate: (pk) => revisions.push(pk),
+                    bypassEmitAction: (params) => nestedActionEvents.push(params),
+                    emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                 });
             }
             // Overwrite the nested object with just the primary key, so the parent level can be saved correctly
             payload[relation.field] = relatedPrimaryKey;
         }
-        return { payload, revisions };
+        return { payload, revisions, nestedActionEvents };
     }
     /**
      * Save/update all nested related m2o items inside the payload
      */
-    async processM2O(data) {
+    async processM2O(data, opts) {
         const payload = (0, lodash_1.cloneDeep)(data);
         // All the revisions saved on this level
         const revisions = [];
+        const nestedActionEvents = [];
         // Many to one relations that exist on the current collection
         const relations = this.schema.relations.filter((relation) => {
             return relation.collection === this.collection;
@@ -400,24 +406,29 @@ class PayloadService {
                 if (Object.keys(fieldsToUpdate).length > 0) {
                     await itemsService.updateOne(relatedPrimaryKey, relatedRecord, {
                         onRevisionCreate: (pk) => revisions.push(pk),
+                        bypassEmitAction: (params) => nestedActionEvents.push(params),
+                        emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                     });
                 }
             }
             else {
                 relatedPrimaryKey = await itemsService.createOne(relatedRecord, {
                     onRevisionCreate: (pk) => revisions.push(pk),
+                    bypassEmitAction: (params) => nestedActionEvents.push(params),
+                    emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                 });
             }
             // Overwrite the nested object with just the primary key, so the parent level can be saved correctly
             payload[relation.field] = relatedPrimaryKey;
         }
-        return { payload, revisions };
+        return { payload, revisions, nestedActionEvents };
     }
     /**
      * Recursively save/update all nested related o2m items
      */
-    async processO2M(data, parent) {
+    async processO2M(data, parent, opts) {
         const revisions = [];
+        const nestedActionEvents = [];
         const relations = this.schema.relations.filter((relation) => {
             return relation.related_collection === this.collection;
         });
@@ -485,6 +496,8 @@ class PayloadService {
                 }
                 savedPrimaryKeys.push(...(await itemsService.upsertMany(recordsToUpsert, {
                     onRevisionCreate: (pk) => revisions.push(pk),
+                    bypassEmitAction: (params) => nestedActionEvents.push(params),
+                    emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                 })));
                 const query = {
                     filter: {
@@ -505,11 +518,16 @@ class PayloadService {
                 // Nullify all related items that aren't included in the current payload
                 if (relation.meta.one_deselect_action === 'delete') {
                     // There's no revision for a deletion
-                    await itemsService.deleteByQuery(query);
+                    await itemsService.deleteByQuery(query, {
+                        bypassEmitAction: (params) => nestedActionEvents.push(params),
+                        emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
+                    });
                 }
                 else {
                     await itemsService.updateByQuery(query, { [relation.field]: null }, {
                         onRevisionCreate: (pk) => revisions.push(pk),
+                        bypassEmitAction: (params) => nestedActionEvents.push(params),
+                        emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                     });
                 }
             }
@@ -520,11 +538,37 @@ class PayloadService {
                 if (error)
                     throw new exceptions_1.InvalidPayloadException(`Invalid one-to-many update structure: ${error.message}`);
                 if (alterations.create) {
-                    await itemsService.createMany(alterations.create.map((item) => ({
-                        ...item,
-                        [relation.field]: parent || payload[currentPrimaryKeyField],
-                    })), {
+                    const sortField = relation.meta.sort_field;
+                    let createPayload;
+                    if (sortField !== null) {
+                        const highestOrderNumber = await this.knex
+                            .from(relation.collection)
+                            .where({ [relation.field]: parent })
+                            .whereNotNull(sortField)
+                            .max(sortField)
+                            .first();
+                        createPayload = alterations.create.map((item, index) => {
+                            const record = (0, lodash_1.cloneDeep)(item);
+                            // add sort field value if it is not supplied in the item
+                            if (parent !== null && record[sortField] === undefined) {
+                                record[sortField] = (highestOrderNumber === null || highestOrderNumber === void 0 ? void 0 : highestOrderNumber.max) ? highestOrderNumber.max + index + 1 : index + 1;
+                            }
+                            return {
+                                ...record,
+                                [relation.field]: parent || payload[currentPrimaryKeyField],
+                            };
+                        });
+                    }
+                    else {
+                        createPayload = alterations.create.map((item) => ({
+                            ...item,
+                            [relation.field]: parent || payload[currentPrimaryKeyField],
+                        }));
+                    }
+                    await itemsService.createMany(createPayload, {
                         onRevisionCreate: (pk) => revisions.push(pk),
+                        bypassEmitAction: (params) => nestedActionEvents.push(params),
+                        emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                     });
                 }
                 if (alterations.update) {
@@ -535,6 +579,8 @@ class PayloadService {
                             [relation.field]: parent || payload[currentPrimaryKeyField],
                         }, {
                             onRevisionCreate: (pk) => revisions.push(pk),
+                            bypassEmitAction: (params) => nestedActionEvents.push(params),
+                            emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                         });
                     }
                 }
@@ -556,17 +602,22 @@ class PayloadService {
                         },
                     };
                     if (relation.meta.one_deselect_action === 'delete') {
-                        await itemsService.deleteByQuery(query);
+                        await itemsService.deleteByQuery(query, {
+                            bypassEmitAction: (params) => nestedActionEvents.push(params),
+                            emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
+                        });
                     }
                     else {
                         await itemsService.updateByQuery(query, { [relation.field]: null }, {
                             onRevisionCreate: (pk) => revisions.push(pk),
+                            bypassEmitAction: (params) => nestedActionEvents.push(params),
+                            emitEvents: opts === null || opts === void 0 ? void 0 : opts.emitEvents,
                         });
                     }
                 }
             }
         }
-        return { revisions };
+        return { revisions, nestedActionEvents };
     }
     /**
      * Transforms the input partial payload to match the output structure, to have consistency

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

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

package/dist/services/payload.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const knex_1 = __importDefault(require("knex"));
+const knex_mock_client_1 = require("knex-mock-client");
+const services_1 = require("../../src/services");
+const helpers_1 = require("../../src/database/helpers");
+jest.mock('../../src/database/index', () => {
+    return { getDatabaseClient: jest.fn().mockReturnValue('postgres') };
+});
+jest.requireMock('../../src/database/index');
+describe('Integration Tests', () => {
+    let db;
+    let tracker;
+    beforeAll(async () => {
+        db = (0, knex_1.default)({ client: knex_mock_client_1.MockClient });
+        tracker = (0, knex_mock_client_1.getTracker)();
+    });
+    afterEach(() => {
+        tracker.reset();
+    });
+    describe('Services / PayloadService', () => {
+        describe('transformers', () => {
+            let service;
+            let helpers;
+            beforeEach(() => {
+                service = new services_1.PayloadService('test', {
+                    knex: db,
+                    schema: { collections: {}, relations: [] },
+                });
+                helpers = (0, helpers_1.getHelpers)(db);
+            });
+            describe('csv', () => {
+                it('Returns undefined for illegal values', async () => {
+                    const result = await service.transformers['cast-csv']({
+                        value: 123,
+                        action: 'read',
+                        payload: {},
+                        accountability: { role: null },
+                        specials: [],
+                        helpers,
+                    });
+                    expect(result).toBe(undefined);
+                });
+                it('Returns [] for empty strings', async () => {
+                    const result = await service.transformers['cast-csv']({
+                        value: '',
+                        action: 'read',
+                        payload: {},
+                        accountability: { role: null },
+                        specials: [],
+                        helpers,
+                    });
+                    expect(result).toMatchObject([]);
+                });
+                it('Splits the CSV string', async () => {
+                    const result = await service.transformers['cast-csv']({
+                        value: 'test,directus',
+                        action: 'read',
+                        payload: {},
+                        accountability: { role: null },
+                        specials: [],
+                        helpers,
+                    });
+                    expect(result).toMatchObject(['test', 'directus']);
+                });
+                it('Saves array values as joined string', async () => {
+                    const result = await service.transformers['cast-csv']({
+                        value: ['test', 'directus'],
+                        action: 'create',
+                        payload: {},
+                        accountability: { role: null },
+                        specials: [],
+                        helpers,
+                    });
+                    expect(result).toBe('test,directus');
+                });
+                it('Saves string values as is', async () => {
+                    const result = await service.transformers['cast-csv']({
+                        value: 'test,directus',
+                        action: 'create',
+                        payload: {},
+                        accountability: { role: null },
+                        specials: [],
+                        helpers,
+                    });
+                    expect(result).toBe('test,directus');
+                });
+            });
+        });
+    });
+});

package/dist/services/server.js

@@ -28,7 +28,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerService = void 0;
 const lodash_1 = require("lodash");
-const macos_release_1 = __importDefault(require("macos-release"));
 const nanoid_1 = require("nanoid");
 const os_1 = __importDefault(require("os"));
 const perf_hooks_1 = require("perf_hooks");
@@ -43,6 +42,7 @@ const storage_1 = __importDefault(require("../storage"));
 const utils_1 = require("@directus/shared/utils");
 const mailer_1 = __importDefault(require("../mailer"));
 const settings_1 = require("./settings");
+const get_os_info_1 = require("../utils/get-os-info");
 class ServerService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -77,10 +77,12 @@ class ServerService {
             else {
                 info.rateLimit = false;
             }
+            info.flows = {
+                execAllowedModules: env_1.default.FLOWS_EXEC_ALLOWED_MODULES ? (0, utils_1.toArray)(env_1.default.FLOWS_EXEC_ALLOWED_MODULES) : [],
+            };
         }
         if (((_b = this.accountability) === null || _b === void 0 ? void 0 : _b.admin) === true) {
-            const osType = os_1.default.type() === 'Darwin' ? 'macOS' : os_1.default.type();
-            const osVersion = osType === 'macOS' ? `${(0, macos_release_1.default)().name} (${(0, macos_release_1.default)().version})` : os_1.default.release();
+            const { osType, osVersion } = (0, get_os_info_1.getOSInfo)();
             info.directus = {
                 version: package_json_1.version,
             };
@@ -141,7 +143,7 @@ class ServerService {
                     componentType: 'datastore',
                     observedUnit: 'ms',
                     observedValue: 0,
-                    threshold: 150,
+                    threshold: env_1.default.DB_HEALTHCHECK_THRESHOLD ? +env_1.default.DB_HEALTHCHECK_THRESHOLD : 150,
                 },
             ];
             const startTime = perf_hooks_1.performance.now();
@@ -186,7 +188,7 @@ class ServerService {
                         componentType: 'cache',
                         observedValue: 0,
                         observedUnit: 'ms',
-                        threshold: 150,
+                        threshold: env_1.default.CACHE_HEALTHCHECK_THRESHOLD ? +env_1.default.CACHE_HEALTHCHECK_THRESHOLD : 150,
                     },
                 ],
             };
@@ -220,7 +222,7 @@ class ServerService {
                         componentType: 'ratelimiter',
                         observedValue: 0,
                         observedUnit: 'ms',
-                        threshold: 150,
+                        threshold: env_1.default.RATE_LIMITER_HEALTHCHECK_THRESHOLD ? +env_1.default.RATE_LIMITER_HEALTHCHECK_THRESHOLD : 150,
                     },
                 ],
             };
@@ -247,13 +249,14 @@ class ServerService {
             const checks = {};
             for (const location of (0, utils_1.toArray)(env_1.default.STORAGE_LOCATIONS)) {
                 const disk = storage_1.default.disk(location);
+                const envThresholdKey = `STORAGE_${location}_HEALTHCHECK_THRESHOLD`.toUpperCase();
                 checks[`storage:${location}:responseTime`] = [
                     {
                         status: 'ok',
                         componentType: 'objectstore',
                         observedValue: 0,
                         observedUnit: 'ms',
-                        threshold: 750,
+                        threshold: env_1.default[envThresholdKey] ? +env_1.default[envThresholdKey] : 750,
                     },
                 ];
                 const startTime = perf_hooks_1.performance.now();

package/dist/services/shares.js

@@ -31,7 +31,7 @@ class SharesService extends items_1.ItemsService {
         return super.createOne(data, opts);
     }
     async login(payload) {
-        var _a, _b;
+        var _a, _b, _c;
         const record = await this.knex
             .select({
             share_id: 'id',
@@ -86,6 +86,7 @@ class SharesService extends items_1.ItemsService {
             expires: refreshTokenExpiration,
             ip: (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.ip,
             user_agent: (_b = this.accountability) === null || _b === void 0 ? void 0 : _b.userAgent,
+            origin: (_c = this.accountability) === null || _c === void 0 ? void 0 : _c.origin,
             share: record.share_id,
         });
         await this.knex('directus_sessions').delete().where('expires', '<', new Date());

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

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

package/dist/services/specifications.test.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const knex_1 = __importDefault(require("knex"));
+const knex_mock_client_1 = require("knex-mock-client");
+const services_1 = require("../../src/services");
+jest.mock('../../src/database/index', () => {
+    return { getDatabaseClient: jest.fn().mockReturnValue('postgres') };
+});
+jest.requireMock('../../src/database/index');
+class Client_PG extends knex_mock_client_1.MockClient {
+}
+describe('Integration Tests', () => {
+    let db;
+    let tracker;
+    beforeAll(async () => {
+        db = (0, knex_1.default)({ client: Client_PG });
+        tracker = (0, knex_mock_client_1.getTracker)();
+    });
+    afterEach(() => {
+        tracker.reset();
+        jest.clearAllMocks();
+    });
+    describe('Services / Specifications', () => {
+        describe('oas', () => {
+            describe('generate', () => {
+                let service;
+                beforeEach(() => {
+                    service = new services_1.SpecificationService({
+                        knex: db,
+                        schema: { collections: {}, relations: [] },
+                    });
+                });
+                it('returns untyped schema for json fields', async () => {
+                    var _a;
+                    jest.spyOn(services_1.CollectionsService.prototype, 'readByQuery').mockImplementation(jest.fn().mockReturnValue([
+                        {
+                            collection: 'test_table',
+                            meta: {
+                                accountability: 'all',
+                                collection: 'test_table',
+                                group: null,
+                                hidden: false,
+                                icon: null,
+                                item_duplication_fields: null,
+                                note: null,
+                                singleton: false,
+                                translations: null,
+                            },
+                            schema: {
+                                name: 'test_table',
+                            },
+                        },
+                    ]));
+                    jest.spyOn(services_1.FieldsService.prototype, 'readAll').mockImplementation(jest.fn().mockReturnValue([
+                        {
+                            collection: 'test_table',
+                            field: 'id',
+                            type: 'integer',
+                            schema: {
+                                is_nullable: false,
+                            },
+                        },
+                        {
+                            collection: 'test_table',
+                            field: 'blob',
+                            type: 'json',
+                            schema: {
+                                is_nullable: true,
+                            },
+                        },
+                    ]));
+                    jest.spyOn(services_1.RelationsService.prototype, 'readAll').mockImplementation(jest.fn().mockReturnValue([]));
+                    const spec = await service.oas.generate();
+                    expect((_a = spec.components) === null || _a === void 0 ? void 0 : _a.schemas).toEqual({
+                        ItemsTestTable: {
+                            type: 'object',
+                            properties: {
+                                id: {
+                                    nullable: false,
+                                    type: 'integer',
+                                },
+                                blob: {
+                                    nullable: true,
+                                },
+                            },
+                            'x-collection': 'test_table',
+                        },
+                    });
+                });
+            });
+        });
+    });
+});

package/dist/types/items.d.ts

@@ -2,6 +2,7 @@
  * I know this looks a little silly, but it allows us to explicitly differentiate between when we're
  * expecting an item vs any other generic object.
  */
+import { EventContext } from '@directus/shared/types';
 export declare type Item = Record<string, any>;
 export declare type PrimaryKey = string | number;
 export declare type Alterations = {
@@ -26,4 +27,14 @@ export declare type MutationOptions = {
      * Allow disabling the emitting of hooks. Useful if a custom hook is fired (like files.upload)
      */
     emitEvents?: boolean;
+    /**
+     * To bypass the emitting of action events if emitEvents is enabled
+     * Can be used to queue up the nested events from item service's create, update and delete
+     */
+    bypassEmitAction?: (params: ActionEventParams) => void;
+};
+export declare type ActionEventParams = {
+    event: string | string[];
+    meta: Record<string, any>;
+    context: EventContext;
 };

package/dist/utils/apply-query.js

@@ -212,11 +212,11 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     const { columnPath, targetCollection } = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
                     if (!columnPath)
                         continue;
-                    validateFilterOperator(schema.collections[targetCollection].fields[(0, strip_function_1.stripFunction)(filterPath[filterPath.length - 1])].type, filterOperator);
+                    validateFilterOperator(schema.collections[targetCollection].fields[(0, strip_function_1.stripFunction)(filterPath[filterPath.length - 1])].type, filterOperator, schema.collections[targetCollection].fields[(0, strip_function_1.stripFunction)(filterPath[filterPath.length - 1])].special);
                     applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
                 }
                 else {
-                    validateFilterOperator(schema.collections[collection].fields[(0, strip_function_1.stripFunction)(filterPath[0])].type, filterOperator);
+                    validateFilterOperator(schema.collections[collection].fields[(0, strip_function_1.stripFunction)(filterPath[0])].type, filterOperator, schema.collections[collection].fields[(0, strip_function_1.stripFunction)(filterPath[0])].special);
                     applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
                 }
             }
@@ -248,13 +248,17 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 }
             }
         }
-        function validateFilterOperator(type, filterOperator) {
+        function validateFilterOperator(type, filterOperator, special) {
             if (filterOperator.startsWith('_')) {
                 filterOperator = filterOperator.slice(1);
             }
             if (!(0, utils_1.getFilterOperatorsForType)(type).includes(filterOperator)) {
                 throw new invalid_query_1.InvalidQueryException(`"${type}" field type does not contain the "_${filterOperator}" filter operator`);
             }
+            if (special.includes('conceal') &&
+                !(0, utils_1.getFilterOperatorsForType)('hash').includes(filterOperator)) {
+                throw new invalid_query_1.InvalidQueryException(`Field with "conceal" special does not allow the "_${filterOperator}" filter operator`);
+            }
         }
         function applyFilterToQuery(key, operator, compareValue, logical = 'and', originalCollectionName) {
             const [table, column] = key.split('.');

package/dist/utils/apply-snapshot.js

@@ -64,6 +64,21 @@ async function applySnapshot(snapshot, options) {
         const deleteCollections = async (collections) => {
             for (const { collection, diff } of collections) {
                 if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
+                    const relations = schema.relations.filter((r) => r.related_collection === collection || r.collection === collection);
+                    if (relations.length > 0) {
+                        const relationsService = new services_1.RelationsService({ knex: trx, schema });
+                        for (const relation of relations) {
+                            try {
+                                await relationsService.deleteOne(relation.collection, relation.field);
+                            }
+                            catch (err) {
+                                logger_1.default.error(`Failed to delete collection "${collection}" due to relation "${relation.collection}.${relation.field}"`);
+                                throw err;
+                            }
+                        }
+                        // clean up deleted relations from existing schema
+                        schema.relations = schema.relations.filter((r) => r.related_collection !== collection && r.collection !== collection);
+                    }
                     await deleteCollections(getNestedCollectionsToDelete(collection));
                     try {
                         await collectionsService.deleteOne(collection);

package/dist/utils/apply-snapshot.test.d.ts

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