directus 9.15.1 → 9.16.0

package/dist/utils/get-graphql-type.js

@@ -6,7 +6,10 @@ const graphql_compose_1 = require("graphql-compose");
 const date_1 = require("../services/graphql/types/date");
 const geojson_1 = require("../services/graphql/types/geojson");
 const hash_1 = require("../services/graphql/types/hash");
-function getGraphQLType(localType) {
+function getGraphQLType(localType, special) {
+    if (special.includes('conceal')) {
+        return hash_1.GraphQLHash;
+    }
     switch (localType) {
         case 'boolean':
             return graphql_1.GraphQLBoolean;

package/dist/utils/get-os-info.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get current host OS information
+ *
+ * @returns Object of OS type and version
+ */
+export declare function getOSInfo(): {
+    osType: string;
+    osVersion: string;
+};

package/dist/utils/get-os-info.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOSInfo = void 0;
+const os_1 = __importDefault(require("os"));
+/**
+ * Get current host OS information
+ *
+ * @returns Object of OS type and version
+ */
+function getOSInfo() {
+    const osType = os_1.default.type() === 'Darwin' ? 'macOS' : os_1.default.type();
+    const osVersion = osType === 'macOS' ? macosRelease() : os_1.default.release();
+    return { osType, osVersion };
+}
+exports.getOSInfo = getOSInfo;
+/**
+ * Get the name and version of a macOS release from the Darwin version.
+ * Lifted from `macos-release`.
+ */
+function macosRelease() {
+    const release = Number(os_1.default.release().split('.')[0]);
+    const nameMap = new Map([
+        [22, ['Ventura', '13']],
+        [21, ['Monterey', '12']],
+        [20, ['Big Sur', '11']],
+        [19, ['Catalina', '10.15']],
+        [18, ['Mojave', '10.14']],
+        [17, ['High Sierra', '10.13']],
+        [16, ['Sierra', '10.12']],
+        [15, ['El Capitan', '10.11']],
+        [14, ['Yosemite', '10.10']],
+        [13, ['Mavericks', '10.9']],
+        [12, ['Mountain Lion', '10.8']],
+        [11, ['Lion', '10.7']],
+        [10, ['Snow Leopard', '10.6']],
+        [9, ['Leopard', '10.5']],
+        [8, ['Tiger', '10.4']],
+        [7, ['Panther', '10.3']],
+        [6, ['Jaguar', '10.2']],
+        [5, ['Puma', '10.1']],
+    ]);
+    const current = nameMap.get(release);
+    return current ? `${current[0]} (${current[1]})` : 'Unknown';
+}

package/dist/utils/get-relation-info.test.d.ts

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

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

@@ -0,0 +1,88 @@
+"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.d.ts

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

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

@@ -0,0 +1,69 @@
+"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.d.ts

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

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

@@ -0,0 +1,8 @@
+"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.d.ts

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

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

@@ -0,0 +1,26 @@
+"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.d.ts

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

package/dist/utils/jwt.test.js

@@ -0,0 +1,36 @@
+"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);
+});

package/dist/utils/merge-permissions.test.d.ts

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

package/dist/utils/merge-permissions.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge_permissions_1 = require("../../src/utils/merge-permissions");
+const fullFilter = {};
+const conditionalFilter = { user: { id: { _eq: '$CURRENT_USER' } } };
+const conditionalFilter2 = { count: { _gt: 42 } };
+const permissionTemplate = {
+    role: null,
+    collection: 'directus_users',
+    permissions: null,
+    validation: null,
+    presets: null,
+    fields: null,
+};
+describe('merging permissions', () => {
+    test('processes _or permissions', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('or', { ...permissionTemplate, permissions: conditionalFilter }, { ...permissionTemplate, permissions: conditionalFilter2 });
+        expect(mergedPermission).toStrictEqual({
+            ...permissionTemplate,
+            permissions: {
+                _or: [conditionalFilter, conditionalFilter2],
+            },
+        });
+    });
+    test('processes _or validations', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('or', { ...permissionTemplate, validation: conditionalFilter }, { ...permissionTemplate, validation: conditionalFilter2 });
+        expect(mergedPermission).toStrictEqual({
+            ...permissionTemplate,
+            validation: {
+                _or: [conditionalFilter, conditionalFilter2],
+            },
+        });
+    });
+    test('processes _and permissions', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('and', { ...permissionTemplate, permissions: conditionalFilter }, { ...permissionTemplate, permissions: conditionalFilter2 });
+        expect(mergedPermission).toStrictEqual({
+            ...permissionTemplate,
+            permissions: {
+                _and: [conditionalFilter, conditionalFilter2],
+            },
+        });
+    });
+    test('processes _and validations', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('and', { ...permissionTemplate, validation: conditionalFilter }, { ...permissionTemplate, validation: conditionalFilter2 });
+        expect(mergedPermission).toStrictEqual({
+            ...permissionTemplate,
+            validation: {
+                _and: [conditionalFilter, conditionalFilter2],
+            },
+        });
+    });
+    test('{} supersedes conditional permissions in _or', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('or', { ...permissionTemplate, permissions: fullFilter }, { ...permissionTemplate, permissions: conditionalFilter });
+        expect(mergedPermission).toStrictEqual({ ...permissionTemplate, permissions: fullFilter });
+    });
+    test('{} supersedes conditional validations in _or', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('or', { ...permissionTemplate, validation: fullFilter }, { ...permissionTemplate, validation: conditionalFilter });
+        expect(mergedPermission).toStrictEqual({ ...permissionTemplate, validation: fullFilter });
+    });
+    test('{} does not supersede conditional permissions in _and', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('and', { ...permissionTemplate, permissions: fullFilter }, { ...permissionTemplate, permissions: conditionalFilter });
+        const expectedPermission = {
+            ...permissionTemplate,
+            permissions: {
+                _and: [fullFilter, conditionalFilter],
+            },
+        };
+        expect(mergedPermission).toStrictEqual(expectedPermission);
+    });
+    test('{} does not supersede conditional validations in _and', () => {
+        const mergedPermission = (0, merge_permissions_1.mergePermission)('and', { ...permissionTemplate, validation: fullFilter }, { ...permissionTemplate, validation: conditionalFilter });
+        const expectedPermission = {
+            ...permissionTemplate,
+            validation: {
+                _and: [fullFilter, conditionalFilter],
+            },
+        };
+        expect(mergedPermission).toStrictEqual(expectedPermission);
+    });
+});

