directus 9.14.5 → 9.16.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,
                     });
                 }
             }
@@ -525,6 +543,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,
                     });
                 }
                 if (alterations.update) {
@@ -535,6 +555,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 +578,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,
             };

package/dist/services/specifications.js

@@ -77,12 +77,7 @@ class OASSpecsService {
             integer: {
                 type: 'integer',
             },
-            json: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-            },
+            json: {},
             string: {
                 type: 'string',
             },

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

@@ -13,6 +13,7 @@ const get_column_1 = require("./get-column");
 const get_column_path_1 = require("./get-column-path");
 const get_relation_info_1 = require("./get-relation-info");
 const utils_1 = require("@directus/shared/utils");
+const strip_function_1 = require("./strip-function");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -211,9 +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, 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, schema.collections[collection].fields[(0, strip_function_1.stripFunction)(filterPath[0])].special);
                     applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
                 }
             }
@@ -245,6 +248,18 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 }
             }
         }
+        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('.');
             // Is processed through Knex.Raw, so should be safe to string-inject into these where queries

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 {};