directus 9.1.2 → 9.2.0

package/dist/database/helpers/geometry/dialects/sqlite.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelperSQLite = void 0;
+const types_1 = require("../types");
+class GeometryHelperSQLite extends types_1.GeometryHelper {
+    async supported() {
+        const res = await this.knex.select('name').from('pragma_function_list').where({ name: 'spatialite_version' });
+        return res.length > 0;
+    }
+    asGeoJSON(table, column) {
+        return this.knex.raw('asgeojson(??.??) as ??', [table, column, column]);
+    }
+}
+exports.GeometryHelperSQLite = GeometryHelperSQLite;

package/dist/database/helpers/geometry/index.d.ts

@@ -0,0 +1,6 @@
+export { GeometryHelperPostgres as postgres } from './dialects/postgres';
+export { GeometryHelperRedshift as redshift } from './dialects/redshift';
+export { GeometryHelperOracle as oracle } from './dialects/oracle';
+export { GeometryHelperSQLite as sqlite } from './dialects/sqlite';
+export { GeometryHelperMySQL as mysql } from './dialects/mysql';
+export { GeometryHelperMSSQL as mssql } from './dialects/mssql';

package/dist/database/helpers/geometry/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mssql = exports.mysql = exports.sqlite = exports.oracle = exports.redshift = exports.postgres = void 0;
+var postgres_1 = require("./dialects/postgres");
+Object.defineProperty(exports, "postgres", { enumerable: true, get: function () { return postgres_1.GeometryHelperPostgres; } });
+var redshift_1 = require("./dialects/redshift");
+Object.defineProperty(exports, "redshift", { enumerable: true, get: function () { return redshift_1.GeometryHelperRedshift; } });
+var oracle_1 = require("./dialects/oracle");
+Object.defineProperty(exports, "oracle", { enumerable: true, get: function () { return oracle_1.GeometryHelperOracle; } });
+var sqlite_1 = require("./dialects/sqlite");
+Object.defineProperty(exports, "sqlite", { enumerable: true, get: function () { return sqlite_1.GeometryHelperSQLite; } });
+var mysql_1 = require("./dialects/mysql");
+Object.defineProperty(exports, "mysql", { enumerable: true, get: function () { return mysql_1.GeometryHelperMySQL; } });
+var mssql_1 = require("./dialects/mssql");
+Object.defineProperty(exports, "mssql", { enumerable: true, get: function () { return mssql_1.GeometryHelperMSSQL; } });

package/dist/database/helpers/{geometry.d.ts → geometry/types.d.ts}

@@ -1,16 +1,13 @@
+import { GeoJSONGeometry } from 'wellknown';
 import { Field, RawField } from '@directus/shared/types';
+import { DatabaseHelper } from '../types';
 import { Knex } from 'knex';
