directus 9.4.2 → 9.5.2

package/dist/database/system-data/fields/collections.yaml

@@ -156,6 +156,8 @@ fields:
         - decimal
         - integer
       allowNone: true
+      allowPrimaryKey: false
+      allowForeignKeys: false
     width: half
 
   - field: accountability_divider

package/dist/database/system-data/relations/index.d.ts

@@ -1,2 +1,2 @@
-import { RelationMeta } from '../../../types';
+import { RelationMeta } from '@directus/shared/types';
 export declare const systemRelationRows: RelationMeta[];

package/dist/emitter.d.ts

@@ -1,11 +1,11 @@
-import { ActionHandler, FilterHandler, HookContext, InitHandler } from './types';
+import { ActionHandler, EventContext, FilterHandler, InitHandler } from '@directus/shared/types';
 export declare class Emitter {
     private filterEmitter;
     private actionEmitter;
     private initEmitter;
     constructor();
-    emitFilter<T>(event: string, payload: T, meta: Record<string, any>, context: HookContext): Promise<T>;
-    emitAction(event: string, meta: Record<string, any>, context: HookContext): void;
+    emitFilter<T>(event: string | string[], payload: T, meta: Record<string, any>, context: EventContext): Promise<T>;
+    emitAction(event: string | string[], meta: Record<string, any>, context: EventContext): void;
     emitInit(event: string, meta: Record<string, any>): Promise<void>;
     onFilter(event: string, handler: FilterHandler): void;
     onAction(event: string, handler: ActionHandler): void;
@@ -14,7 +14,6 @@ export declare class Emitter {
     offAction(event: string, handler: ActionHandler): void;
     offInit(event: string, handler: InitHandler): void;
     offAll(): void;
-    private eventsToEmit;
 }
 declare const emitter: Emitter;
 export default emitter;

package/dist/emitter.js

@@ -20,7 +20,7 @@ class Emitter {
         this.initEmitter = new eventemitter2_1.EventEmitter2(emitterOptions);
     }
     async emitFilter(event, payload, meta, context) {
-        const events = this.eventsToEmit(event, meta);
+        const events = Array.isArray(event) ? event : [event];
         const listeners = events.flatMap((event) => this.filterEmitter.listeners(event));
         let updatedPayload = payload;
         for (const listener of listeners) {
@@ -32,7 +32,7 @@ class Emitter {
         return updatedPayload;
     }
     emitAction(event, meta, context) {
-        const events = this.eventsToEmit(event, meta);
+        const events = Array.isArray(event) ? event : [event];
         for (const event of events) {
             this.actionEmitter.emitAsync(event, meta, context).catch((err) => {
                 logger_1.default.warn(`An error was thrown while executing action "${event}"`);
@@ -72,12 +72,6 @@ class Emitter {
         this.actionEmitter.removeAllListeners();
         this.initEmitter.removeAllListeners();
     }
-    eventsToEmit(event, meta) {
-        if (event.startsWith('items')) {
-            return [event, `${meta.collection}.${event}`];
-        }
-        return [event];
-    }
 }
 exports.Emitter = Emitter;
 const emitter = new Emitter();

package/dist/env.js

@@ -52,6 +52,7 @@ const defaults = {
     AUTH_PROVIDERS: '',
     AUTH_DISABLE_DEFAULT: false,
     EXTENSIONS_PATH: './extensions',
+    EXTENSIONS_AUTO_RELOAD: false,
     EMAIL_FROM: 'no-reply@directus.io',
     EMAIL_TRANSPORT: 'sendmail',
     EMAIL_SENDMAIL_NEW_LINE: 'unix',

package/dist/exceptions/database/translate.js

@@ -46,6 +46,7 @@ async function translateDatabaseError(error) {
         case 'mysql':
             defaultError = (0, mysql_1.extractError)(error);
             break;
+        case 'cockroachdb':
         case 'postgres':
             defaultError = (0, postgres_1.extractError)(error);
             break;

package/dist/exceptions/index.d.ts

@@ -14,5 +14,6 @@ export * from './range-not-satisfiable';
 export * from './route-not-found';
 export * from './service-unavailable';
 export * from './unprocessable-entity';
+export * from './unsupported-media-type';
 export * from './user-suspended';
 export * from './unexpected-response';

package/dist/exceptions/index.js

@@ -26,5 +26,6 @@ __exportStar(require("./range-not-satisfiable"), exports);
 __exportStar(require("./route-not-found"), exports);
 __exportStar(require("./service-unavailable"), exports);
 __exportStar(require("./unprocessable-entity"), exports);
+__exportStar(require("./unsupported-media-type"), exports);
 __exportStar(require("./user-suspended"), exports);
 __exportStar(require("./unexpected-response"), exports);

package/dist/exceptions/unsupported-media-type.d.ts

@@ -0,0 +1,4 @@
+import { BaseException } from '@directus/shared/exceptions';
+export declare class UnsupportedMediaTypeException extends BaseException {
+    constructor(message: string, extensions?: Record<string, unknown>);
+}

package/dist/exceptions/unsupported-media-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedMediaTypeException = void 0;
+const exceptions_1 = require("@directus/shared/exceptions");
+class UnsupportedMediaTypeException extends exceptions_1.BaseException {
+    constructor(message, extensions) {
+        super(message, 415, 'UNSUPPORTED_MEDIA_TYPE', extensions);
+    }
+}
+exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;

package/dist/extensions.d.ts

@@ -1,23 +1,29 @@
 import { Router } from 'express';
 import { AppExtensionType, ExtensionType } from '@directus/shared/types';
 export declare function getExtensionManager(): ExtensionManager;
+declare type Options = {
+    schedule: boolean;
+    watch: boolean;
+};
 declare class ExtensionManager {
-    private isInitialized;
+    private isLoaded;
+    private options;
     private extensions;
     private appExtensions;
-    private apiHooks;
-    private apiEndpoints;
+    private apiExtensions;
     private apiEmitter;
     private endpointRouter;
-    private isScheduleHookEnabled;
+    private watcher;
     constructor();
-    initialize({ schedule }?: {
-        schedule: boolean;
-    }): Promise<void>;
+    initialize(options?: Partial<Options>): Promise<void>;
     reload(): Promise<void>;
-    listExtensions(type?: ExtensionType): string[];
+    getExtensionsList(type?: ExtensionType): string[];
     getAppExtensions(type: AppExtensionType): string | undefined;
     getEndpointRouter(): Router;
+    private load;
+    private unload;
+    private initializeWatcher;
+    private updateWatchedExtensions;
     private getExtensions;
     private generateExtensionBundles;
     private getSharedDepsMapping;

package/dist/extensions.js

@@ -45,6 +45,8 @@ const plugin_alias_1 = __importDefault(require("@rollup/plugin-alias"));
 const url_1 = require("./utils/url");
 const get_module_default_1 = __importDefault(require("./utils/get-module-default"));
 const lodash_1 = require("lodash");
+const chokidar_1 = __importDefault(require("chokidar"));
+const utils_1 = require("@directus/shared/utils");
 let extensionManager;
 function getExtensionManager() {
     if (extensionManager) {
@@ -54,21 +56,73 @@ function getExtensionManager() {
     return extensionManager;
 }
 exports.getExtensionManager = getExtensionManager;
+const defaultOptions = {
+    schedule: true,
+    watch: env_1.default.EXTENSIONS_AUTO_RELOAD && env_1.default.NODE_ENV !== 'development',
+};
 class ExtensionManager {
     constructor() {
-        this.isInitialized = false;
+        this.isLoaded = false;
         this.extensions = [];
         this.appExtensions = {};
-        this.apiHooks = [];
-        this.apiEndpoints = [];
-        this.isScheduleHookEnabled = true;
+        this.apiExtensions = { hooks: [], endpoints: [] };
+        this.watcher = null;
+        this.options = defaultOptions;
         this.apiEmitter = new emitter_1.Emitter();
         this.endpointRouter = (0, express_1.Router)();
     }
-    async initialize({ schedule } = { schedule: true }) {
-        this.isScheduleHookEnabled = schedule;
-        if (this.isInitialized)
-            return;
+    async initialize(options = {}) {
+        this.options = {
+            ...defaultOptions,
+            ...options,
+        };
+        this.initializeWatcher();
+        if (!this.isLoaded) {
+            await this.load();
+            this.updateWatchedExtensions(this.extensions);
+            const loadedExtensions = this.getExtensionsList();
+            if (loadedExtensions.length > 0) {
+                logger_1.default.info(`Loaded extensions: ${loadedExtensions.join(', ')}`);
+            }
+        }
+    }
+    async reload() {
+        if (this.isLoaded) {
+            logger_1.default.info('Reloading extensions');
+            const prevExtensions = (0, lodash_1.clone)(this.extensions);
+            await this.unload();
+            await this.load();
+            const added = this.extensions.filter((extension) => !prevExtensions.some((prevExtension) => extension.path === prevExtension.path));
+            const removed = prevExtensions.filter((prevExtension) => !this.extensions.some((extension) => prevExtension.path === extension.path));
+            this.updateWatchedExtensions(added, removed);
+            const addedExtensions = added.map((extension) => extension.name);
+            const removedExtensions = removed.map((extension) => extension.name);
+            if (addedExtensions.length > 0) {
+                logger_1.default.info(`Added extensions: ${addedExtensions.join(', ')}`);
+            }
+            if (removedExtensions.length > 0) {
+                logger_1.default.info(`Removed extensions: ${removedExtensions.join(', ')}`);
+            }
+        }
+        else {
+            logger_1.default.warn('Extensions have to be loaded before they can be reloaded');
+        }
+    }
+    getExtensionsList(type) {
+        if (type === undefined) {
+            return this.extensions.map((extension) => extension.name);
+        }
+        else {
+            return this.extensions.filter((extension) => extension.type === type).map((extension) => extension.name);
+        }
+    }
+    getAppExtensions(type) {
+        return this.appExtensions[type];
+    }
+    getEndpointRouter() {
+        return this.endpointRouter;
+    }
+    async load() {
         try {
             await (0, node_1.ensureExtensionDirs)(env_1.default.EXTENSIONS_PATH, env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES);
             this.extensions = await this.getExtensions();
@@ -82,38 +136,42 @@ class ExtensionManager {
         if (env_1.default.SERVE_APP) {
             this.appExtensions = await this.generateExtensionBundles();
         }
-        const loadedExtensions = this.listExtensions();
-        if (loadedExtensions.length > 0) {
-            logger_1.default.info(`Loaded extensions: ${loadedExtensions.join(', ')}`);
-        }
-        this.isInitialized = true;
+        this.isLoaded = true;
     }
-    async reload() {
-        if (!this.isInitialized)
-            return;
-        logger_1.default.info('Reloading extensions');
+    async unload() {
         this.unregisterHooks();
         this.unregisterEndpoints();
         this.apiEmitter.offAll();
         if (env_1.default.SERVE_APP) {
             this.appExtensions = {};
         }
-        this.isInitialized = false;
-        await this.initialize();
+        this.isLoaded = false;
     }
-    listExtensions(type) {
-        if (type === undefined) {
-            return this.extensions.map((extension) => extension.name);
-        }
-        else {
-            return this.extensions.filter((extension) => extension.type === type).map((extension) => extension.name);
+    initializeWatcher() {
+        if (this.options.watch && !this.watcher) {
+            logger_1.default.info('Watching extensions for changes...');
+            const localExtensionPaths = (env_1.default.SERVE_APP ? constants_1.EXTENSION_TYPES : constants_1.API_EXTENSION_TYPES).map((type) => path_1.default.posix.join(path_1.default.relative('.', env_1.default.EXTENSIONS_PATH).split(path_1.default.sep).join(path_1.default.posix.sep), (0, utils_1.pluralize)(type), '*', 'index.js'));
+            this.watcher = chokidar_1.default.watch([path_1.default.resolve('.', 'package.json'), ...localExtensionPaths], {
+                ignoreInitial: true,
+            });
+            this.watcher
+                .on('add', () => this.reload())
+                .on('change', () => this.reload())
+                .on('unlink', () => this.reload());
         }
     }
-    getAppExtensions(type) {
-        return this.appExtensions[type];
-    }
-    getEndpointRouter() {
-        return this.endpointRouter;
+    updateWatchedExtensions(added, removed = []) {
+        if (this.watcher) {
+            const toPackageExtensionPaths = (extensions) => extensions
+                .filter((extension) => !extension.local)
+                .map((extension) => extension.type !== 'pack'
+                ? path_1.default.resolve(extension.path, extension.entrypoint || '')
+                : path_1.default.resolve(extension.path, 'package.json'));
+            const addedPackageExtensionPaths = toPackageExtensionPaths(added);
+            const removedPackageExtensionPaths = toPackageExtensionPaths(removed);
+            this.watcher.add(addedPackageExtensionPaths);
+            this.watcher.unwatch(removedPackageExtensionPaths);
+        }
     }
     async getExtensions() {
         const packageExtensions = await (0, node_1.getPackageExtensions)('.', env_1.default.SERVE_APP ? constants_1.EXTENSION_PACKAGE_TYPES : constants_1.API_EXTENSION_PACKAGE_TYPES);
@@ -129,15 +187,21 @@ class ExtensionManager {
         const bundles = {};
         for (const extensionType of constants_1.APP_EXTENSION_TYPES) {
             const entry = (0, node_1.generateExtensionsEntry)(extensionType, this.extensions);
-            const bundle = await (0, rollup_1.rollup)({
-                input: 'entry',
-                external: Object.values(sharedDepsMapping),
-                makeAbsoluteExternalsRelative: false,
-                plugins: [(0, plugin_virtual_1.default)({ entry }), (0, plugin_alias_1.default)({ entries: internalImports })],
-            });
-            const { output } = await bundle.generate({ format: 'es', compact: true });
-            bundles[extensionType] = output[0].code;
-            await bundle.close();
+            try {
+                const bundle = await (0, rollup_1.rollup)({
+                    input: 'entry',
+                    external: Object.values(sharedDepsMapping),
+                    makeAbsoluteExternalsRelative: false,
+                    plugins: [(0, plugin_virtual_1.default)({ entry }), (0, plugin_alias_1.default)({ entries: internalImports })],
+                });
+                const { output } = await bundle.generate({ format: 'es', compact: true });
+                bundles[extensionType] = output[0].code;
+                await bundle.close();
+            }
+            catch (error) {
+                logger_1.default.warn(`Couldn't bundle App extensions`);
+                logger_1.default.warn(error);
+            }
         }
         return bundles;
     }
@@ -185,38 +249,39 @@ class ExtensionManager {
         const hookPath = path_1.default.resolve(hook.path, hook.entrypoint || '');
         const hookInstance = require(hookPath);
         const register = (0, get_module_default_1.default)(hookInstance);
+        const hookHandler = {
+            path: hookPath,
+            events: [],
+        };
         const registerFunctions = {
             filter: (event, handler) => {
                 emitter_1.default.onFilter(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'filter',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             action: (event, handler) => {
                 emitter_1.default.onAction(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'action',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             init: (event, handler) => {
                 emitter_1.default.onInit(event, handler);
-                this.apiHooks.push({
+                hookHandler.events.push({
                     type: 'init',
-                    path: hookPath,
-                    event,
+                    name: event,
                     handler,
                 });
             },
             schedule: (cron, handler) => {
                 if ((0, node_cron_1.validate)(cron)) {
                     const task = (0, node_cron_1.schedule)(cron, async () => {
-                        if (this.isScheduleHookEnabled) {
+                        if (this.options.schedule) {
                             try {
                                 await handler();
                             }
@@ -225,9 +290,8 @@ class ExtensionManager {
                             }
                         }
                     });
-                    this.apiHooks.push({
+                    hookHandler.events.push({
                         type: 'schedule',
-                        path: hookPath,
                         task,
                     });
                 }
@@ -245,6 +309,7 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
+        this.apiExtensions.hooks.push(hookHandler);
     }
     registerEndpoint(endpoint, router) {
         const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
@@ -263,35 +328,37 @@ class ExtensionManager {
             logger: logger_1.default,
             getSchema: get_schema_1.getSchema,
         });
-        this.apiEndpoints.push({
+        this.apiExtensions.endpoints.push({
             path: endpointPath,
         });
     }
     unregisterHooks() {
-        for (const hook of this.apiHooks) {
-            switch (hook.type) {
-                case 'filter':
-                    emitter_1.default.offFilter(hook.event, hook.handler);
-                    break;
-                case 'action':
-                    emitter_1.default.offAction(hook.event, hook.handler);
-                    break;
-                case 'init':
-                    emitter_1.default.offInit(hook.event, hook.handler);
-                    break;
-                case 'schedule':
-                    hook.task.destroy();
-                    break;
+        for (const hook of this.apiExtensions.hooks) {
+            for (const event of hook.events) {
+                switch (event.type) {
+                    case 'filter':
+                        emitter_1.default.offFilter(event.name, event.handler);
+                        break;
+                    case 'action':
+                        emitter_1.default.offAction(event.name, event.handler);
+                        break;
+                    case 'init':
+                        emitter_1.default.offInit(event.name, event.handler);
+                        break;
+                    case 'schedule':
+                        event.task.stop();
+                        break;
+                }
             }
             delete require.cache[require.resolve(hook.path)];
         }
-        this.apiHooks = [];
+        this.apiExtensions.hooks = [];
     }
     unregisterEndpoints() {
-        for (const endpoint of this.apiEndpoints) {
+        for (const endpoint of this.apiExtensions.endpoints) {
             delete require.cache[require.resolve(endpoint.path)];
         }
         this.endpointRouter.stack = [];
-        this.apiEndpoints = [];
+        this.apiExtensions.endpoints = [];
     }
 }

package/dist/logger.js

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 const pino_http_1 = __importStar(require("pino-http"));
+const get_config_from_env_1 = require("./utils/get-config-from-env");
 const url_1 = require("url");
 const env_1 = __importDefault(require("./env"));
 const pinoOptions = {
@@ -38,9 +39,29 @@ if (env_1.default.LOG_STYLE !== 'raw') {
     pinoOptions.prettyPrint = true;
     pinoOptions.prettifier = require('pino-colada');
 }
-const logger = (0, pino_1.default)(pinoOptions);
+const loggerEnvConfig = (0, get_config_from_env_1.getConfigFromEnv)('LOGGER_', 'LOGGER_HTTP');
+// Expose custom log levels into formatter function
+if (loggerEnvConfig.levels) {
+    const customLogLevels = {};
+    for (const el of loggerEnvConfig.levels.split(',')) {
+        const key_val = el.split(':');
+        customLogLevels[key_val[0].trim()] = key_val[1].trim();
+    }
+    pinoOptions.formatters = {
+        level(label, number) {
+            return {
+                severity: customLogLevels[label] || 'info',
+                level: number,
+            };
+        },
+    };
+    delete loggerEnvConfig.levels;
+}
+const logger = (0, pino_1.default)(Object.assign(pinoOptions, loggerEnvConfig));
+const httpLoggerEnvConfig = (0, get_config_from_env_1.getConfigFromEnv)('LOGGER_HTTP', ['LOGGER_HTTP_LOGGER']);
 exports.expressLogger = (0, pino_http_1.default)({
     logger,
+    ...httpLoggerEnvConfig,
 }, {
     serializers: {
         req(request) {

package/dist/middleware/extract-token.js

@@ -15,7 +15,7 @@ const extractToken = (req, res, next) => {
     }
     if (req.headers && req.headers.authorization) {
         const parts = req.headers.authorization.split(' ');
-        if (parts.length === 2 && parts[0] === 'Bearer') {
+        if (parts.length === 2 && parts[0].toLowerCase() === 'bearer') {
             token = parts[1];
         }
     }

package/dist/services/assets.js

@@ -52,9 +52,6 @@ class AssetsService {
             .from('directus_settings')
             .first();
         const systemPublicKeys = Object.values(publicSettings || {});
-        if (systemPublicKeys.includes(id) === false && ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
-            await this.authorizationService.checkAccess('read', 'directus_files', id);
-        }
         /**
          * This is a little annoying. Postgres will error out if you're trying to search in `where`
          * with a wrong type. In case of directus_files where id is a uuid, we'll have to verify the
@@ -63,6 +60,9 @@ class AssetsService {
         const isValidUUID = (0, uuid_validate_1.default)(id, 4);
         if (isValidUUID === false)
             throw new exceptions_1.ForbiddenException();
+        if (systemPublicKeys.includes(id) === false && ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) !== true) {
+            await this.authorizationService.checkAccess('read', 'directus_files', id);
+        }
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
         if (!file)
             throw new exceptions_1.ForbiddenException();

package/dist/services/authentication.d.ts

@@ -1,7 +1,7 @@
 import { Knex } from 'knex';
 import { ActivityService } from './activity';
-import { AbstractServiceOptions, SchemaOverview, LoginResult } from '../types';
-import { Accountability } from '@directus/shared/types';
+import { AbstractServiceOptions, LoginResult } from '../types';
+import { Accountability, SchemaOverview } from '@directus/shared/types';
 export declare class AuthenticationService {
     knex: Knex;
     accountability: Accountability | null;

package/dist/services/authentication.js

@@ -43,7 +43,7 @@ class AuthenticationService {
         const user = await this.knex
             .select('u.id', 'u.first_name', 'u.last_name', 'u.email', 'u.password', 'u.status', 'u.role', 'r.admin_access', 'r.app_access', 'u.tfa_secret', 'u.provider', 'u.external_identifier', 'u.auth_data')
             .from('directus_users as u')
-            .innerJoin('directus_roles as r', 'u.role', 'r.id')
+            .leftJoin('directus_roles as r', 'u.role', 'r.id')
             .where('u.id', await provider.getUserID((0, lodash_1.cloneDeep)(payload)))
             .andWhere('u.provider', providerName)
             .first();
@@ -204,7 +204,9 @@ class AuthenticationService {
             .from('directus_sessions AS s')
             .leftJoin('directus_users AS u', 's.user', 'u.id')
             .leftJoin('directus_shares AS d', 's.share', 'd.id')
-            .joinRaw('LEFT JOIN directus_roles AS r ON r.id IN (u.role, d.role)')
+            .leftJoin('directus_roles AS r', (join) => {
+            join.onIn('r.id', [this.knex.ref('u.role'), this.knex.ref('d.role')]);
+        })
             .where('s.token', refreshToken)
             .andWhere('s.expires', '>=', new Date())
             .andWhere((subQuery) => {
@@ -247,6 +249,9 @@ class AuthenticationService {
                 collection: record.share_collection,
                 item: record.share_item,
             };
+            tokenPayload.app_access = false;
+            tokenPayload.admin_access = false;
+            delete tokenPayload.id;
         }
         const customClaims = await emitter_1.default.emitFilter('auth.jwt', tokenPayload, {
             status: 'pending',

package/dist/services/authorization.d.ts

@@ -1,7 +1,6 @@
 import { Knex } from 'knex';
-import { Accountability } from '@directus/shared/types';
-import { AbstractServiceOptions, AST, Item, PrimaryKey, SchemaOverview } from '../types';
-import { PermissionsAction } from '@directus/shared/types';
+import { AbstractServiceOptions, AST, Item, PrimaryKey } from '../types';
+import { PermissionsAction, Accountability, SchemaOverview } from '@directus/shared/types';
 import { PayloadService } from './payload';
 export declare class AuthorizationService {
     knex: Knex;

package/dist/services/collections.d.ts

@@ -1,8 +1,8 @@
 import SchemaInspector from '@directus/schema';
 import { Knex } from 'knex';
 import Keyv from 'keyv';
-import { AbstractServiceOptions, Collection, CollectionMeta, SchemaOverview, MutationOptions } from '../types';
-import { Accountability, RawField } from '@directus/shared/types';
+import { AbstractServiceOptions, Collection, CollectionMeta, MutationOptions } from '../types';
+import { Accountability, RawField, SchemaOverview } from '@directus/shared/types';
 import { Table } from 'knex-schema-inspector/dist/types/table';
 export declare type RawCollection = {
     collection: string;