directus 9.20.4 → 9.21.0

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

@@ -1,76 +0,0 @@
-"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.js

@@ -1,60 +0,0 @@
-"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-auth-providers.test.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-let factoryEnv = {};
-jest.mock('../../src/env', () => new Proxy({}, {
-    get(target, prop) {
-        return factoryEnv[prop];
-    },
-}));
-const get_auth_providers_1 = require("../../src/utils/get-auth-providers");
-const scenarios = [
-    {
-        name: 'when no providers configured',
-        input: {},
-        output: [],
-    },
-    {
-        name: 'when no driver configured',
-        input: {
-            AUTH_PROVIDERS: 'directus',
-        },
-        output: [],
-    },
-    {
-        name: 'when single provider and driver are properly configured',
-        input: {
-            AUTH_PROVIDERS: 'directus',
-            AUTH_DIRECTUS_DRIVER: 'openid',
-            AUTH_DIRECTUS_LABEL: 'Directus',
-            AUTH_DIRECTUS_ICON: 'hare',
-        },
-        output: [
-            {
-                name: 'directus',
-                driver: 'openid',
-                label: 'Directus',
-                icon: 'hare',
-            },
-        ],
-    },
-    {
-        name: 'when multiple provider and driver are properly configured',
-        input: {
-            AUTH_PROVIDERS: 'directus,custom',
-            AUTH_DIRECTUS_DRIVER: 'openid',
-            AUTH_DIRECTUS_LABEL: 'Directus',
-            AUTH_DIRECTUS_ICON: 'hare',
-            AUTH_CUSTOM_DRIVER: 'openid',
-            AUTH_CUSTOM_ICON: 'lock',
-        },
-        output: [
-            {
-                name: 'directus',
-                driver: 'openid',
-                label: 'Directus',
-                icon: 'hare',
-            },
-            {
-                name: 'custom',
-                driver: 'openid',
-                icon: 'lock',
-            },
-        ],
-    },
-];
-describe('get auth providers', () => {
-    for (const scenario of scenarios) {
-        test(scenario.name, () => {
-            factoryEnv = scenario.input;
-            expect((0, get_auth_providers_1.getAuthProviders)()).toEqual(scenario.output);
-        });
-    }
-});

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

@@ -1,74 +0,0 @@
-"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 method = 'GET';
-const requests = [
-    {
-        name: 'as unauthenticated request',
-        params: { method, originalUrl: restUrl },
-        key: '17da8272c9a0ec6eea38a37d6d78bddeb7c79045',
-    },
-    {
-        name: 'as authenticated request',
-        params: { method, originalUrl: restUrl, accountability },
-        key: '99a6394222a3d7d149ac1662fc2fff506932db58',
-    },
-    {
-        name: 'a request with a fields query',
-        params: { method, originalUrl: restUrl, sanitizedQuery: { fields: ['id', 'name'] } },
-        key: 'aa6e2d8a78de4dfb4af6eaa230d1cd9b7d31ed19',
-    },
-    {
-        name: 'a request with a filter query',
-        params: { method, originalUrl: restUrl, sanitizedQuery: { filter: { name: { _eq: 'test' } } } },
-        key: 'd7eb8970f0429e1cf85e12eb5bb8669f618b09d3',
-    },
-    {
-        name: 'a GraphQL GET query request',
-        params: { method, originalUrl: graphQlUrl, query: { query: 'query { test { id } }' } },
-        key: '201731b75c627c60554512d819b6935b54c73814',
-    },
-    {
-        name: 'a GraphQL POST query request',
-        params: { method: 'POST', originalUrl: graphQlUrl, body: { query: 'query { test { name } }' } },
-        key: '64eb0c48ea69d0863ff930398f29b5c7884f88f7',
-    },
-    {
-        name: 'an authenticated GraphQL GET query request',
-        params: { method, originalUrl: graphQlUrl, accountability, query: { query: 'query { test { id } }' } },
-        key: '9bc52c98dcf2de04c64589f52e0ada1e38d53a90',
-    },
-    {
-        name: 'an authenticated GraphQL POST query request',
-        params: { method: 'POST', originalUrl: graphQlUrl, accountability, body: { query: 'query { test { name } }' } },
-        key: '051ea77ce5ba71bbc88bcb567b9ddc602b585c13',
-    },
-];
-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 = cases.map(([, params]) => (0, get_cache_key_1.getCacheKey)(params));
-        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 = { method, originalUrl: graphQlUrl, query: { query, operationName, variables: variables1 } };
-        const req2 = { method, originalUrl: graphQlUrl, query: { query, operationName, variables: variables2 } };
-        const postReq1 = { method: 'POST', originalUrl: req1.originalUrl, body: req1.query };
-        const postReq2 = { method: 'POST', originalUrl: req2.originalUrl, body: req2.query };
-        expect((0, get_cache_key_1.getCacheKey)(req1)).not.toEqual((0, get_cache_key_1.getCacheKey)(req2));
-        expect((0, get_cache_key_1.getCacheKey)(postReq1)).not.toEqual((0, get_cache_key_1.getCacheKey)(postReq2));
-        expect((0, get_cache_key_1.getCacheKey)(req1)).toEqual((0, get_cache_key_1.getCacheKey)(postReq1));
-        expect((0, get_cache_key_1.getCacheKey)(req2)).toEqual((0, get_cache_key_1.getCacheKey)(postReq2));
-    });
-});

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