-import { GeoJSONGeometry } from 'wellknown';
-export declare function getGeometryHelper(database?: Knex): KnexSpatial;
-declare abstract class KnexSpatial {
-    protected knex: Knex;
-    constructor(knex: Knex);
+export declare abstract class GeometryHelper extends DatabaseHelper {
     supported(): boolean | Promise<boolean>;
     isTrue(expression: Knex.Raw): Knex.Raw<any>;
     isFalse(expression: Knex.Raw): Knex.Raw<any>;
     createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
     asText(table: string, column: string): Knex.Raw;
-    asGeoJSON?(table: string, column: string): Knex.Raw;
     fromText(text: string): Knex.Raw;
     fromGeoJSON(geojson: GeoJSONGeometry): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
@@ -21,4 +18,3 @@ declare abstract class KnexSpatial {
     nintersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;
     collect(table: string, column: string): Knex.Raw;
 }
-export {};

package/dist/database/helpers/geometry/types.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryHelper = void 0;
+const wellknown_1 = require("wellknown");
+const types_1 = require("../types");
+class GeometryHelper extends types_1.DatabaseHelper {
+    supported() {
+        return true;
+    }
+    isTrue(expression) {
+        return expression;
+    }
+    isFalse(expression) {
+        return expression.wrap('NOT ', '');
+    }
+    createColumn(table, field) {
+        var _a;
+        const type = (_a = field.type.split('.')[1]) !== null && _a !== void 0 ? _a : 'geometry';
+        return table.specificType(field.field, type);
+    }
+    asText(table, column) {
+        return this.knex.raw('st_astext(??.??) as ??', [table, column, column]);
+    }
+    fromText(text) {
+        return this.knex.raw('st_geomfromtext(?, 4326)', text);
+    }
+    fromGeoJSON(geojson) {
+        return this.fromText((0, wellknown_1.stringify)(geojson));
+    }
+    _intersects(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('st_intersects(??, ?)', [key, geometry]);
+    }
+    intersects(key, geojson) {
+        return this.isTrue(this._intersects(key, geojson));
+    }
+    nintersects(key, geojson) {
+        return this.isFalse(this._intersects(key, geojson));
+    }
+    _intersects_bbox(key, geojson) {
+        const geometry = this.fromGeoJSON(geojson);
+        return this.knex.raw('st_intersects(??, ?)', [key, geometry]);
+    }
+    intersects_bbox(key, geojson) {
+        return this.isTrue(this._intersects_bbox(key, geojson));
+    }
+    nintersects_bbox(key, geojson) {
+        return this.isFalse(this._intersects_bbox(key, geojson));
+    }
+    collect(table, column) {
+        return this.knex.raw('st_astext(st_collect(??.??))', [table, column]);
+    }
+}
+exports.GeometryHelper = GeometryHelper;

package/dist/database/helpers/index.d.ts

@@ -0,0 +1,8 @@
+import { Knex } from 'knex';
+import * as dateHelpers from './date';
+import * as geometryHelpers from './geometry';
+export declare function getHelpers(database: Knex): {
+    date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.sqlite | dateHelpers.mysql | dateHelpers.mssql;
+    st: geometryHelpers.postgres | geometryHelpers.redshift | geometryHelpers.oracle | geometryHelpers.sqlite | geometryHelpers.mysql | geometryHelpers.mssql;
+};
+export declare type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHelpers = void 0;
+const __1 = require("..");
+const dateHelpers = __importStar(require("./date"));
+const geometryHelpers = __importStar(require("./geometry"));
+function getHelpers(database) {
+    const client = (0, __1.getDatabaseClient)(database);
+    return {
+        date: new dateHelpers[client](database),
+        st: new geometryHelpers[client](database),
+    };
+}
+exports.getHelpers = getHelpers;

package/dist/database/helpers/types.d.ts

@@ -0,0 +1,5 @@
+import { Knex } from 'knex';
+export declare abstract class DatabaseHelper {
+    protected knex: Knex;
+    constructor(knex: Knex);
+}

package/dist/database/helpers/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelper = void 0;
+class DatabaseHelper {
+    constructor(knex) {
+        this.knex = knex;
+    }
+}
+exports.DatabaseHelper = DatabaseHelper;

package/dist/database/index.js

@@ -15,7 +15,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const lodash_1 = require("lodash");
 const util_1 = require("util");
-const geometry_1 = require("./helpers/geometry");
+const helpers_1 = require("./helpers");
 let database = null;
 let inspector = null;
 function getDatabase() {
@@ -197,11 +197,11 @@ exports.validateMigrations = validateMigrations;
  */
 async function validateDatabaseExtensions() {
     const database = getDatabase();
-    const databaseClient = getDatabaseClient(database);
-    const geometryHelper = (0, geometry_1.getGeometryHelper)(database);
-    const geometrySupport = await geometryHelper.supported();
+    const client = getDatabaseClient(database);
+    const helpers = (0, helpers_1.getHelpers)(database);
+    const geometrySupport = await helpers.st.supported();
     if (!geometrySupport) {
-        switch (databaseClient) {
+        switch (client) {
             case 'postgres':
                 logger_1.default.warn(`PostGIS isn't installed. Geometry type support will be limited.`);
                 break;
@@ -209,7 +209,7 @@ async function validateDatabaseExtensions() {
                 logger_1.default.warn(`Spatialite isn't installed. Geometry type support will be limited.`);
                 break;
             default:
-                logger_1.default.warn(`Geometry type not supported on ${databaseClient}`);
+                logger_1.default.warn(`Geometry type not supported on ${client}`);
         }
     }
 }

package/dist/database/run-ast.js

@@ -10,14 +10,14 @@ const apply_query_1 = __importDefault(require("../utils/apply-query"));
 const get_column_1 = require("../utils/get-column");
 const strip_function_1 = require("../utils/strip-function");
 const utils_1 = require("@directus/shared/utils");
-const index_1 = __importDefault(require("./index"));
-const geometry_1 = require("../database/helpers/geometry");
+const _1 = __importDefault(require("."));
+const helpers_1 = require("../database/helpers");
 /**
  * Execute a given AST using Knex. Returns array of items based on requested AST.
  */
 async function runAST(originalAST, schema, options) {
     const ast = (0, lodash_1.cloneDeep)(originalAST);
-    const knex = (options === null || options === void 0 ? void 0 : options.knex) || (0, index_1.default)();
+    const knex = (options === null || options === void 0 ? void 0 : options.knex) || (0, _1.default)();
     if (ast.type === 'm2a') {
         const results = {};
         for (const collection of ast.names) {
@@ -111,7 +111,7 @@ async function parseCurrentLevel(schema, collection, children, query) {
     return { fieldNodes, nestedCollectionNodes, primaryKeyField };
 }
 function getColumnPreprocessor(knex, schema, table) {
-    const helper = (0, geometry_1.getGeometryHelper)();
+    const helpers = (0, helpers_1.getHelpers)(knex);
     return function (fieldNode) {
         let field;
         if (fieldNode.type === 'field') {
@@ -125,7 +125,7 @@ function getColumnPreprocessor(knex, schema, table) {
             alias = fieldNode.fieldKey;
         }
         if (field.type.startsWith('geometry')) {
-            return helper.asText(table, field.field);
+            return helpers.st.asText(table, field.field);
         }
         return (0, get_column_1.getColumn)(knex, table, fieldNode.name, alias);
     };

package/dist/database/seeds/run.js

@@ -7,8 +7,9 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const lodash_1 = require("lodash");
 const path_1 = __importDefault(require("path"));
-const geometry_1 = require("../helpers/geometry");
+const helpers_1 = require("../helpers");
 async function runSeed(database) {
+    const helpers = (0, helpers_1.getHelpers)(database);
     const exists = await database.schema.hasTable('directus_collections');
     if (exists) {
         throw new Error('Database is already installed');
@@ -38,8 +39,7 @@ async function runSeed(database) {
                     column = tableBuilder.string(columnName, 255);
                 }
                 else if ((_a = columnInfo.type) === null || _a === void 0 ? void 0 : _a.startsWith('geometry')) {
-                    const helper = (0, geometry_1.getGeometryHelper)();
-                    column = helper.createColumn(tableBuilder, { field: columnName, type: columnInfo.type });
+                    column = helpers.st.createColumn(tableBuilder, { field: columnName, type: columnInfo.type });
                 }
                 else {
                     // @ts-ignore

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

@@ -4,6 +4,7 @@ fields:
   - field: id
   - field: timestamp
     special: date-created
+  - field: status
   - field: recipient
   - field: sender
   - field: subject

package/dist/env.js

@@ -50,6 +50,7 @@ const defaults = {
     CACHE_SCHEMA: true,
     CACHE_PERMISSIONS: true,
     AUTH_PROVIDERS: '',
+    AUTH_DISABLE_DEFAULT: false,
     EXTENSIONS_PATH: './extensions',
     EMAIL_FROM: 'no-reply@directus.io',
     EMAIL_TRANSPORT: 'sendmail',

package/dist/extensions.js

@@ -31,6 +31,7 @@ const database_1 = __importDefault(require("./database"));
 const emitter_1 = __importDefault(require("./emitter"));
 const env_1 = __importDefault(require("./env"));
 const exceptions = __importStar(require("./exceptions"));
+const sharedExceptions = __importStar(require("@directus/shared/exceptions"));
 const logger_1 = __importDefault(require("./logger"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const get_schema_1 = require("./utils/get-schema");
@@ -231,7 +232,14 @@ class ExtensionManager {
                 }
             },
         };
-        register(registerFunctions, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(registerFunctions, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
     }
     registerEndpoint(endpoint, router) {
         const endpointPath = path_1.default.resolve(endpoint.path, endpoint.entrypoint || '');
@@ -241,7 +249,14 @@ class ExtensionManager {
         const routeName = typeof mod === 'function' ? endpoint.name : mod.id;
         const scopedRouter = express_1.default.Router();
         router.use(`/${routeName}`, scopedRouter);
-        register(scopedRouter, { services, exceptions, env: env_1.default, database: (0, database_1.default)(), logger: logger_1.default, getSchema: get_schema_1.getSchema });
+        register(scopedRouter, {
+            services,
+            exceptions: { ...exceptions, ...sharedExceptions },
+            env: env_1.default,
+            database: (0, database_1.default)(),
+            logger: logger_1.default,
+            getSchema: get_schema_1.getSchema,
+        });
         this.apiEndpoints.push({
             path: endpointPath,
         });

package/dist/middleware/sanitize-query.js

@@ -6,7 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sanitize_query_1 = require("../utils/sanitize-query");
 const validate_query_1 = require("../utils/validate-query");
-const sanitizeQueryMiddleware = (req, res, next) => {
+const sanitizeQueryMiddleware = (req, _res, next) => {
     req.sanitizedQuery = {};
     if (!req.query)
         return;

package/dist/services/activity.js

@@ -15,6 +15,7 @@ const logger_1 = __importDefault(require("../logger"));
 const user_name_1 = require("../utils/user-name");
 const lodash_1 = require("lodash");
 const env_1 = __importDefault(require("../env"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 class ActivityService extends index_1.ItemsService {
     constructor(options) {
         super('directus_activity', options);
@@ -55,9 +56,13 @@ class ActivityService extends index_1.ItemsService {
                     }, {});
                     let comment = data.comment;
                     for (const mention of mentions) {
-                        comment = comment.replace(mention, (_h = userPreviews[mention.substring(1)]) !== null && _h !== void 0 ? _h : '@Unknown User');
+                        const uuid = mention.substring(1);
+                        // We only match on UUIDs in the first place. This is just an extra sanity check
+                        if ((0, uuid_validate_1.default)(uuid) === false)
+                            continue;
+                        comment = comment.replace(new RegExp(mention, 'gm'), (_h = userPreviews[uuid]) !== null && _h !== void 0 ? _h : '@Unknown User');
                     }
-                    comment = `> ${comment}`;
+                    comment = `> ${comment.replace(/\n+/gm, '\n> ')}`;
                     const message = `
 Hello ${(0, user_name_1.userName)(user)},
 

package/dist/services/assets.js

@@ -34,6 +34,7 @@ const exceptions_1 = require("../exceptions");
 const storage_1 = __importDefault(require("../storage"));
 const authorization_1 = require("./authorization");
 const TransformationUtils = __importStar(require("../utils/transformations"));
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
 sharp_1.default.concurrency(1);
 // Note: don't put this in the service. The service can be initialized in multiple places, but they
 // should all share the same semaphore instance.
@@ -54,7 +55,20 @@ class AssetsService {
         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
+         * validity of the uuid ahead of time.
+         */
+        const isValidUUID = (0, uuid_validate_1.default)(id, 4);
+        if (isValidUUID === false)
+            throw new exceptions_1.ForbiddenException();
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
+        if (!file)
+            throw new exceptions_1.ForbiddenException();
+        const { exists } = await storage_1.default.disk(file.storage).exists(file.filename_disk);
+        if (!exists)
+            throw new exceptions_1.ForbiddenException();
         if (range) {
             if (range.start >= file.filesize || (range.end && range.end >= file.filesize)) {
                 throw new exceptions_1.RangeNotSatisfiableException(range);

package/dist/services/fields.d.ts

@@ -6,9 +6,11 @@ import { PayloadService } from '../services/payload';
 import { AbstractServiceOptions, SchemaOverview } from '../types';
 import { Accountability } from '@directus/shared/types';
 import { Field, RawField, Type } from '@directus/shared/types';
+import { Helpers } from '../database/helpers';
 import Keyv from 'keyv';
 export declare class FieldsService {
     knex: Knex;
+    helpers: Helpers;
     accountability: Accountability | null;
     itemsService: ItemsService;
     payloadService: PayloadService;

package/dist/services/fields.js

@@ -39,10 +39,11 @@ const get_local_type_1 = __importDefault(require("../utils/get-local-type"));
 const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const relations_1 = require("./relations");
-const geometry_1 = require("../database/helpers/geometry");
+const helpers_1 = require("../database/helpers");
 class FieldsService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
+        this.helpers = (0, helpers_1.getHelpers)(this.knex);
         this.schemaInspector = options.knex ? (0, schema_1.default)(options.knex) : (0, database_1.getSchemaInspector)();
         this.accountability = options.accountability || null;
         this.itemsService = new items_1.ItemsService('directus_fields', options);
@@ -211,23 +212,39 @@ class FieldsService {
                 accountability: this.accountability,
                 schema: this.schema,
             });
-            if (field.type && constants_1.ALIAS_TYPES.includes(field.type) === false) {
+            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+                collection: collection,
+            }, {
+                database: trx,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+            if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
                 if (table) {
-                    this.addColumnToTable(table, field);
+                    this.addColumnToTable(table, hookAdjustedField);
                 }
                 else {
                     await trx.schema.alterTable(collection, (table) => {
-                        this.addColumnToTable(table, field);
+                        this.addColumnToTable(table, hookAdjustedField);
                     });
                 }
             }
-            if (field.meta) {
+            if (hookAdjustedField.meta) {
                 await itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
+            emitter_1.default.emitAction(`fields.create`, {
+                payload: hookAdjustedField,
+                key: hookAdjustedField.field,
+                collection: collection,
+            }, {
+                database: (0, database_1.default)(),
+                schema: this.schema,
+                accountability: this.accountability,
+            });
         });
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
@@ -238,12 +255,23 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        if (field.schema) {
-            const existingColumn = await this.schemaInspector.columnInfo(collection, field.field);
-            if (!(0, lodash_1.isEqual)(existingColumn, field.schema)) {
+        const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
+            keys: [field.field],
+            collection: collection,
+        }, {
+            database: this.knex,
+            schema: this.schema,
+            accountability: this.accountability,
+        });
+        const record = field.meta
+            ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
+            : null;
+        if (hookAdjustedField.schema) {
+            const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+            if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
                 try {
                     await this.knex.schema.alterTable(collection, (table) => {
-                        if (!field.schema)
+                        if (!hookAdjustedField.schema)
                             return;
                         this.addColumnToTable(table, field, existingColumn);
                     });
@@ -253,31 +281,35 @@ class FieldsService {
                 }
             }
         }
-        if (field.meta) {
-            const record = await this.knex
-                .select('id')
-                .from('directus_fields')
-                .where({ collection, field: field.field })
-                .first();
+        if (hookAdjustedField.meta) {
             if (record) {
                 await this.itemsService.updateOne(record.id, {
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
             else {
                 await this.itemsService.createOne({
-                    ...field.meta,
+                    ...hookAdjustedField.meta,
                     collection: collection,
-                    field: field.field,
-                });
+                    field: hookAdjustedField.field,
+                }, { emitEvents: false });
             }
         }
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
         await this.systemCache.clear();
+        emitter_1.default.emitAction(`fields.update`, {
+            payload: hookAdjustedField,
+            keys: [hookAdjustedField.field],
+            collection: collection,
+        }, {
+            database: (0, database_1.default)(),
+            schema: this.schema,
+            accountability: this.accountability,
+        });
         return field.field;
     }
     async deleteField(collection, field) {
@@ -402,8 +434,7 @@ class FieldsService {
             column = table.timestamp(field.field, { useTz: true });
         }
         else if (field.type.startsWith('geometry')) {
-            const helper = (0, geometry_1.getGeometryHelper)();
-            column = helper.createColumn(table, field);
+            column = this.helpers.st.createColumn(table, field);
         }
         else {
             // @ts-ignore

package/dist/services/files.d.ts

@@ -9,7 +9,7 @@ export declare class FilesService extends ItemsService {
     uploadOne(stream: NodeJS.ReadableStream, data: Partial<File> & {
         filename_download: string;
         storage: string;
-    }, primaryKey?: PrimaryKey): Promise<PrimaryKey>;
+    }, primaryKey?: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
     /**
      * Import a single file from an external URL
      */

package/dist/services/files.js

@@ -26,7 +26,7 @@ class FilesService extends items_1.ItemsService {
     /**
      * Upload a single new file to the configured storage adapter
      */
-    async uploadOne(stream, data, primaryKey) {
+    async uploadOne(stream, data, primaryKey, opts) {
         var _a, _b, _c, _d, _e, _f;
         const payload = (0, lodash_1.clone)(data);
         if ('folder' in payload === false) {
@@ -109,15 +109,17 @@ class FilesService extends items_1.ItemsService {
         if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
             await this.cache.clear();
         }
-        emitter_1.default.emitAction('files.upload', {
-            payload,
-            key: primaryKey,
-            collection: this.collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+        if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
+            emitter_1.default.emitAction('files.upload', {
+                payload,
+                key: primaryKey,
+                collection: this.collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
         return primaryKey;
     }
     /**
@@ -126,7 +128,7 @@ class FilesService extends items_1.ItemsService {
     async importOne(importURL, body) {
         var _a, _b, _c;
         const fileCreatePermissions = (_b = (_a = this.accountability) === null || _a === void 0 ? void 0 : _a.permissions) === null || _b === void 0 ? void 0 : _b.find((permission) => permission.collection === 'directus_files' && permission.action === 'create');
-        if (((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
+        if (this.accountability && ((_c = this.accountability) === null || _c === void 0 ? void 0 : _c.admin) !== true && !fileCreatePermissions) {
             throw new exceptions_1.ForbiddenException();
         }
         let fileResponse;

package/dist/services/graphql.js

@@ -726,6 +726,9 @@ class GraphQLService {
                     args: {
                         groupBy: new graphql_1.GraphQLList(graphql_1.GraphQLString),
                         filter: ReadableCollectionFilterTypes[collection.collection],
+                        limit: {
+                            type: graphql_1.GraphQLInt,
+                        },
                         search: {
                             type: graphql_1.GraphQLString,
                         },