directus 9.10.0 → 9.12.0

package/dist/operations/item-create/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const operation_options_1 = require("../../utils/operation-options");
+const get_accountability_for_role_1 = require("../../utils/get-accountability-for-role");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'item-create',
+    handler: async ({ collection, payload, emitEvents, permissions }, { accountability, database, getSchema }) => {
+        var _a;
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(permissions, { database, schema, accountability });
+        }
+        const itemsService = new services_1.ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const payloadObject = (_a = (0, operation_options_1.optionToObject)(payload)) !== null && _a !== void 0 ? _a : null;
+        let result;
+        if (!payloadObject) {
+            result = null;
+        }
+        else {
+            result = await itemsService.createMany((0, utils_1.toArray)(payloadObject), { emitEvents });
+        }
+        return result;
+    },
+});

package/dist/operations/item-delete/index.d.ts

@@ -0,0 +1,9 @@
+import { PrimaryKey } from '@directus/shared/types';
+declare type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    query?: Record<string, any> | string | null;
+    permissions: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-delete/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const operation_options_1 = require("../../utils/operation-options");
+const get_accountability_for_role_1 = require("../../utils/get-accountability-for-role");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'item-delete',
+    handler: async ({ collection, key, query, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(permissions, { database, schema, accountability });
+        }
+        const itemsService = new services_1.ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const queryObject = query ? (0, operation_options_1.optionToObject)(query) : {};
+        let result;
+        if (!key) {
+            result = await itemsService.deleteByQuery(queryObject);
+        }
+        else {
+            const keys = (0, utils_1.toArray)(key);
+            if (keys.length === 1) {
+                result = await itemsService.deleteOne(keys[0]);
+            }
+            else {
+                result = await itemsService.deleteMany(keys);
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/item-read/index.d.ts

@@ -0,0 +1,9 @@
+import { PrimaryKey } from '@directus/shared/types';
+declare type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    query?: Record<string, any> | string | null;
+    permissions: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-read/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const operation_options_1 = require("../../utils/operation-options");
+const get_accountability_for_role_1 = require("../../utils/get-accountability-for-role");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'item-read',
+    handler: async ({ collection, key, query, permissions }, { accountability, database, getSchema }) => {
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(permissions, { database, schema, accountability });
+        }
+        const itemsService = new services_1.ItemsService(collection, {
+            schema,
+            accountability: customAccountability,
+            knex: database,
+        });
+        const queryObject = query ? (0, operation_options_1.optionToObject)(query) : {};
+        let result;
+        if (!key) {
+            result = await itemsService.readByQuery(queryObject);
+        }
+        else {
+            const keys = (0, utils_1.toArray)(key);
+            if (keys.length === 1) {
+                result = await itemsService.readOne(keys[0], queryObject);
+            }
+            else {
+                result = await itemsService.readMany(keys, queryObject);
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/item-update/index.d.ts

@@ -0,0 +1,10 @@
+import { PrimaryKey } from '@directus/shared/types';
+declare type Options = {
+    collection: string;
+    key?: PrimaryKey | PrimaryKey[] | null;
+    payload?: Record<string, any> | string | null;
+    query?: Record<string, any> | string | null;
+    permissions: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/item-update/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const operation_options_1 = require("../../utils/operation-options");
+const get_accountability_for_role_1 = require("../../utils/get-accountability-for-role");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'item-update',
+    handler: async ({ collection, key, payload, query, permissions }, { accountability, database, getSchema }) => {
+        var _a;
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(permissions, { database, schema, accountability });
+        }
+        const itemsService = new services_1.ItemsService(collection, {
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const payloadObject = (_a = (0, operation_options_1.optionToObject)(payload)) !== null && _a !== void 0 ? _a : null;
+        const queryObject = query ? (0, operation_options_1.optionToObject)(query) : {};
+        if (!payloadObject) {
+            return null;
+        }
+        let result;
+        if (!key) {
+            result = await itemsService.updateByQuery(queryObject, payloadObject);
+        }
+        else {
+            const keys = (0, utils_1.toArray)(key);
+            if (keys.length === 1) {
+                result = await itemsService.updateOne(keys[0], payloadObject);
+            }
+            else {
+                result = await itemsService.updateMany(keys, payloadObject);
+            }
+        }
+        return result;
+    },
+});

package/dist/operations/log/index.d.ts

@@ -0,0 +1,5 @@
+declare type Options = {
+    message: unknown;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/log/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const logger_1 = __importDefault(require("../../logger"));
+const operation_options_1 = require("../../utils/operation-options");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'log',
+    handler: ({ message }) => {
+        logger_1.default.info((0, operation_options_1.optionToString)(message));
+    },
+});

package/dist/operations/mail/index.d.ts

@@ -0,0 +1,7 @@
+declare type Options = {
+    body: string;
+    to: string;
+    subject: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/mail/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const md_1 = require("../../utils/md");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'mail',
+    handler: async ({ body, to, subject }, { accountability, database, getSchema }) => {
+        const mailService = new services_1.MailService({ schema: await getSchema({ database }), accountability, knex: database });
+        await mailService.send({
+            html: (0, md_1.md)(body),
+            to,
+            subject,
+        });
+    },
+});

package/dist/operations/notification/index.d.ts

@@ -0,0 +1,8 @@
+declare type Options = {
+    recipient: string;
+    subject: string;
+    message?: unknown | null;
+    permissions: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/notification/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const services_1 = require("../../services");
+const operation_options_1 = require("../../utils/operation-options");
+const get_accountability_for_role_1 = require("../../utils/get-accountability-for-role");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'notification',
+    handler: async ({ recipient, subject, message, permissions }, { accountability, database, getSchema }) => {
+        var _a;
+        const schema = await getSchema({ database });
+        let customAccountability;
+        if (!permissions || permissions === '$trigger') {
+            customAccountability = accountability;
+        }
+        else if (permissions === '$full') {
+            customAccountability = null;
+        }
+        else if (permissions === '$public') {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(null, { database, schema, accountability });
+        }
+        else {
+            customAccountability = await (0, get_accountability_for_role_1.getAccountabilityForRole)(permissions, { database, schema, accountability });
+        }
+        const notificationsService = new services_1.NotificationsService({
+            schema: await getSchema({ database }),
+            accountability: customAccountability,
+            knex: database,
+        });
+        const messageString = message ? (0, operation_options_1.optionToString)(message) : null;
+        const result = await notificationsService.createOne({
+            recipient,
+            sender: (_a = customAccountability === null || customAccountability === void 0 ? void 0 : customAccountability.user) !== null && _a !== void 0 ? _a : null,
+            subject,
+            message: messageString,
+        });
+        return result;
+    },
+});

package/dist/operations/request/index.d.ts

@@ -0,0 +1,9 @@
+import { Method } from 'axios';
+declare type Options = {
+    url: string;
+    method: Method;
+    body: Record<string, any> | string | null;
+    headers: Record<string, string>;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/request/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const axios_1 = __importDefault(require("axios"));
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'request',
+    handler: async ({ url, method, body, headers }) => {
+        const result = await (0, axios_1.default)({ url, method, data: body, headers });
+        return { status: result.status, statusText: result.statusText, headers: result.headers, data: result.data };
+    },
+});

package/dist/operations/sleep/index.d.ts

@@ -0,0 +1,5 @@
+declare type Options = {
+    milliseconds: string | number;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/sleep/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'sleep',
+    handler: async ({ milliseconds }) => {
+        await new Promise((resolve) => setTimeout(resolve, Number(milliseconds)));
+    },
+});

