directus 9.11.0 → 9.12.1

package/dist/services/operations.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationsService = void 0;
+const messenger_1 = require("../messenger");
+const items_1 = require("./items");
+class OperationsService extends items_1.ItemsService {
+    constructor(options) {
+        super('directus_operations', options);
+        this.messenger = (0, messenger_1.getMessenger)();
+    }
+    async createOne(data, opts) {
+        const result = await super.createOne(data, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+    async createMany(data, opts) {
+        const result = await super.createMany(data, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+    async updateOne(key, data, opts) {
+        const result = await super.updateOne(key, data, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+    async updateMany(keys, data, opts) {
+        const result = await super.updateMany(keys, data, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+    async deleteOne(key, opts) {
+        const result = await super.deleteOne(key, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+    async deleteMany(keys, opts) {
+        const result = await super.deleteMany(keys, opts);
+        this.messenger.publish('flows', { type: 'reload' });
+        return result;
+    }
+}
+exports.OperationsService = OperationsService;

package/dist/services/webhooks.d.ts

@@ -1,6 +1,8 @@
 import { AbstractServiceOptions, Item, PrimaryKey, Webhook, MutationOptions } from '../types';
 import { ItemsService } from './items';
+import { Messenger } from '../messenger';
 export declare class WebhooksService extends ItemsService<Webhook> {
+    messenger: Messenger;
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;
     createMany(data: Partial<Item>[], opts?: MutationOptions): Promise<PrimaryKey[]>;

package/dist/services/webhooks.js

@@ -1,40 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhooksService = void 0;
-const webhooks_1 = require("../webhooks");
 const items_1 = require("./items");
+const messenger_1 = require("../messenger");
 class WebhooksService extends items_1.ItemsService {
     constructor(options) {
         super('directus_webhooks', options);
+        this.messenger = (0, messenger_1.getMessenger)();
     }
     async createOne(data, opts) {
         const result = await super.createOne(data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async createMany(data, opts) {
         const result = await super.createMany(data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async updateOne(key, data, opts) {
         const result = await super.updateOne(key, data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async updateMany(keys, data, opts) {
         const result = await super.updateMany(keys, data, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async deleteOne(key, opts) {
         const result = await super.deleteOne(key, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
     async deleteMany(keys, opts) {
         const result = await super.deleteMany(keys, opts);
-        await (0, webhooks_1.register)();
+        this.messenger.publish('webhooks', { type: 'reload' });
         return result;
     }
 }

package/dist/types/events.d.ts

@@ -0,0 +1,18 @@
+import { ActionHandler, FilterHandler, InitHandler } from '@directus/shared/types';
+import { ScheduledTask } from 'node-cron';
+export declare type EventHandler = {
+    type: 'filter';
+    name: string;
+    handler: FilterHandler;
+} | {
+    type: 'action';
+    name: string;
+    handler: ActionHandler;
+} | {
+    type: 'init';
+    name: string;
+    handler: InitHandler;
+} | {
+    type: 'schedule';
+    task: ScheduledTask;
+};

package/dist/types/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
-export * from './activity';
 export * from './assets';
 export * from './ast';
 export * from './auth';
 export * from './collection';
+export * from './events';
 export * from './files';
 export * from './graphql';
 export * from './items';

package/dist/types/index.js

@@ -10,11 +10,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./activity"), exports);
 __exportStar(require("./assets"), exports);
 __exportStar(require("./ast"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./collection"), exports);
+__exportStar(require("./events"), exports);
 __exportStar(require("./files"), exports);
 __exportStar(require("./graphql"), exports);
 __exportStar(require("./items"), exports);

package/dist/utils/{apply-query/index.js → apply-query.js}

@@ -7,12 +7,12 @@ exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.app
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const uuid_validate_1 = __importDefault(require("uuid-validate"));
-const helpers_1 = require("../../database/helpers");
-const invalid_query_1 = require("../../exceptions/invalid-query");
-const get_column_1 = require("../get-column");
-const get_column_path_1 = require("../get-column-path");
-const get_relation_info_1 = require("../get-relation-info");
-const operators_1 = __importDefault(require("./operators"));
+const helpers_1 = require("../database/helpers");
+const invalid_query_1 = require("../exceptions/invalid-query");
+const get_column_1 = require("./get-column");
+const get_column_path_1 = require("./get-column-path");
+const get_relation_info_1 = require("./get-relation-info");
+const utils_1 = require("@directus/shared/utils");
 const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
 /**
  * Apply the Query to a given Knex query builder instance
@@ -155,9 +155,6 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
     addJoins(rootQuery, rootFilter, collection);
     addWhereClauses(knex, rootQuery, rootFilter, collection);
     return rootQuery;
-    function isNegativeOperator(operator) {
-        return operator.indexOf('_n') === 0;
-    }
     function addJoins(dbQuery, filter, collection) {
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
@@ -185,33 +182,8 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
         }
     }
-    function callbackSubqueryRelation(relation, value) {
-        return function (subQueryKnex) {
-            const field = relation.field;
-            const collection = relation.collection;
-            const column = `${collection}.${field}`;
-            subQueryKnex.from(collection).whereRaw(`${field} = ${column}`);
-            applyQuery(knex, relation.collection, subQueryKnex, {
-                filter: value,
-            }, schema, true);
-        };
-    }
-    function inverseFilters(value) {
-        for (const field in value) {
-            for (const operator in value[field]) {
-                let inverseOperator = operator;
-                if (isNegativeOperator(operator)) {
-                    inverseOperator = '_' + operator.substring(2);
-                }
-                else {
-                    inverseOperator = '_n' + operator.substring(1);
-                }
-                value[field][inverseOperator] = value[field][operator];
-                delete value[field][operator];
-            }
-        }
-    }
     function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
+        var _a, _b;
         for (const [key, value] of Object.entries(filter)) {
             if (key === '_or' || key === '_and') {
                 // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
@@ -252,12 +224,24 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 if (relationType === 'o2a') {
                     pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
                 }
-                if (isNegativeOperator(filterOperator)) {
-                    inverseFilters(value);
-                    dbQuery[logical].whereNotExists(callbackSubqueryRelation(relation, value));
+                const subQueryBuilder = (filter) => (subQueryKnex) => {
+                    const field = relation.field;
+                    const collection = relation.collection;
+                    const column = `${collection}.${field}`;
+                    subQueryKnex
+                        .select({ [field]: column })
+                        .from(collection)
+                        .whereNotNull(column);
+                    applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, true);
+                };
+                if (((_a = Object.keys(value)) === null || _a === void 0 ? void 0 : _a[0]) === '_none') {
+                    dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0]));
+                }
+                else if (((_b = Object.keys(value)) === null || _b === void 0 ? void 0 : _b[0]) === '_some') {
+                    dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0]));
                 }
                 else {
-                    dbQuery[logical].whereExists(callbackSubqueryRelation(relation, value));
+                    dbQuery[logical].whereIn(pkField, subQueryBuilder(value));
                 }
             }
         }
@@ -267,6 +251,32 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema);
             // Knex supports "raw" in the columnName parameter, but isn't typed as such. Too bad..
             // See https://github.com/knex/knex/issues/4518 @TODO remove as any once knex is updated
+            // These operators don't rely on a value, and can thus be used without one (eg `?filter[field][_null]`)
+            if (operator === '_null' || (operator === '_nnull' && compareValue === false)) {
+                dbQuery[logical].whereNull(selectionRaw);
+            }
+            if (operator === '_nnull' || (operator === '_null' && compareValue === false)) {
+                dbQuery[logical].whereNotNull(selectionRaw);
+            }
+            if (operator === '_empty' || (operator === '_nempty' && compareValue === false)) {
+                dbQuery[logical].andWhere((query) => {
+                    query.where(key, '=', '');
+                });
+            }
+            if (operator === '_nempty' || (operator === '_empty' && compareValue === false)) {
+                dbQuery[logical].andWhere((query) => {
+                    query.where(key, '!=', '');
+                });
+            }
+            // Cast filter value (compareValue) based on function used
+            if (column.includes('(') && column.includes(')')) {
+                const functionName = column.split('(')[0];
+                const type = (0, utils_1.getOutputTypeForFunction)(functionName);
+                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
+                    compareValue = Number(compareValue);
+                }
+            }
+            // Cast filter value (compareValue) based on type of field being filtered against
             const [collection, field] = key.split('.');
             if (collection in schema.collections && field in schema.collections[collection].fields) {
                 const type = schema.collections[collection].fields[field].type;
@@ -298,16 +308,105 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 // We need to remove any undefined values, as they are useless
                 compareValue = compareValue.filter((val) => val !== undefined);
             }
-            if (operator in operators_1.default) {
-                operators_1.default[operator].apply({
-                    query: dbQuery[logical],
-                    helpers,
-                    selectionRaw,
-                    compareValue,
-                });
+            if (operator === '_eq') {
+                dbQuery[logical].where(selectionRaw, '=', compareValue);
             }
-            else {
-                throw new Error(`Operator ${operator} not supported`);
+            if (operator === '_neq') {
+                dbQuery[logical].whereNot(selectionRaw, compareValue);
+            }
+            if (operator === '_ieq') {
+                dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_nieq') {
+                dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_contains') {
+                dbQuery[logical].where(selectionRaw, 'like', `%${compareValue}%`);
+            }
+            if (operator === '_ncontains') {
+                dbQuery[logical].whereNot(selectionRaw, 'like', `%${compareValue}%`);
+            }
+            if (operator === '_icontains') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_nicontains') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_starts_with') {
+                dbQuery[logical].where(key, 'like', `${compareValue}%`);
+            }
+            if (operator === '_nstarts_with') {
+                dbQuery[logical].whereNot(key, 'like', `${compareValue}%`);
+            }
+            if (operator === '_istarts_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_nistarts_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+            }
+            if (operator === '_ends_with') {
+                dbQuery[logical].where(key, 'like', `%${compareValue}`);
+            }
+            if (operator === '_nends_with') {
+                dbQuery[logical].whereNot(key, 'like', `%${compareValue}`);
+            }
+            if (operator === '_iends_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_niends_with') {
+                dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+            }
+            if (operator === '_gt') {
+                dbQuery[logical].where(selectionRaw, '>', compareValue);
+            }
+            if (operator === '_gte') {
+                dbQuery[logical].where(selectionRaw, '>=', compareValue);
+            }
+            if (operator === '_lt') {
+                dbQuery[logical].where(selectionRaw, '<', compareValue);
+            }
+            if (operator === '_lte') {
+                dbQuery[logical].where(selectionRaw, '<=', compareValue);
+            }
+            if (operator === '_in') {
+                let value = compareValue;
+                if (typeof value === 'string')
+                    value = value.split(',');
+                dbQuery[logical].whereIn(selectionRaw, value);
+            }
+            if (operator === '_nin') {
+                let value = compareValue;
+                if (typeof value === 'string')
+                    value = value.split(',');
+                dbQuery[logical].whereNotIn(selectionRaw, value);
+            }
+            if (operator === '_between') {
+                if (compareValue.length !== 2)
+                    return;
+                let value = compareValue;
+                if (typeof value === 'string')
+                    value = value.split(',');
+                dbQuery[logical].whereBetween(selectionRaw, value);
+            }
+            if (operator === '_nbetween') {
+                if (compareValue.length !== 2)
+                    return;
+                let value = compareValue;
+                if (typeof value === 'string')
+                    value = value.split(',');
+                dbQuery[logical].whereNotBetween(selectionRaw, value);
+            }
+            if (operator == '_intersects') {
+                dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
+            }
+            if (operator == '_nintersects') {
+                dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
+            }
+            if (operator == '_intersects_bbox') {
+                dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
+            }
+            if (operator == '_nintersects_bbox') {
+                dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
             }
         }
     }

package/dist/utils/construct-flow-tree.d.ts

@@ -0,0 +1,2 @@
+import { Flow, FlowRaw } from '@directus/shared/types';
+export declare function constructFlowTree(flow: FlowRaw): Flow;

package/dist/utils/construct-flow-tree.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructFlowTree = void 0;
+const lodash_1 = require("lodash");
+function constructFlowTree(flow) {
+    var _a;
+    const rootOperation = (_a = flow.operations.find((operation) => operation.id === flow.operation)) !== null && _a !== void 0 ? _a : null;
+    const operationTree = constructOperationTree(rootOperation, flow.operations);
+    const flowTree = {
+        ...(0, lodash_1.omit)(flow, 'operations'),
+        operation: operationTree,
+    };
+    return flowTree;
+}
+exports.constructFlowTree = constructFlowTree;
+function constructOperationTree(root, operations) {
+    if (root === null) {
+        return null;
+    }
+    const resolveOperation = root.resolve !== null ? operations.find((operation) => operation.id === root.resolve) : null;
+    const rejectOperation = root.reject !== null ? operations.find((operation) => operation.id === root.reject) : null;
+    if (resolveOperation === undefined || rejectOperation === undefined) {
+        throw new Error('Undefined reference in operations');
+    }
+    const operationTree = {
+        ...(0, lodash_1.omit)(root, 'flow'),
+        resolve: constructOperationTree(resolveOperation, operations),
+        reject: constructOperationTree(rejectOperation, operations),
+    };
+    return operationTree;
+}

package/dist/utils/get-accountability-for-role.d.ts

@@ -0,0 +1,7 @@
+import { Accountability, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
+export declare function getAccountabilityForRole(role: null | string, context: {
+    accountability: null | Accountability;
+    schema: SchemaOverview;
+    database: Knex;
+}): Promise<Accountability>;

package/dist/utils/get-accountability-for-role.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountabilityForRole = void 0;
+const get_permissions_1 = require("./get-permissions");
+const exceptions_1 = require("../exceptions");
+async function getAccountabilityForRole(role, context) {
+    let generatedAccountability = context.accountability;
+    if (role === null) {
+        generatedAccountability = {
+            role: null,
+            user: null,
+            admin: false,
+            app: false,
+        };
+        generatedAccountability.permissions = await (0, get_permissions_1.getPermissions)(generatedAccountability, context.schema);
+    }
+    else {
+        const roleInfo = await context.database
+            .select(['app_access', 'admin_access'])
+            .from('directus_roles')
+            .where({ id: role })
+            .first();
+        if (!roleInfo) {
+            throw new exceptions_1.InvalidConfigException(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
+        }
+        generatedAccountability = {
+            role,
+            user: null,
+            admin: roleInfo.admin_access === 1 || roleInfo.admin_access === '1' || roleInfo.admin_access === true,
+            app: roleInfo.app_access === 1 || roleInfo.app_access === '1' || roleInfo.app_access === true,
+        };
+        generatedAccountability.permissions = await (0, get_permissions_1.getPermissions)(generatedAccountability, context.schema);
+    }
+    return generatedAccountability;
+}
+exports.getAccountabilityForRole = getAccountabilityForRole;

package/dist/utils/operation-options.d.ts

@@ -0,0 +1,3 @@
+export declare function applyOperationOptions(options: Record<string, any>, data: Record<string, any>): Record<string, any>;
+export declare function optionToObject<T>(option: T): Exclude<T, string>;
+export declare function optionToString(option: unknown): string;

package/dist/utils/operation-options.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionToString = exports.optionToObject = exports.applyOperationOptions = void 0;
+const micromustache_1 = require("micromustache");
+const parse_json_1 = require("./parse-json");
+function resolveFn(path, scope) {
+    if (!scope)
+        return undefined;
+    const value = (0, micromustache_1.get)(scope, path);
+    return typeof value === 'object' ? JSON.stringify(value) : value;
+}
+function renderMustache(item, scope) {
+    if (typeof item === 'string') {
+        return (0, micromustache_1.renderFn)(item, resolveFn, scope, { explicit: true });
+    }
+    else if (Array.isArray(item)) {
+        return item.map((element) => renderMustache(element, scope));
+    }
+    else if (typeof item === 'object' && item !== null) {
+        return Object.fromEntries(Object.entries(item).map(([key, value]) => [key, renderMustache(value, scope)]));
+    }
+    else {
+        return item;
+    }
+}
+function applyOperationOptions(options, data) {
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+        if (typeof value === 'string') {
+            const single = value.match(/^\{\{\s*([^}\s]+)\s*\}\}$/);
+            if (single !== null) {
+                return [key, (0, micromustache_1.get)(data, single[1])];
+            }
+        }
+        return [key, renderMustache(value, data)];
+    }));
+}
+exports.applyOperationOptions = applyOperationOptions;
+function optionToObject(option) {
+    return typeof option === 'string' ? (0, parse_json_1.parseJSON)(option) : option;
+}
+exports.optionToObject = optionToObject;
+function optionToString(option) {
+    return typeof option === 'object' ? JSON.stringify(option) : String(option);
+}
+exports.optionToString = optionToString;

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

@@ -0,0 +1,6 @@
+import { SchemaOverview } from '@directus/shared/types';
+import { PrimaryKey } from '../types';
+/**
+ * Validate keys based on its type
+ */
+export declare function validateKeys(schema: SchemaOverview, collection: string, keyField: string, keys: PrimaryKey | PrimaryKey[]): void;

package/dist/utils/validate-keys.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKeys = void 0;
+const exceptions_1 = require("../exceptions");
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
+/**
+ * Validate keys based on its type
+ */
+function validateKeys(schema, collection, keyField, keys) {
+    if (Array.isArray(keys)) {
+        for (const key of keys) {
+            validateKeys(schema, collection, keyField, key);
+        }
+    }
+    else {
+        const primaryKeyFieldType = schema.collections[collection].fields[keyField].type;
+        if (primaryKeyFieldType === 'uuid' && !(0, uuid_validate_1.default)(String(keys))) {
+            throw new exceptions_1.ForbiddenException();
+        }
+        else if (primaryKeyFieldType === 'integer' && !Number.isInteger(Number(keys))) {
+            throw new exceptions_1.ForbiddenException();
+        }
+    }
+}
+exports.validateKeys = validateKeys;

package/dist/utils/validate-query.js

@@ -104,7 +104,7 @@ function validateFilterPrimitive(value, key) {
         false) {
         throw new exceptions_1.InvalidQueryException(`The filter value for "${key}" has to be a string, number, or boolean`);
     }
-    if (typeof value === 'number' && (Number.isNaN(value) || !Number.isSafeInteger(value))) {
+    if (typeof value === 'number' && (Number.isNaN(value) || value > Number.MAX_SAFE_INTEGER)) {
         throw new exceptions_1.InvalidQueryException(`The filter value for "${key}" is not a valid number`);
     }
     if (typeof value === 'string' && value.length === 0) {

package/dist/webhooks.d.ts

@@ -1,2 +1,4 @@
+export declare function init(): Promise<void>;
+export declare function reload(): Promise<void>;
 export declare function register(): Promise<void>;
 export declare function unregister(): void;

package/dist/webhooks.js

@@ -3,16 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregister = exports.register = void 0;
+exports.unregister = exports.register = exports.reload = exports.init = void 0;
 const axios_1 = __importDefault(require("axios"));
 const database_1 = __importDefault(require("./database"));
 const emitter_1 = __importDefault(require("./emitter"));
 const logger_1 = __importDefault(require("./logger"));
 const services_1 = require("./services");
 const get_schema_1 = require("./utils/get-schema");
+const messenger_1 = require("./messenger");
 let registered = [];
-async function register() {
+async function init() {
+    await register();
+    const messenger = (0, messenger_1.getMessenger)();
+    messenger.subscribe('webhooks', (event) => {
+        if (event.type === 'reload') {
+            reload();
+        }
+    });
+}
+exports.init = init;
+async function reload() {
     unregister();
+    await register();
+}
+exports.reload = reload;
+async function register() {
     const webhookService = new services_1.WebhooksService({ knex: (0, database_1.default)(), schema: await (0, get_schema_1.getSchema)() });
     const webhooks = await webhookService.readByQuery({ filter: { status: { _eq: 'active' } } });
     for (const webhook of webhooks) {