directus 9.15.1 → 9.17.0

package/dist/utils/apply-snapshot.test.js

@@ -0,0 +1,305 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 schemas_1 = require("../__utils__/schemas");
+const services_1 = require("../services");
+const apply_snapshot_1 = require("./apply-snapshot");
+const getSchema = __importStar(require("./get-schema"));
+const snapshots_1 = require("../__utils__/snapshots");
+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('applySnapshot', () => {
+    let db;
+    let tracker;
+    beforeEach(() => {
+        db = (0, knex_1.default)({ client: Client_PG });
+        tracker = (0, knex_mock_client_1.getTracker)();
+    });
+    afterEach(() => {
+        tracker.reset();
+        jest.clearAllMocks();
+    });
+    describe('Creating new collection(s)', () => {
+        it('Creates new top-level collection(s)', async () => {
+            const expected = {
+                collection: 'test_table_2',
+                meta: {
+                    accountability: 'all',
+                    collection: 'test_table_2',
+                    group: null,
+                    hidden: true,
+                    icon: 'import_export',
+                    item_duplication_fields: null,
+                    note: null,
+                    singleton: false,
+                    translations: {},
+                },
+                schema: { comment: null, name: 'test_table_2', schema: 'public' },
+                fields: [
+                    {
+                        collection: 'test_table_2',
+                        field: 'id',
+                        meta: {
+                            collection: 'test_table_2',
+                            conditions: null,
+                            display: null,
+                            display_options: null,
+                            field: 'id',
+                            group: null,
+                            hidden: true,
+                            interface: null,
+                            note: null,
+                            options: null,
+                            readonly: false,
+                            required: false,
+                            sort: null,
+                            special: null,
+                            translations: {},
+                            validation: null,
+                            validation_message: null,
+                            width: 'full',
+                        },
+                        schema: {
+                            comment: null,
+                            data_type: 'uuid',
+                            default_value: null,
+                            foreign_key_column: null,
+                            foreign_key_schema: null,
+                            foreign_key_table: null,
+                            generation_expression: null,
+                            has_auto_increment: false,
+                            is_generated: false,
+                            is_nullable: false,
+                            is_primary_key: true,
+                            is_unique: true,
+                            max_length: null,
+                            name: 'id',
+                            numeric_precision: null,
+                            numeric_scale: null,
+                            schema: 'public',
+                            table: 'test_table_2',
+                        },
+                        type: 'uuid',
+                    },
+                ],
+            };
+            // Stop call to db later on in apply-snapshot
+            jest.spyOn(getSchema, 'getSchema').mockReturnValue(Promise.resolve(schemas_1.snapshotApplyTestSchema));
+            // We are not actually testing that createOne works, just that is is called correctly
+            const createOneCollectionSpy = jest
+                .spyOn(services_1.CollectionsService.prototype, 'createOne')
+                .mockImplementation(jest.fn());
+            const createFieldSpy = jest.spyOn(services_1.FieldsService.prototype, 'createField').mockImplementation(jest.fn());
+            await (0, apply_snapshot_1.applySnapshot)(snapshots_1.snapshotCreateCollectionNotNested, {
+                database: db,
+                current: snapshots_1.snapshotBeforeCreateCollection,
+                schema: schemas_1.snapshotApplyTestSchema,
+            });
+            expect(createOneCollectionSpy).toHaveBeenCalledTimes(1);
+            expect(createOneCollectionSpy).toHaveBeenCalledWith(expected);
+            // There should be no fields left to create
+            // they will get filtered in createCollections
+            expect(createFieldSpy).toHaveBeenCalledTimes(0);
+        });
+        it('Creates the highest-level nested collection(s) with existing parents and any children', async () => {
+            const expected = {
+                collection: 'test_table_2',
+                meta: {
+                    accountability: 'all',
+                    collection: 'test_table_2',
+                    group: 'test_table',
+                    hidden: true,
+                    icon: 'import_export',
+                    item_duplication_fields: null,
+                    note: null,
+                    singleton: false,
+                    translations: {},
+                },
+                schema: { comment: null, name: 'test_table_2', schema: 'public' },
+                fields: [
+                    {
+                        collection: 'test_table_2',
+                        field: 'id',
+                        meta: {
+                            collection: 'test_table_2',
+                            conditions: null,
+                            display: null,
+                            display_options: null,
+                            field: 'id',
+                            group: null,
+                            hidden: true,
+                            interface: null,
+                            note: null,
+                            options: null,
+                            readonly: false,
+                            required: false,
+                            sort: null,
+                            special: null,
+                            translations: {},
+                            validation: null,
+                            validation_message: null,
+                            width: 'full',
+                        },
+                        schema: {
+                            comment: null,
+                            data_type: 'uuid',
+                            default_value: null,
+                            foreign_key_column: null,
+                            foreign_key_schema: null,
+                            foreign_key_table: null,
+                            generation_expression: null,
+                            has_auto_increment: false,
+                            is_generated: false,
+                            is_nullable: false,
+                            is_primary_key: true,
+                            is_unique: true,
+                            max_length: null,
+                            name: 'id',
+                            numeric_precision: null,
+                            numeric_scale: null,
+                            schema: 'public',
+                            table: 'test_table_2',
+                        },
+                        type: 'uuid',
+                    },
+                ],
+            };
+            const expected2 = {
+                collection: 'test_table_3',
+                fields: [
+                    {
+                        collection: 'test_table_3',
+                        field: 'id',
+                        meta: {
+                            collection: 'test_table_3',
+                            conditions: null,
+                            display: null,
+                            display_options: null,
+                            field: 'id',
+                            group: null,
+                            hidden: true,
+                            interface: null,
+                            note: null,
+                            options: null,
+                            readonly: false,
+                            required: false,
+                            sort: null,
+                            special: null,
+                            translations: {},
+                            validation: null,
+                            validation_message: null,
+                            width: 'full',
+                        },
+                        schema: {
+                            comment: null,
+                            data_type: 'uuid',
+                            default_value: null,
+                            foreign_key_column: null,
+                            foreign_key_schema: null,
+                            foreign_key_table: null,
+                            generation_expression: null,
+                            has_auto_increment: false,
+                            is_generated: false,
+                            is_nullable: false,
+                            is_primary_key: true,
+                            is_unique: true,
+                            max_length: null,
+                            name: 'id',
+                            numeric_precision: null,
+                            numeric_scale: null,
+                            schema: 'public',
+                            table: 'test_table_3',
+                        },
+                        type: 'uuid',
+                    },
+                ],
+                meta: {
+                    accountability: 'all',
+                    collection: 'test_table_3',
+                    group: 'test_table_2',
+                    hidden: true,
+                    icon: 'import_export',
+                    item_duplication_fields: null,
+                    note: null,
+                    singleton: false,
+                    translations: {},
+                },
+                schema: { comment: null, name: 'test_table_3', schema: 'public' },
+            };
+            // Stop call to db later on in apply-snapshot
+            jest.spyOn(getSchema, 'getSchema').mockReturnValue(Promise.resolve(schemas_1.snapshotApplyTestSchema));
+            // We are not actually testing that createOne works, just that is is called correctly
+            const createOneCollectionSpy = jest
+                .spyOn(services_1.CollectionsService.prototype, 'createOne')
+                .mockImplementation(jest.fn());
+            const createFieldSpy = jest.spyOn(services_1.FieldsService.prototype, 'createField').mockImplementation(jest.fn());
+            await (0, apply_snapshot_1.applySnapshot)(snapshots_1.snapshotCreateCollection, {
+                database: db,
+                current: snapshots_1.snapshotBeforeCreateCollection,
+                schema: schemas_1.snapshotApplyTestSchema,
+            });
+            expect(createOneCollectionSpy).toHaveBeenCalledTimes(2);
+            expect(createOneCollectionSpy).toHaveBeenCalledWith(expected);
+            expect(createOneCollectionSpy).toHaveBeenCalledWith(expected2);
+            // There should be no fields left to create
+            // they will get filtered in createCollections
+            expect(createFieldSpy).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('Delete collections', () => {
+        it('Deletes interrelated collections', async () => {
+            const snapshotToApply = {
+                version: 1,
+                directus: '0.0.0',
+                collections: [],
+                fields: [],
+                relations: [],
+            };
+            // Stop call to db later on in apply-snapshot
+            jest.spyOn(getSchema, 'getSchema').mockReturnValue(Promise.resolve(schemas_1.snapshotApplyTestSchema));
+            // We are not actually testing that deleteOne works, just that is is called correctly
+            const deleteOneCollectionSpy = jest
+                .spyOn(services_1.CollectionsService.prototype, 'deleteOne')
+                .mockImplementation(jest.fn());
+            await (0, apply_snapshot_1.applySnapshot)(snapshotToApply, {
+                database: db,
+                current: snapshots_1.snapshotBeforeDeleteCollection,
+                schema: schemas_1.snapshotApplyTestSchema,
+            });
+            expect(deleteOneCollectionSpy).toHaveBeenCalledTimes(3);
+        });
+    });
+});

package/dist/utils/async-handler.d.ts

@@ -1,7 +1,3 @@
-import { ErrorRequestHandler, RequestHandler } from 'express';
-/**
- * Handles promises in routes.
- */
-declare function asyncHandler(handler: RequestHandler): RequestHandler;
-declare function asyncHandler(handler: ErrorRequestHandler): ErrorRequestHandler;
+import type { RequestHandler, Request, Response, NextFunction } from 'express';
+declare const asyncHandler: (fn: RequestHandler) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
 export default asyncHandler;

package/dist/utils/async-handler.js

@@ -1,16 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function asyncHandler(handler) {
-    if (handler.length === 2 || handler.length === 3) {
-        const scoped = (req, res, next) => Promise.resolve(handler(req, res, next)).catch(next);
-        return scoped;
-    }
-    else if (handler.length === 4) {
-        const scoped = (err, req, res, next) => Promise.resolve(handler(err, req, res, next)).catch(next);
-        return scoped;
-    }
-    else {
-        throw new Error(`Failed to asyncHandle() function "${handler.name}"`);
-    }
-}
+const asyncHandler = (fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
 exports.default = asyncHandler;

package/dist/utils/async-handler.test.d.ts

@@ -0,0 +1 @@
+import '../../src/types/express.d.ts';

package/dist/utils/async-handler.test.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../src/types/express.d.ts");
+const async_handler_1 = __importDefault(require("./async-handler"));
+let mockRequest;
+let mockResponse;
+const nextFunction = jest.fn();
+test('Wraps async middleware in Promise resolve that will catch rejects and pass them to the nextFn', async () => {
+    const err = new Error('testing');
+    const middleware = async (_req, _res, _next) => {
+        throw err;
+    };
+    await (0, async_handler_1.default)(middleware)(mockRequest, mockResponse, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith(err);
+});

package/dist/utils/calculate-field-depth.test.d.ts

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

package/dist/utils/calculate-field-depth.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const calculate_field_depth_1 = require("../../src/utils/calculate-field-depth");
+test('Calculates basic depth', () => {
+    const filter = {
+        name: {
+            _eq: 'test',
+        },
+    };
+    const result = (0, calculate_field_depth_1.calculateFieldDepth)(filter);
+    expect(result).toBe(1);
+});
+test('Calculates relational depth', () => {
+    const filter = {
+        author: {
+            name: {
+                _eq: 'test',
+            },
+        },
+    };
+    const result = (0, calculate_field_depth_1.calculateFieldDepth)(filter);
+    expect(result).toBe(2);
+});
+test('Ignores _and/_or', () => {
+    const filter = {
+        _and: [
+            {
+                _or: [
+                    {
+                        author: {
+                            name: {
+                                _eq: 'Directus',
+                            },
+                        },
+                    },
+                    {
+                        status: {
+                            _eq: 'published',
+                        },
+                    },
+                ],
+            },
+            {
+                category: {
+                    _eq: 'recipes',
+                },
+            },
+        ],
+    };
+    const result = (0, calculate_field_depth_1.calculateFieldDepth)(filter);
+    expect(result).toBe(2);
+});
+test('Skips underscore prefix in tree', () => {
+    const deep = {
+        translations: {
+            _filter: {
+                language_id: {
+                    code: {
+                        _eq: 'nl-NL',
+                    },
+                },
+            },
+        },
+    };
+    const result = (0, calculate_field_depth_1.calculateFieldDepth)(deep);
+    expect(result).toBe(3);
+});
+test('Calculates _sort in deep correctly', () => {
+    const deep = {
+        articles: {
+            _sort: ['sort', 'category.type.sort'],
+        },
+    };
+    const result = (0, calculate_field_depth_1.calculateFieldDepth)(deep, ['_sort']);
+    expect(result).toBe(4);
+});

package/dist/utils/filter-items.test.d.ts

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

package/dist/utils/filter-items.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_items_1 = require("../../src/utils/filter-items");
+const items = [
+    {
+        role: '9bc9fea0-f761-4107-bfb7-b3d06c125e98',
+        permissions: {},
+        validation: null,
+        presets: null,
+        fields: ['*'],
+        system: true,
+        collection: 'directus_settings',
+        action: 'read',
+    },
+    {
+        role: '9bc9fea0-f761-4107-bfb7-b3d06c125e98',
+        permissions: {
+            user: {
+                _eq: '$CURRENT_USER',
+            },
+        },
+        validation: null,
+        presets: null,
+        fields: ['*'],
+        system: true,
+        collection: 'directus_presets',
+        action: 'delete',
+    },
+];
+describe('filter items', () => {
+    test('return items when no filter', () => {
+        const result = (0, filter_items_1.filterItems)(items, undefined);
+        expect(result).toStrictEqual(items);
+    });
+    test('return items when empty filter used', () => {
+        const result = (0, filter_items_1.filterItems)(items, {});
+        expect(result).toStrictEqual(items);
+    });
+    test('return filtered items when nested empty filter used', () => {
+        const result = (0, filter_items_1.filterItems)(items, {
+            _and: [
+                {
+                    action: {
+                        _eq: 'read',
+                    },
+                },
+                {},
+            ],
+        });
+        expect(result).toStrictEqual(items.filter((item) => item.action === 'read'));
+    });
+    test('return filtered items', () => {
+        const result = (0, filter_items_1.filterItems)(items, {
+            action: {
+                _eq: 'read',
+            },
+        });
+        expect(result).toStrictEqual(items.filter((item) => item.action === 'read'));
+    });
+});

package/dist/utils/get-cache-key.test.d.ts

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

package/dist/utils/get-cache-key.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_cache_key_1 = require("../../src/utils/get-cache-key");
+const restUrl = 'http://localhost/items/example';
+const graphQlUrl = 'http://localhost/graphql';
+const accountability = { user: '00000000-0000-0000-0000-000000000000' };
+const requests = [
+    {
+        name: 'as unauthenticated request',
+        params: { originalUrl: restUrl },
+        key: '17da8272c9a0ec6eea38a37d6d78bddeb7c79045',
+    },
+    {
+        name: 'as authenticated request',
+        params: { originalUrl: restUrl, accountability },
+        key: '99a6394222a3d7d149ac1662fc2fff506932db58',
+    },
+    {
+        name: 'a request with a fields query',
+        params: { originalUrl: restUrl, sanitizedQuery: { fields: ['id', 'name'] } },
+        key: 'aa6e2d8a78de4dfb4af6eaa230d1cd9b7d31ed19',
+    },
+    {
+        name: 'a request with a filter query',
+        params: { originalUrl: restUrl, sanitizedQuery: { filter: { name: { _eq: 'test' } } } },
+        key: 'd7eb8970f0429e1cf85e12eb5bb8669f618b09d3',
+    },
+    {
+        name: 'a GraphQL query request',
+        params: { originalUrl: graphQlUrl, query: { query: 'query { test { id } }' } },
+        key: '201731b75c627c60554512d819b6935b54c73814',
+    },
+];
+const cases = requests.map(({ name, params, key }) => [name, params, key]);
+describe('get cache key', () => {
+    test.each(cases)('should create a cache key for %s', (_, params, key) => {
+        expect((0, get_cache_key_1.getCacheKey)(params)).toEqual(key);
+    });
+    test('should create a unique key for each request', () => {
+        const keys = requests.map((r) => r.key);
+        const hasDuplicate = keys.some((key) => keys.indexOf(key) !== keys.lastIndexOf(key));
+        expect(hasDuplicate).toBeFalsy();
+    });
+    test('should create a unique key for GraphQL requests with different variables', () => {
+        const query = 'query Test ($name: String) { test (filter: { name: { _eq: $name } }) { id } }';
+        const operationName = 'test';
+        const variables1 = JSON.stringify({ name: 'test 1' });
+        const variables2 = JSON.stringify({ name: 'test 2' });
+        const req1 = { originalUrl: graphQlUrl, query: { query, operationName, variables: variables1 } };
+        const req2 = { originalUrl: graphQlUrl, query: { query, operationName, variables: variables2 } };
+        expect((0, get_cache_key_1.getCacheKey)(req1)).not.toEqual((0, get_cache_key_1.getCacheKey)(req2));
+    });
+});

package/dist/utils/get-column-path.test.d.ts

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