package/dist/operations/transform/index.d.ts

@@ -0,0 +1,5 @@
+declare type Options = {
+    json: string;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/transform/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const parse_json_1 = require("../../utils/parse-json");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'transform',
+    handler: ({ json }) => {
+        return (0, parse_json_1.parseJSON)(json);
+    },
+});

package/dist/operations/trigger/index.d.ts

@@ -0,0 +1,6 @@
+declare type Options = {
+    flow: string;
+    payload?: Record<string, any> | Record<string, any>[] | string | null;
+};
+declare const _default: import("@directus/shared/types").OperationApiConfig<Options>;
+export default _default;

package/dist/operations/trigger/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@directus/shared/utils");
+const flows_1 = require("../../flows");
+const operation_options_1 = require("../../utils/operation-options");
+exports.default = (0, utils_1.defineOperationApi)({
+    id: 'trigger',
+    handler: async ({ flow, payload }, context) => {
+        var _a;
+        const flowManager = (0, flows_1.getFlowManager)();
+        const payloadObject = (_a = (0, operation_options_1.optionToObject)(payload)) !== null && _a !== void 0 ? _a : null;
+        let result;
+        if (Array.isArray(payloadObject)) {
+            result = await Promise.all(payloadObject.map((payload) => flowManager.runOperationFlow(flow, payload, context)));
+        }
+        else {
+            result = await flowManager.runOperationFlow(flow, payloadObject, context);
+        }
+        return result;
+    },
+});

package/dist/services/activity.d.ts

