directus 9.14.5 → 9.16.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/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/compress.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function compress(raw: Record<string, any> | Record<string, any>[]): Promise<Buffer>;
+export declare function decompress(compressed: Buffer): Promise<any>;

package/dist/utils/compress.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decompress = exports.compress = void 0;
+const snappy_1 = require("snappy");
+const utils_1 = require("@directus/shared/utils");
+async function compress(raw) {
+    if (!raw)
+        return raw;
+    return await (0, snappy_1.compress)((0, utils_1.compress)(raw));
+}
+exports.compress = compress;
+async function decompress(compressed) {
+    if (!compressed)
+        return compressed;
+    return (0, utils_1.decompress)((await (0, snappy_1.uncompress)(compressed, { asBuffer: false })));
+}
+exports.decompress = decompress;

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-ast-from-query.js

@@ -70,7 +70,7 @@ async function getASTFromQuery(collection, query, schema, options) {
         if (!fields)
             return [];
         fields = await convertWildcards(parentCollection, fields);
-        if (!fields)
+        if (!fields || !Array.isArray(fields))
             return [];
         const children = [];
         const relationalStructure = {};

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

package/dist/utils/get-column-path.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_column_path_1 = require("../../src/utils/get-column-path");
+const exceptions_1 = require("../../src/exceptions");
+/*
+{
+  path: [ 'author', 'role', 'name' ],
+  collection: 'articles',
+  aliasMap: {
+    author: { role: { name: 'ljnsv' } },
+    ljnsv: { role: { name: 'grenv' } }
+  },
+  relations: []
+
+grenv.name
+
+{
+  path: [ 'author', 'first_name' ],
+  collection: 'articles',
+  aliasMap: { author: { first_name: 'rnmxt' } },
+  relations: []
+
+rnmxt.first_name
+
+{
+  path: [ 'item:headings', 'text' ],
+  collection: 'pages_sections',
+  aliasMap: { 'item:headings': { text: 'yllus' } },
+  relations: [
+*/
+test('Throws an error when the field path is not known in relations', () => {
+    const input = {
+        path: ['author', 'first_name'],
+        collection: 'articles',
+        aliasMap: { author: { first_name: 'bjoyu' } },
+        relations: [],
+    };
+    expect(() => (0, get_column_path_1.getColumnPath)(input)).toThrowError(exceptions_1.InvalidQueryException);
+});
+test('Throws an error when an a2o is used without a collection scope', () => {
+    const input = {
+        path: ['item', 'type'],
+        collection: 'pages',
+        aliasMap: {},
+        relations: [
+            {
+                collection: 'pages',
+                field: 'item',
+                related_collection: null,
+                meta: {
+                    one_collection_field: 'collection',
+                    one_allowed_collections: ['paragraphs', 'headings'],
+                },
+            },
+        ],
+    };
+    expect(() => (0, get_column_path_1.getColumnPath)(input)).toThrowError(exceptions_1.InvalidQueryException);
+});
+test('Extracts path scope and returns correct alias for a2o', () => {
+    const input = {
+        path: ['item:headings', 'text'],
+        collection: 'pages',
+        aliasMap: { 'item:headings': { text: 'abcdef' } },
+        relations: [
+            {
+                collection: 'pages',
+                field: 'item',
+                related_collection: null,
+                meta: {
+                    one_collection_field: 'collection',
+                    one_allowed_collections: ['paragraphs', 'headings'],
+                },
+            },
+        ],
+    };
+    const result = (0, get_column_path_1.getColumnPath)(input);
+    expect(result.columnPath).toBe('abcdef.text');
+    expect(result.targetCollection).toBe('headings');
+});
+test('Returns correct alias for m2o', () => {
+    const input = {
+        path: ['author', 'role', 'name'],
+        collection: 'articles',
+        aliasMap: {
+            author: { role: { name: 'ljnsv' } },
+            ljnsv: { role: { name: 'grenv' } },
+        },
+        relations: [
+            {
+                collection: 'articles',
+                field: 'author',
+                related_collection: 'directus_users',
+                meta: null,
+                schema: null,
+            },
+            {
+                collection: 'directus_users',
+                field: 'role',
+                related_collection: 'directus_roles',
+                meta: null,
+                schema: null,
+            },
+        ],
+    };
+    const result = (0, get_column_path_1.getColumnPath)(input);
+    expect(result.columnPath).toBe('grenv.name');
+    expect(result.targetCollection).toBe('directus_roles');
+});
+test('Returns correct alias for o2m (& uses the table name if no alias exists)', () => {
+    const input = {
+        path: ['categories', 'category_id', 'name'],
+        collection: 'articles',
+        aliasMap: {},
+        relations: [
+            {
+                collection: 'categories_articles',
+                field: 'category_id',
+                related_collection: 'categories',
+                meta: null,
+                schema: null,
+            },
+            {
+                collection: 'categories_articles',
+                field: 'article_id',
+                related_collection: 'articles',
+                meta: {
+                    one_field: 'categories',
+                },
+                schema: null,
+            },
+        ],
+    };
+    const result = (0, get_column_path_1.getColumnPath)(input);
+    expect(result.columnPath).toBe('categories.name');
+    expect(result.targetCollection).toBe('categories');
+});

package/dist/utils/get-config-from-env.test.d.ts

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