@@ -1,136 +0,0 @@
-"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.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_config_from_env_1 = require("../../src/utils/get-config-from-env");
-jest.mock('../../src/env', () => ({
-    OBJECT_BRAND__COLOR: 'purple',
-    OBJECT_BRAND__HEX: '#6644FF',
-    CAMELCASE_OBJECT__FIRST_KEY: 'firstValue',
-    CAMELCASE_OBJECT__SECOND_KEY: 'secondValue',
-}));
-describe('get config from env', () => {
-    test('Keys with double underscore should be an object', () => {
-        expect((0, get_config_from_env_1.getConfigFromEnv)('OBJECT_')).toStrictEqual({ brand: { color: 'purple', hex: '#6644FF' } });
-    });
-    test('Keys with double underscore should be an object with camelCase keys', () => {
-        expect((0, get_config_from_env_1.getConfigFromEnv)('CAMELCASE_')).toStrictEqual({
-            object: { firstKey: 'firstValue', secondKey: 'secondValue' },
-        });
-    });
-});

package/dist/utils/get-relation-info.test.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_relation_info_1 = require("../../src/utils/get-relation-info");
-describe('getRelationInfo', () => {
-    it('Errors on suspiciously long implicit $FOLLOW', () => {
-        expect(() => (0, get_relation_info_1.getRelationInfo)([], 'related_test_collection', '$FOLLOW(test_collection, test_field, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)')).toThrowError(Error);
-    });
-    it('Generates a new relation object for an implicit o2m relation', () => {
-        const result = (0, get_relation_info_1.getRelationInfo)([], 'related_test_collection', '$FOLLOW(test_collection, test_field)');
-        expect(result).toEqual({
-            relation: {
-                collection: 'test_collection',
-                field: 'test_field',
-                related_collection: 'related_test_collection',
-                schema: null,
-                meta: null,
-            },
-            relationType: 'o2m',
-        });
-    });
-    it('Generates a new relation object for an implicit o2a relation', () => {
-        const result = (0, get_relation_info_1.getRelationInfo)([], 'related_test_collection', '$FOLLOW(test_collection, test_field, test_collection_field)');
-        expect(result).toEqual({
-            relation: {
-                collection: 'test_collection',
-                field: 'test_field',
-                related_collection: 'related_test_collection',
-                schema: null,
-                meta: {
-                    one_collection_field: 'test_collection_field',
-                },
-            },
-            relationType: 'o2a',
-        });
-    });
-    it('Returns the correct existing relation for the given collection/field', () => {
-        const testRelations = [
-            // o2m
-            {
-                collection: 'articles',
-                field: 'author_id',
-                related_collection: 'authors',
-                meta: {
-                    one_field: 'articles',
-                },
-                schema: null,
-            },
-            // m2o
-            {
-                collection: 'articles',
-                field: 'category_id',
-                related_collection: 'categories',
-                meta: null,
-                schema: null,
-            },
-            // a2o
-            {
-                collection: 'pages',
-                field: 'item',
-                related_collection: null,
-                meta: {
-                    one_collection_field: 'collection',
-                    one_allowed_collections: ['headings', 'paragraphs', 'images'],
-                },
-            },
-        ];
-        const o2mResult = (0, get_relation_info_1.getRelationInfo)(testRelations, 'authors', 'articles');
-        expect(o2mResult).toEqual({
-            relationType: 'o2m',
-            relation: testRelations[0],
-        });
-        const m2oResult = (0, get_relation_info_1.getRelationInfo)(testRelations, 'articles', 'category_id');
-        expect(m2oResult).toEqual({
-            relationType: 'm2o',
-            relation: testRelations[1],
-        });
-        const a2oResult = (0, get_relation_info_1.getRelationInfo)(testRelations, 'pages', 'item');
-        expect(a2oResult).toEqual({
-            relationType: 'a2o',
-            relation: testRelations[2],
-        });
-        const noResult = (0, get_relation_info_1.getRelationInfo)(testRelations, 'does not exist', 'wrong field');
-        expect(noResult).toEqual({
-            relation: null,
-            relationType: null,
-        });
-    });
-});

