directus 9.11.1 → 9.12.2

package/dist/controllers/operations.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const exceptions_1 = require("../exceptions");
+const respond_1 = require("../middleware/respond");
+const use_collection_1 = __importDefault(require("../middleware/use-collection"));
+const validate_batch_1 = require("../middleware/validate-batch");
+const services_1 = require("../services");
+const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const router = express_1.default.Router();
+router.use((0, use_collection_1.default)('directus_operations'));
+router.post('/', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const savedKeys = [];
+    if (Array.isArray(req.body)) {
+        const keys = await service.createMany(req.body);
+        savedKeys.push(...keys);
+    }
+    else {
+        const key = await service.createOne(req.body);
+        savedKeys.push(key);
+    }
+    try {
+        if (Array.isArray(req.body)) {
+            const items = await service.readMany(savedKeys, req.sanitizedQuery);
+            res.locals.payload = { data: items };
+        }
+        else {
+            const item = await service.readOne(savedKeys[0], req.sanitizedQuery);
+            res.locals.payload = { data: item };
+        }
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+const readHandler = (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const metaService = new services_1.MetaService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const records = await service.readByQuery(req.sanitizedQuery);
+    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+    res.locals.payload = { data: records || null, meta };
+    return next();
+});
+router.get('/', (0, validate_batch_1.validateBatch)('read'), readHandler, respond_1.respond);
+router.search('/', (0, validate_batch_1.validateBatch)('read'), readHandler, respond_1.respond);
+router.get('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const record = await service.readOne(req.params.pk, req.sanitizedQuery);
+    res.locals.payload = { data: record || null };
+    return next();
+}), respond_1.respond);
+router.patch('/', (0, validate_batch_1.validateBatch)('update'), (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    let keys = [];
+    if (req.body.keys) {
+        keys = await service.updateMany(req.body.keys, req.body.data);
+    }
+    else {
+        keys = await service.updateByQuery(req.body.query, req.body.data);
+    }
+    try {
+        const result = await service.readMany(keys, req.sanitizedQuery);
+        res.locals.payload = { data: result };
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+router.patch('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    const primaryKey = await service.updateOne(req.params.pk, req.body);
+    try {
+        const item = await service.readOne(primaryKey, req.sanitizedQuery);
+        res.locals.payload = { data: item || null };
+    }
+    catch (error) {
+        if (error instanceof exceptions_1.ForbiddenException) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond_1.respond);
+router.delete('/', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    if (Array.isArray(req.body)) {
+        await service.deleteMany(req.body);
+    }
+    else if (req.body.keys) {
+        await service.deleteMany(req.body.keys);
+    }
+    else {
+        await service.deleteByQuery(req.body.query);
+    }
+    return next();
+}), respond_1.respond);
+router.delete('/:pk', (0, async_handler_1.default)(async (req, res, next) => {
+    const service = new services_1.OperationsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.deleteOne(req.params.pk);
+    return next();
+}), respond_1.respond);
+exports.default = router;

package/dist/database/helpers/fn/dialects/oracle.d.ts

@@ -1,13 +1,13 @@
-import { FnHelper } from '../types';
+import { FnHelper, FnHelperOptions } from '../types';
 import { Knex } from 'knex';
 export declare class FnHelperOracle extends FnHelper {
-    year(table: string, column: string): Knex.Raw;
-    month(table: string, column: string): Knex.Raw;
-    week(table: string, column: string): Knex.Raw;
-    day(table: string, column: string): Knex.Raw;
-    weekday(table: string, column: string): Knex.Raw;
-    hour(table: string, column: string): Knex.Raw;
-    minute(table: string, column: string): Knex.Raw;
-    second(table: string, column: string): Knex.Raw;
+    year(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    month(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    week(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    day(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    weekday(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    hour(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    minute(table: string, column: string, options: FnHelperOptions): Knex.Raw;
+    second(table: string, column: string, options: FnHelperOptions): Knex.Raw;
     count(table: string, column: string): Knex.Raw<any>;
 }

package/dist/database/helpers/fn/dialects/oracle.js

@@ -2,30 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FnHelperOracle = void 0;
 const types_1 = require("../types");
+const parseLocaltime = (columnType) => {
+    if (columnType === 'timestamp') {
+        return ` AT TIME ZONE 'UTC'`;
+    }
+    return '';
+};
 class FnHelperOracle extends types_1.FnHelper {
-    year(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'IYYY')", [table, column]);
+    year(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'IYYY')`, [table, column]);
     }
-    month(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'MM')", [table, column]);
+    month(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'MM')`, [table, column]);
     }
-    week(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'IW')", [table, column]);
+    week(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'IW')`, [table, column]);
     }
-    day(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'DD')", [table, column]);
+    day(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'DD')`, [table, column]);
     }
-    weekday(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'D')", [table, column]);
+    weekday(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'D')`, [table, column]);
     }
-    hour(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'HH24')", [table, column]);
+    hour(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'HH24')`, [table, column]);
     }
-    minute(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'MI')", [table, column]);
+    minute(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'MI')`, [table, column]);
     }
-    second(table, column) {
-        return this.knex.raw("TO_CHAR(??.??, 'SS')", [table, column]);
+    second(table, column, options) {
+        return this.knex.raw(`TO_CHAR(??.??${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}, 'SS')`, [table, column]);
     }
     count(table, column) {
         var _a, _b, _c, _d, _e;

package/dist/database/helpers/fn/dialects/sqlite.d.ts

@@ -1,13 +1,13 @@
-import { FnHelper } from '../types';
+import { FnHelper, FnHelperOptions } from '../types';
 import { Knex } from 'knex';
 export declare class FnHelperSQLite extends FnHelper {
-    year(table: string, column: string): Knex.Raw;
-    month(table: string, column: string): Knex.Raw;
-    week(table: string, column: string): Knex.Raw;
-    day(table: string, column: string): Knex.Raw;
-    weekday(table: string, column: string): Knex.Raw;
-    hour(table: string, column: string): Knex.Raw;
-    minute(table: string, column: string): Knex.Raw;
-    second(table: string, column: string): Knex.Raw;
+    year(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    month(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    week(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    day(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    weekday(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    hour(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    minute(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    second(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     count(table: string, column: string): Knex.Raw<any>;
 }

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

@@ -2,30 +2,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FnHelperSQLite = void 0;
 const types_1 = require("../types");
+const parseLocaltime = (columnType) => {
+    if (columnType === 'timestamp') {
+        return '';
+    }
+    return `, 'localtime'`;
+};
 class FnHelperSQLite extends types_1.FnHelper {
-    year(table, column) {
-        return this.knex.raw("CAST(strftime('%Y', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    year(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%Y', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    month(table, column) {
-        return this.knex.raw("CAST(strftime('%m', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    month(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%m', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    week(table, column) {
-        return this.knex.raw("CAST(strftime('%W', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    week(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%W', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    day(table, column) {
-        return this.knex.raw("CAST(strftime('%d', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    day(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%d', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    weekday(table, column) {
-        return this.knex.raw("CAST(strftime('%w', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    weekday(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%w', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    hour(table, column) {
-        return this.knex.raw("CAST(strftime('%H', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    hour(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%H', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    minute(table, column) {
-        return this.knex.raw("CAST(strftime('%M', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    minute(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%M', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
-    second(table, column) {
-        return this.knex.raw("CAST(strftime('%S', ??.?? / 1000, 'unixepoch') AS INTEGER)", [table, column]);
+    second(table, column, options) {
+        return this.knex.raw(`CAST(strftime('%S', ??.?? / 1000, 'unixepoch'${parseLocaltime(options === null || options === void 0 ? void 0 : options.type)}) AS INTEGER)`, [
+            table,
+            column,
+        ]);
     }
     count(table, column) {
         var _a, _b, _c, _d, _e;

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

@@ -1,18 +1,21 @@
 import { SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 import { DatabaseHelper } from '../types';
+export declare type FnHelperOptions = {
+    type?: string;
+};
 export declare abstract class FnHelper extends DatabaseHelper {
     protected knex: Knex;
     protected schema: SchemaOverview;
     constructor(knex: Knex, schema: SchemaOverview);
-    abstract year(table: string, column: string): Knex.Raw;
-    abstract month(table: string, column: string): Knex.Raw;
-    abstract week(table: string, column: string): Knex.Raw;
-    abstract day(table: string, column: string): Knex.Raw;
-    abstract weekday(table: string, column: string): Knex.Raw;
-    abstract hour(table: string, column: string): Knex.Raw;
-    abstract minute(table: string, column: string): Knex.Raw;
-    abstract second(table: string, column: string): Knex.Raw;
-    abstract count(table: string, column: string): Knex.Raw;
+    abstract year(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract month(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract week(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract day(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract weekday(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract hour(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract minute(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract second(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
+    abstract count(table: string, column: string, options?: FnHelperOptions): Knex.Raw;
     protected _relationalCount(table: string, column: string): Knex.Raw;
 }

package/dist/database/index.js

@@ -22,18 +22,9 @@ function getDatabase() {
     if (database) {
         return database;
     }
-    const connectionConfig = (0, get_config_from_env_1.getConfigFromEnv)('DB_', [
-        'DB_CLIENT',
-        'DB_VERSION',
-        'DB_SEARCH_PATH',
-        'DB_CONNECTION_STRING',
-        'DB_POOL',
-        'DB_EXCLUDE_TABLES',
-        'DB_VERSION',
-    ]);
-    const poolConfig = (0, get_config_from_env_1.getConfigFromEnv)('DB_POOL');
+    const { client, version, searchPath, connectionString, pool: poolConfig = {}, ...connectionConfig } = (0, get_config_from_env_1.getConfigFromEnv)('DB_', ['DB_EXCLUDE_TABLES']);
     const requiredEnvVars = ['DB_CLIENT'];
-    switch (env_1.default.DB_CLIENT) {
+    switch (client) {
         case 'sqlite3':
             requiredEnvVars.push('DB_FILENAME');
             break;
@@ -47,7 +38,7 @@ function getDatabase() {
             break;
         case 'cockroachdb':
         case 'pg':
-            if (!env_1.default.DB_CONNECTION_STRING) {
+            if (!connectionString) {
                 requiredEnvVars.push('DB_HOST', 'DB_PORT', 'DB_DATABASE', 'DB_USER');
             }
             else {
@@ -64,10 +55,10 @@ function getDatabase() {
     }
     (0, validate_env_1.validateEnv)(requiredEnvVars);
     const knexConfig = {
-        client: env_1.default.DB_CLIENT,
-        version: env_1.default.DB_VERSION,
-        searchPath: env_1.default.DB_SEARCH_PATH,
-        connection: env_1.default.DB_CONNECTION_STRING || connectionConfig,
+        client,
+        version,
+        searchPath,
+        connection: connectionString || connectionConfig,
         log: {
             warn: (msg) => {
                 // Ignore warnings about returning not being supported in some DBs
@@ -84,7 +75,7 @@ function getDatabase() {
         },
         pool: poolConfig,
     };
-    if (env_1.default.DB_CLIENT === 'sqlite3') {
+    if (client === 'sqlite3') {
         knexConfig.useNullAsDefault = true;
         poolConfig.afterCreate = async (conn, callback) => {
             logger_1.default.trace('Enabling SQLite Foreign Keys support...');
@@ -93,7 +84,7 @@ function getDatabase() {
             callback(null, conn);
         };
     }
-    if (env_1.default.DB_CLIENT === 'cockroachdb') {
+    if (client === 'cockroachdb') {
         poolConfig.afterCreate = async (conn, callback) => {
             logger_1.default.trace('Setting CRDB serial_normalization and default_int_size');
             const run = (0, util_1.promisify)(conn.query.bind(conn));
@@ -102,7 +93,7 @@ function getDatabase() {
             callback(null, conn);
         };
     }
-    if (env_1.default.DB_CLIENT === 'mssql') {
+    if (client === 'mssql') {
         // This brings MS SQL in line with the other DB vendors. We shouldn't do any automatic
         // timezone conversion on the database level, especially not when other database vendors don't
         // act the same

package/dist/database/migrations/20220429A-add-flows.d.ts

@@ -0,0 +1,3 @@
+import { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20220429A-add-flows.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+const utils_1 = require("@directus/shared/utils");
+const uuid_1 = require("uuid");
+const parse_json_1 = require("../../utils/parse-json");
+async function up(knex) {
+    await knex.schema.createTable('directus_flows', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.string('name').notNullable();
+        table.string('icon', 30);
+        table.string('color').nullable();
+        table.text('description');
+        table.string('status').notNullable().defaultTo('active');
+        table.string('trigger');
+        table.string('accountability').defaultTo('all');
+        table.json('options');
+        table.uuid('operation').unique();
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+    });
+    await knex.schema.createTable('directus_operations', (table) => {
+        table.uuid('id').primary().notNullable();
+        table.string('name');
+        table.string('key').notNullable();
+        table.string('type').notNullable();
+        table.integer('position_x').notNullable();
+        table.integer('position_y').notNullable();
+        table.json('options');
+        table.uuid('resolve').unique().references('id').inTable('directus_operations');
+        table.uuid('reject').unique().references('id').inTable('directus_operations');
+        table.uuid('flow').notNullable().references('id').inTable('directus_flows').onDelete('CASCADE');
+        table.timestamp('date_created').defaultTo(knex.fn.now());
+        table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
+    });
+    const webhooks = await knex.select('*').from('directus_webhooks');
+    const flows = [];
+    const operations = [];
+    for (const webhook of webhooks) {
+        const flowID = (0, uuid_1.v4)();
+        flows.push({
+            id: flowID,
+            name: webhook.name,
+            status: 'inactive',
+            trigger: 'hook',
+            options: JSON.stringify({
+                name: webhook.name,
+                type: 'action',
+                scope: (0, utils_1.toArray)(webhook.actions).map((scope) => `items.${scope}`),
+                collections: (0, utils_1.toArray)(webhook.collections),
+            }),
+        });
+        operations.push({
+            id: (0, uuid_1.v4)(),
+            name: 'Request',
+            key: 'request',
+            type: 'request',
+            position_x: 21,
+            position_y: 1,
+            options: JSON.stringify({
+                url: webhook.url,
+                headers: typeof webhook.headers === 'string' ? (0, parse_json_1.parseJSON)(webhook.headers) : webhook.headers,
+                data: webhook.data ? '{{$trigger}}' : null,
+                method: webhook.method,
+            }),
+            date_created: new Date(),
+            flow: flowID,
+        });
+    }
+    if (flows.length && operations.length) {
+        await knex.insert(flows).into('directus_flows');
+        await knex.insert(operations).into('directus_operations');
+        for (const operation of operations) {
+            await knex('directus_flows').update({ operation: operation.id }).where({ id: operation.flow });
+        }
+    }
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.dropTable('directus_operations');
+    await knex.schema.dropTable('directus_flows');
+}
+exports.down = down;

package/dist/database/migrations/20220429B-add-color-to-insights-icon.d.ts

@@ -0,0 +1,3 @@
+import { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20220429B-add-color-to-insights-icon.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+async function up(knex) {
+    await knex.schema.alterTable('directus_dashboards', (table) => {
+        table.string('color').nullable();
+    });
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.alterTable('directus_dashboards', (table) => {
+        table.dropColumn('color');
+    });
+}
+exports.down = down;

package/dist/database/migrations/20220429C-drop-non-null-from-ip-of-activity.d.ts

@@ -0,0 +1,3 @@
+import { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20220429C-drop-non-null-from-ip-of-activity.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+async function up(knex) {
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.setNullable('ip');
+    });
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.alterTable('directus_activity', (table) => {
+        table.dropNullable('ip');
+    });
+}
+exports.down = down;

package/dist/database/migrations/20220429D-drop-non-null-from-sender-of-notifications.d.ts

@@ -0,0 +1,3 @@
+import { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20220429D-drop-non-null-from-sender-of-notifications.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.down = exports.up = void 0;
+async function up(knex) {
+    await knex.schema.alterTable('directus_notifications', (table) => {
+        table.setNullable('sender');
+    });
+}
+exports.up = up;
+async function down(knex) {
+    await knex.schema.alterTable('directus_notifications', (table) => {
+        table.dropNullable('sender');
+    });
+}
+exports.down = down;

package/dist/database/seeds/05-activity.yaml

@@ -20,7 +20,6 @@ columns:
   user_agent:
     type: string
     length: 255
-    nullabel: false
   collection:
     type: string
     length: 64

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

@@ -68,3 +68,7 @@ data:
   - collection: directus_shares
     icon: share
     note: $t:directus_collection.directus_shares
+  - collection: directus_flows
+    note: $t:directus_collection.directus_flows
+  - collection: directus_operations
+    note: $t:directus_collection.directus_operations

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

@@ -0,0 +1,21 @@
+table: directus_flows
+
+fields:
+  - field: id
+    special: uuid
+  - field: name
+  - field: icon
+  - field: color
+  - field: description
+  - field: status
+  - field: trigger
+  - field: accountability
+  - field: options
+    special: cast-json
+  - field: operation
+  - field: operations
+    special: o2m
+  - field: date_created
+    special: date-created
+  - field: user_created
+    special: user-created

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

@@ -0,0 +1,19 @@
+table: directus_operations
+
+fields:
+  - field: id
+    special: uuid
+  - field: name
+  - field: key
+  - field: type
+  - field: position_x
+  - field: position_y
+  - field: options
+    special: cast-json
+  - field: resolve
+  - field: reject
+  - field: flow
+  - field: date_created
+    special: date-created
+  - field: user_created
+    special: user-created

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

@@ -135,10 +135,8 @@ fields:
       template: '{{ name }}'
 
   - field: token
-    interface: token
-    options:
-      iconRight: vpn_key
-      placeholder: $t:fields.directus_users.token_placeholder
+    interface: system-token
+    special: conceal
     width: full
 
   - field: id