package/dist/utils/validate-keys.test.d.ts

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

package/dist/utils/validate-keys.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validate_keys_1 = require("../../src/utils/validate-keys");
+const uuid_1 = require("uuid");
+const schema = {
+    collections: {
+        pk_integer: {
+            collection: 'pk_integer',
+            primary: 'id',
+            singleton: false,
+            note: 'Sample schema with integer primary key',
+            sortField: null,
+            accountability: null,
+            fields: {
+                id: {
+                    field: 'id',
+                    defaultValue: null,
+                    nullable: false,
+                    generated: false,
+                    type: 'integer',
+                    dbType: 'integer',
+                    precision: null,
+                    scale: null,
+                    special: [],
+                    note: null,
+                    alias: false,
+                    validation: null,
+                },
+            },
+        },
+        pk_uuid: {
+            collection: 'pk_uuid',
+            primary: 'id',
+            singleton: false,
+            note: 'Sample schema with uuid primary key',
+            sortField: null,
+            accountability: null,
+            fields: {
+                id: {
+                    field: 'id',
+                    defaultValue: null,
+                    nullable: false,
+                    generated: false,
+                    type: 'uuid',
+                    dbType: 'uuid',
+                    precision: null,
+                    scale: null,
+                    special: [],
+                    note: null,
+                    alias: false,
+                    validation: null,
+                },
+            },
+        },
+    },
+    relations: [],
+};
+describe('validate keys', () => {
+    describe('of integer type', () => {
+        it('Throws an error when provided with an invalid integer key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', 'invalid')).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', NaN)).toThrowError();
+        });
+        it('Throws an error when provided with an array containing an invalid integer key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', [111, 'invalid', 222])).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', [555, NaN, 666])).toThrowError();
+        });
+        it('Does not throw an error when provided with a valid integer key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', 111)).not.toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', '222')).not.toThrowError();
+        });
+        it('Does not throw an error when provided with an array of valid integer keys', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', [111, 222, 333])).not.toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_integer', 'id', ['444', '555', '666'])).not.toThrowError();
+        });
+    });
+    describe('of uuid type', () => {
+        it('Throws an error when provided with an invalid uuid key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', 'fakeuuid-62d9-434d-a7c7-878c8376782e')).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', 'invalid')).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', NaN)).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', 111)).toThrowError();
+        });
+        it('Throws an error when provided with an array containing an invalid uuid key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', [(0, uuid_1.v4)(), 'fakeuuid-62d9-434d-a7c7-878c8376782e', (0, uuid_1.v4)()])).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', [(0, uuid_1.v4)(), 'invalid', (0, uuid_1.v4)()])).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', [(0, uuid_1.v4)(), NaN, (0, uuid_1.v4)()])).toThrowError();
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', [(0, uuid_1.v4)(), 111, (0, uuid_1.v4)()])).toThrowError();
+        });
+        it('Does not throw an error when provided with a valid uuid key', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', (0, uuid_1.v4)())).not.toThrowError();
+        });
+        it('Does not throw an error when provided with an array of valid uuid keys', () => {
+            expect(() => (0, validate_keys_1.validateKeys)(schema, 'pk_uuid', 'id', [(0, uuid_1.v4)(), (0, uuid_1.v4)(), (0, uuid_1.v4)()])).not.toThrowError();
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directus",
-  "version": "9.15.1",
+  "version": "9.16.0",
   "license": "GPL-3.0-only",
   "homepage": "https://github.com/directus/directus#readme",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content.",
@@ -66,16 +66,16 @@
   ],
   "dependencies": {
     "@aws-sdk/client-ses": "^3.107.0",
-    "@directus/app": "9.15.1",
+    "@directus/app": "9.16.0",
     "@directus/drive": "9.15.1",
-    "@directus/drive-azure": "9.15.1",
-    "@directus/drive-gcs": "9.15.1",
-    "@directus/drive-s3": "9.15.1",
+    "@directus/drive-azure": "9.16.0",
+    "@directus/drive-gcs": "9.16.0",
+    "@directus/drive-s3": "9.16.0",
     "@directus/extensions-sdk": "^9.14.1",
     "@directus/format-title": "^9.15.0",
-    "@directus/schema": "9.15.1",
-    "@directus/shared": "9.15.1",
-    "@directus/specs": "9.15.1",
+    "@directus/schema": "9.16.0",
+    "@directus/shared": "9.16.0",
+    "@directus/specs": "9.16.0",
     "@godaddy/terminus": "^4.10.2",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-virtual": "^2.1.0",
@@ -117,11 +117,10 @@
     "jsonwebtoken": "^8.5.1",
     "keyv": "^4.3.0",
     "knex": "2.2.0",
-    "knex-schema-inspector": "^2.0.3",
+    "knex-schema-inspector": "2.0.4",
     "ldapjs": "^2.3.3",
     "liquidjs": "^9.37.0",
     "lodash": "^4.17.21",
-    "macos-release": "^2.4.1",
     "marked": "^4.0.16",
     "micromustache": "^8.0.3",
     "mime-types": "^2.1.35",
@@ -152,6 +151,7 @@
     "update-check": "^1.5.4",
     "uuid": "^8.3.2",
     "uuid-validate": "0.0.3",
+    "vm2": "^3.9.10",
     "wellknown": "^0.5.0"
   },
   "optionalDependencies": {