package/dist/utils/get-relation-type.test.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_relation_type_1 = require("../../src/utils/get-relation-type");
-test('Returns null if no relation object is included', () => {
-    const result = (0, get_relation_type_1.getRelationType)({ relation: null, collection: null, field: 'test' });
-    expect(result).toBe(null);
-});
-test('Returns a2o if relation matches and includes one_collection_field and one_allowed_collection', () => {
-    const relation = {
-        collection: 'pages',
-        field: 'item',
-        related_collection: null,
-        meta: {
-            one_collection_field: 'collection',
-            one_allowed_collections: ['paragraphs', 'headings', 'images'],
-        },
-    };
-    const result = (0, get_relation_type_1.getRelationType)({
-        relation,
-        collection: 'pages',
-        field: 'item',
-    });
-    expect(result).toBe('a2o');
-});
-test('Returns m2o', () => {
-    const relation = {
-        collection: 'articles',
-        field: 'author',
-        related_collection: 'authors',
-    };
-    const result = (0, get_relation_type_1.getRelationType)({
-        relation,
-        collection: 'articles',
-        field: 'author',
-    });
-    expect(result).toBe('m2o');
-});
-test('Returns o2m', () => {
-    const relation = {
-        collection: 'articles',
-        field: 'author',
-        related_collection: 'authors',
-        meta: {
-            one_field: 'articles',
-        },
-    };
-    const result = (0, get_relation_type_1.getRelationType)({
-        relation,
-        collection: 'authors',
-        field: 'articles',
-    });
-    expect(result).toBe('o2m');
-});
-test('Returns null when field/collection doesnt match the relationship', () => {
-    const relation = {
-        collection: 'articles',
-        field: 'author',
-        related_collection: 'authors',
-        meta: {
-            one_field: 'articles',
-        },
-    };
-    const result = (0, get_relation_type_1.getRelationType)({
-        relation,
-        collection: 'unrelated',
-        field: 'wrong',
-    });
-    expect(result).toBe(null);
-});

package/dist/utils/get-string-byte-size.test.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const get_string_byte_size_1 = require("../../src/utils/get-string-byte-size");
-test('Returns correct byte size for given input string', () => {
-    expect((0, get_string_byte_size_1.stringByteSize)('test')).toBe(4);
-    expect((0, get_string_byte_size_1.stringByteSize)('🐡')).toBe(4);
-    expect((0, get_string_byte_size_1.stringByteSize)('👨‍👧‍👦')).toBe(18);
-});

package/dist/utils/is-directus-jwt.test.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_directus_jwt_1 = __importDefault(require("../../src/utils/is-directus-jwt"));
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-test('Returns false for non JWT string', () => {
-    const result = (0, is_directus_jwt_1.default)('test');
-    expect(result).toBe(false);
-});
-test('Returns false for JWTs with text payload', () => {
-    const token = jsonwebtoken_1.default.sign('plaintext', 'secret');
-    const result = (0, is_directus_jwt_1.default)(token);
-    expect(result).toBe(false);
-});
-test(`Returns false if token issuer isn't "directus"`, () => {
-    const token = jsonwebtoken_1.default.sign({ payload: 'content' }, 'secret', { issuer: 'rijk' });
-    const result = (0, is_directus_jwt_1.default)(token);
-    expect(result).toBe(false);
-});
-test(`Returns true if token is valid JWT and issuer is "directus"`, () => {
-    const token = jsonwebtoken_1.default.sign({ payload: 'content' }, 'secret', { issuer: 'directus' });
-    const result = (0, is_directus_jwt_1.default)(token);
-    expect(result).toBe(true);
-});

package/dist/utils/jwt.test.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const jwt_1 = require("../../src/utils/jwt");
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const exceptions_1 = require("../../src/exceptions");
-const payload = { role: null, app_access: false, admin_access: false };
-const secret = 'test-secret';
-const options = { issuer: 'directus' };
-test('Returns the payload of a correctly signed token', () => {
-    const token = jsonwebtoken_1.default.sign(payload, secret, options);
-    const result = (0, jwt_1.verifyAccessJWT)(token, secret);
-    expect(result).toEqual(payload);
-});
-test('Throws TokenExpiredException when token used has expired', () => {
-    const token = jsonwebtoken_1.default.sign({ ...payload, exp: new Date().getTime() / 1000 - 500 }, secret, options);
-    expect(() => (0, jwt_1.verifyAccessJWT)(token, secret)).toThrow(exceptions_1.TokenExpiredException);
-});
-const InvalidTokenCases = {
-    'wrong issuer': jsonwebtoken_1.default.sign(payload, secret, { issuer: 'wrong' }),
-    'wrong secret': jsonwebtoken_1.default.sign(payload, 'wrong-secret', options),
-    'string payload': jsonwebtoken_1.default.sign('illegal payload', secret),
-    'missing properties in token payload': jsonwebtoken_1.default.sign({ role: null }, secret, options),
-};
-Object.entries(InvalidTokenCases).forEach(([title, token]) => test(`Throws InvalidTokenError - ${title}`, () => {
-    expect(() => (0, jwt_1.verifyAccessJWT)(token, secret)).toThrow(exceptions_1.InvalidTokenException);
-}));
-test(`Throws ServiceUnavailableException for unexpected error from jsonwebtoken`, () => {
-    jest.spyOn(jsonwebtoken_1.default, 'verify').mockImplementation(() => {
-        throw new Error();
-    });
-    const token = jsonwebtoken_1.default.sign(payload, secret, options);
-    expect(() => (0, jwt_1.verifyAccessJWT)(token, secret)).toThrow(exceptions_1.ServiceUnavailableException);
-});