@@ -1,6 +1,5 @@
-import { AbstractServiceOptions, PrimaryKey, Item } from '../types';
+import { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
 import { ItemsService } from './items';
-import { MutationOptions } from '../types';
 import { NotificationsService } from './notifications';
 import { UsersService } from './users';
 export declare class ActivityService extends ItemsService {

package/dist/services/activity.js

@@ -4,19 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityService = void 0;
-const types_1 = require("../types");
-const items_1 = require("./items");
-const notifications_1 = require("./notifications");
-const users_1 = require("./users");
-const authorization_1 = require("./authorization");
-const get_permissions_1 = require("../utils/get-permissions");
-const forbidden_1 = require("../exceptions/forbidden");
-const logger_1 = __importDefault(require("../logger"));
-const user_name_1 = require("../utils/user-name");
+const types_1 = require("@directus/shared/types");
 const lodash_1 = require("lodash");
-const env_1 = __importDefault(require("../env"));
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
+const env_1 = __importDefault(require("../env"));
+const forbidden_1 = require("../exceptions/forbidden");
+const logger_1 = __importDefault(require("../logger"));
+const get_permissions_1 = require("../utils/get-permissions");
 const url_1 = require("../utils/url");
+const user_name_1 = require("../utils/user-name");
+const authorization_1 = require("./authorization");
+const items_1 = require("./items");
+const notifications_1 = require("./notifications");
+const users_1 = require("./users");
 class ActivityService extends items_1.ItemsService {
     constructor(options) {
         super('directus_activity', options);

package/dist/services/assets.js

@@ -70,9 +70,35 @@ class AssetsService {
         if (!exists)
             throw new exceptions_1.ForbiddenException();
         if (range) {
-            if (range.start >= file.filesize || (range.end && range.end >= file.filesize)) {
+            const missingRangeLimits = range.start === undefined && range.end === undefined;
+            const endBeforeStart = range.start !== undefined && range.end !== undefined && range.end <= range.start;
+            const startOverflow = range.start !== undefined && range.start >= file.filesize;
+            const endUnderflow = range.end !== undefined && range.end <= 0;
+            if (missingRangeLimits || endBeforeStart || startOverflow || endUnderflow) {
                 throw new exceptions_1.RangeNotSatisfiableException(range);
             }
+            const lastByte = file.filesize - 1;
+            if (range.end) {
+                if (range.start === undefined) {
+                    // fetch chunk from tail
+                    range.start = file.filesize - range.end;
+                    range.end = lastByte;
+                }
+                if (range.end >= file.filesize) {
+                    // fetch entire file
+                    range.end = lastByte;
+                }
+            }
+            if (range.start) {
+                if (range.end === undefined) {
+                    // fetch entire file
+                    range.end = lastByte;
+                }
+                if (range.start < 0) {
+                    // fetch file from head
+                    range.start = 0;
+                }
+            }
         }
         const type = file.type;
         const transforms = TransformationUtils.resolvePreset(transformation, file);

package/dist/services/authentication.d.ts

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

package/dist/services/authentication.js

@@ -4,23 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthenticationService = void 0;
+const types_1 = require("@directus/shared/types");
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const lodash_1 = require("lodash");
 const ms_1 = __importDefault(require("ms"));
 const nanoid_1 = require("nanoid");
+const perf_hooks_1 = require("perf_hooks");
+const auth_1 = require("../auth");
+const constants_1 = require("../constants");
 const database_1 = __importDefault(require("../database"));
 const emitter_1 = __importDefault(require("../emitter"));
 const env_1 = __importDefault(require("../env"));
-const auth_1 = require("../auth");
-const constants_1 = require("../constants");
 const exceptions_1 = require("../exceptions");
 const rate_limiter_1 = require("../rate-limiter");
+const stall_1 = require("../utils/stall");
 const activity_1 = require("./activity");
-const tfa_1 = require("./tfa");
-const types_1 = require("../types");
 const settings_1 = require("./settings");
-const lodash_1 = require("lodash");
-const perf_hooks_1 = require("perf_hooks");
-const stall_1 = require("../utils/stall");
+const tfa_1 = require("./tfa");
 const loginAttemptsLimiter = (0, rate_limiter_1.createRateLimiter)({ duration: 0 });
 class AuthenticationService {
     constructor(options) {
@@ -45,7 +45,6 @@ class AuthenticationService {
             .from('directus_users as u')
             .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();
         const updatedPayload = await emitter_1.default.emitFilter('auth.login', payload, {
             status: 'pending',
@@ -79,6 +78,10 @@ class AuthenticationService {
                 throw new exceptions_1.InvalidCredentialsException();
             }
         }
+        else if (user.provider !== providerName) {
+            await (0, stall_1.stall)(STALL_TIME, timeStart);
+            throw new exceptions_1.InvalidProviderException();
+        }
         const settingsService = new settings_1.SettingsService({
             knex: this.knex,
             schema: this.schema,

package/dist/services/authorization.js

@@ -12,6 +12,7 @@ const exceptions_2 = require("../exceptions");
 const strip_function_1 = require("../utils/strip-function");
 const items_1 = require("./items");
 const payload_1 = require("./payload");
+const get_relation_info_1 = require("../utils/get-relation-info");
 class AuthorizationService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -161,6 +162,15 @@ class AuthorizationService {
                         // Filter value is not a filter, so we should skip it
                         return result;
                     }
+                    // virtual o2m/o2a filter in the form of `$FOLLOW(...)`
+                    else if (collection && filterKey.startsWith('$FOLLOW')) {
+                        (result[collection] || (result[collection] = new Set())).add(filterKey);
+                        // add virtual relation to the required permissions
+                        const { relation } = (0, get_relation_info_1.getRelationInfo)([], collection, filterKey);
+                        if ((relation === null || relation === void 0 ? void 0 : relation.collection) && (relation === null || relation === void 0 ? void 0 : relation.field)) {
+                            (result[relation.collection] || (result[relation.collection] = new Set())).add(relation.field);
+                        }
+                    }
                     // m2a filter in the form of `item:collection`
                     else if (filterKey.includes(':')) {
                         const [field, collectionScope] = filterKey.split(':');
@@ -271,6 +281,8 @@ class AuthorizationService {
                     if (allowedFields.length === 0)
                         allowedFields.push(schema.collections[collection].primary);
                     for (const field of requiredPermissions[collection]) {
+                        if (field.startsWith('$FOLLOW'))
+                            continue;
                         if (!allowedFields.includes(field))
                             throw new exceptions_2.ForbiddenException();
                     }

package/dist/services/fields.js

@@ -351,13 +351,6 @@ class FieldsService {
             });
             await this.knex.transaction(async (trx) => {
                 var _a, _b;
-                if (this.schema.collections[collection] &&
-                    field in this.schema.collections[collection].fields &&
-                    this.schema.collections[collection].fields[field].alias === false) {
-                    await trx.schema.table(collection, (table) => {
-                        table.dropColumn(field);
-                    });
-                }
                 const relations = this.schema.relations.filter((relation) => {
                     var _a;
                     return ((relation.collection === collection && relation.field === field) ||
@@ -389,6 +382,14 @@ class FieldsService {
                             .where({ many_collection: relation.collection, many_field: relation.field });
                     }
                 }
+                // Delete field only after foreign key constraints are removed
+                if (this.schema.collections[collection] &&
+                    field in this.schema.collections[collection].fields &&
+                    this.schema.collections[collection].fields[field].alias === false) {
+                    await trx.schema.table(collection, (table) => {
+                        table.dropColumn(field);
+                    });
+                }
                 const collectionMeta = await trx
                     .select('archive_field', 'sort_field')
                     .from('directus_collections')
@@ -441,7 +442,13 @@ class FieldsService {
         if (field.type === 'alias' || field.type === 'unknown')
             return;
         if ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.has_auto_increment) {
-            column = table.increments(field.field);
+            if (field.type === 'bigInteger') {
+                // Create an auto-incremented big integer (MySQL, PostgreSQL) or an auto-incremented integer (other DBs)
+                column = table.bigIncrements(field.field);
+            }
+            else {
+                column = table.increments(field.field);
+            }
         }
         else if (field.type === 'string') {
             column = table.string(field.field, (_c = (_b = field.schema) === null || _b === void 0 ? void 0 : _b.max_length) !== null && _c !== void 0 ? _c : undefined);

package/dist/services/flows.d.ts

@@ -0,0 +1,14 @@
+import { FlowRaw } from '@directus/shared/types';
+import { Messenger } from '../messenger';
+import { AbstractServiceOptions, Item, MutationOptions, PrimaryKey } from '../types';
+import { ItemsService } from './items';
+export declare class FlowsService extends ItemsService<FlowRaw> {
+    messenger: Messenger;
+    constructor(options: AbstractServiceOptions);
+    createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+    updateOne(key: PrimaryKey, data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
+    updateMany(keys: PrimaryKey[], data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey[]>;
+    deleteOne(key: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
+    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
+}