@directus/api 35.0.2 → 35.1.0

package/dist/flows.js

@@ -26,9 +26,7 @@ import { get as get$1 } from "micromustache";
 //#region src/flows.ts
 let flowManager;
 function getFlowManager() {
-	if (flowManager) {
-		return flowManager;
-	}
+	if (flowManager) return flowManager;
 	flowManager = new FlowManager();
 	return flowManager;
 }
@@ -38,7 +36,8 @@ const LAST_KEY = "$last";
 const ENV_KEY = "$env";
 var FlowManager = class {
 	isLoaded = false;
-	operations = new Map();
+	flows = {};
+	operations = /* @__PURE__ */ new Map();
 	triggerHandlers = [];
 	operationFlowHandlers = {};
 	webhookFlowHandlers = {};
@@ -49,28 +48,20 @@ var FlowManager = class {
 		const logger = useLogger();
 		this.reloadQueue = new JobQueue();
 		this.envs = env["FLOWS_ENV_ALLOW_LIST"] ? pick(env, toArray(env["FLOWS_ENV_ALLOW_LIST"])) : {};
-		const messenger = useBus();
-		messenger.subscribe("flows", (event) => {
-			if (event["type"] === "reload") {
-				this.reloadQueue.enqueue(async () => {
-					if (this.isLoaded) {
-						await this.unload();
-						await this.load();
-					} else {
-						logger.warn("Flows have to be loaded before they can be reloaded");
-					}
-				});
-			}
+		useBus().subscribe("flows", (event) => {
+			if (event["type"] === "reload") this.reloadQueue.enqueue(async () => {
+				if (this.isLoaded) {
+					await this.unload();
+					await this.load();
+				} else logger.warn("Flows have to be loaded before they can be reloaded");
+			});
 		});
 	}
 	async initialize() {
-		if (!this.isLoaded) {
-			await this.load();
-		}
+		if (!this.isLoaded) await this.load();
 	}
 	async reload() {
-		const messenger = useBus();
-		messenger.publish("flows", { type: "reload" });
+		useBus().publish("flows", { type: "reload" });
 	}
 	addOperation(id, operation) {
 		this.operations.set(id, operation);
@@ -96,40 +87,40 @@ var FlowManager = class {
 		const handler = this.webhookFlowHandlers[id];
 		return handler(data, context);
 	}
+	getFlow(id) {
+		return this.flows[id];
+	}
 	async load() {
 		const logger = useLogger();
-		const flowsService = new FlowsService({
+		const flowTrees = (await new FlowsService({
 			knex: database_default(),
 			schema: await getSchema()
-		});
-		const flows = await flowsService.readByQuery({
+		}).readByQuery({
 			filter: { status: { _eq: "active" } },
 			fields: ["*", "operations.*"],
 			limit: -1
-		});
-		const flowTrees = flows.map((flow) => constructFlowTree(flow));
+		})).map((flow) => constructFlowTree(flow));
 		for (const flow of flowTrees) {
+			this.flows[flow.id] = flow;
 			if (flow.trigger === "event") {
 				let events = [];
-				if (flow.options?.["scope"]) {
-					events = toArray(flow.options["scope"]).map((scope) => {
-						if ([
-							"items.create",
-							"items.update",
-							"items.delete"
-						].includes(scope)) {
-							if (!flow.options?.["collections"]) return [];
-							return toArray(flow.options["collections"]).map((collection) => {
-								if (isSystemCollection(collection)) {
-									const action = scope.split(".")[1];
-									return collection.substring(9) + "." + action;
-								}
-								return `${collection}.${scope}`;
-							});
-						}
-						return scope;
-					}).flat();
-				}
+				if (flow.options?.["scope"]) events = toArray(flow.options["scope"]).map((scope) => {
+					if ([
+						"items.create",
+						"items.update",
+						"items.delete"
+					].includes(scope)) {
+						if (!flow.options?.["collections"]) return [];
+						return toArray(flow.options["collections"]).map((collection) => {
+							if (isSystemCollection(collection)) {
+								const action = scope.split(".")[1];
+								return collection.substring(9) + "." + action;
+							}
+							return `${collection}.${scope}`;
+						});
+					}
+					return scope;
+				}).flat();
 				if (flow.options["type"] === "filter") {
 					const handler = (payload, meta, context) => this.executeFlow(flow, {
 						payload,
@@ -164,47 +155,40 @@ var FlowManager = class {
 						}))
 					});
 				}
-			} else if (flow.trigger === "schedule") {
-				if (validateCron(flow.options["cron"])) {
-					const job = scheduleSynchronizedJob(flow.id, flow.options["cron"], async () => {
-						try {
-							await this.executeFlow(flow);
-						} catch (error) {
-							logger.error(error);
-						}
-					});
-					this.triggerHandlers.push({
-						id: flow.id,
-						events: [{
-							type: flow.trigger,
-							job
-						}]
-					});
-				} else {
-					logger.warn(`Couldn't register cron trigger. Provided cron is invalid: ${flow.options["cron"]}`);
-				}
-			} else if (flow.trigger === "operation") {
+			} else if (flow.trigger === "schedule") if (validateCron(flow.options["cron"])) {
+				const job = scheduleSynchronizedJob(flow.id, flow.options["cron"], async () => {
+					try {
+						await this.executeFlow(flow);
+					} catch (error) {
+						logger.error(error);
+					}
+				});
+				this.triggerHandlers.push({
+					id: flow.id,
+					events: [{
+						type: flow.trigger,
+						job
+					}]
+				});
+			} else logger.warn(`Couldn't register cron trigger. Provided cron is invalid: ${flow.options["cron"]}`);
+			else if (flow.trigger === "operation") {
 				const handler = (data, context) => this.executeFlow(flow, data, context);
 				this.operationFlowHandlers[flow.id] = handler;
 			} else if (flow.trigger === "webhook") {
 				const method = flow.options?.["method"] ?? "GET";
 				const handler = async (data, context) => {
 					let cacheEnabled = true;
-					if (method === "GET") {
-						cacheEnabled = flow.options["cacheEnabled"] !== false;
-					}
+					if (method === "GET") cacheEnabled = flow.options["cacheEnabled"] !== false;
 					if (flow.options["async"]) {
 						this.executeFlow(flow, data, context);
 						return {
-							result: undefined,
-							cacheEnabled
-						};
-					} else {
-						return {
-							result: await this.executeFlow(flow, data, context),
+							result: void 0,
 							cacheEnabled
 						};
-					}
+					} else return {
+						result: await this.executeFlow(flow, data, context),
+						cacheEnabled
+					};
 				};
 				flow.options["return"] = flow.options["return"] ?? "$last";
 				this.webhookFlowHandlers[`${method}-${flow.id}`] = handler;
@@ -242,20 +226,18 @@ var FlowManager = class {
 					if (accountability.admin === false) {
 						const database = context["database"] ?? database_default();
 						const schema = context["schema"] ?? await getSchema({ database });
-						const policies = await fetchPolicies(accountability, {
-							schema,
-							knex: database
-						});
-						const permissions = await fetchPermissions({
-							policies,
+						if ((await fetchPermissions({
+							policies: await fetchPolicies(accountability, {
+								schema,
+								knex: database
+							}),
 							accountability,
 							action: "read",
 							collections: [targetCollection]
 						}, {
 							schema,
 							knex: database
-						});
-						if (permissions.length === 0) {
+						})).length === 0) {
 							logger.warn(`Triggering ${targetCollection} is not allowed`);
 							throw new ForbiddenError();
 						}
@@ -266,8 +248,7 @@ var FlowManager = class {
 								knex: database
 							});
 							const primaryField = schema.collections[targetCollection].primary;
-							const keys = await service.readMany(targetKeys, { fields: [primaryField] }, { emitEvents: false });
-							const allowedKeys = keys.map((key) => String(key[primaryField]));
+							const allowedKeys = (await service.readMany(targetKeys, { fields: [primaryField] }, { emitEvents: false })).map((key) => String(key[primaryField]));
 							if (targetKeys.some((key) => !allowedKeys.includes(String(key)))) {
 								logger.warn(`Triggering keys ${targetKeys} is not allowed`);
 								throw new ForbiddenError();
@@ -276,10 +257,8 @@ var FlowManager = class {
 					}
 					if (flow.options["async"]) {
 						this.executeFlow(flow, data, context);
-						return { result: undefined };
-					} else {
-						return { result: await this.executeFlow(flow, data, context) };
-					}
+						return { result: void 0 };
+					} else return { result: await this.executeFlow(flow, data, context) };
 				};
 				flow.options["return"] = "$last";
 				this.webhookFlowHandlers[`POST-${flow.id}`] = handler;
@@ -288,21 +267,18 @@ var FlowManager = class {
 		this.isLoaded = true;
 	}
 	async unload() {
-		for (const trigger of this.triggerHandlers) {
-			for (const event of trigger.events) {
-				switch (event.type) {
-					case "filter":
-						emitter_default.offFilter(event.name, event.handler);
-						break;
-					case "action":
-						emitter_default.offAction(event.name, event.handler);
-						break;
-					case "schedule":
-						await event.job.stop();
-						break;
-				}
-			}
+		for (const trigger of this.triggerHandlers) for (const event of trigger.events) switch (event.type) {
+			case "filter":
+				emitter_default.offFilter(event.name, event.handler);
+				break;
+			case "action":
+				emitter_default.offAction(event.name, event.handler);
+				break;
+			case "schedule":
+				await event.job.stop();
+				break;
 		}
+		this.flows = {};
 		this.triggerHandlers = [];
 		this.operationFlowHandlers = {};
 		this.webhookFlowHandlers = {};
@@ -349,103 +325,92 @@ var FlowManager = class {
 				origin: accountability?.origin ?? null,
 				item: flow.id
 			});
-			if (flow.accountability === "all") {
-				const revisionsService = new RevisionsService({
-					knex: database,
-					schema
-				});
-				await revisionsService.createOne({
-					activity,
-					collection: "directus_flows",
-					item: flow.id,
-					data: {
-						steps: steps.map((step) => redactObject(step, { values: this.envs }, getRedactedString)),
-						data: redactObject(keyedData, {
-							keys: [
-								[
-									"**",
-									"headers",
-									"authorization"
-								],
-								[
-									"**",
-									"headers",
-									"cookie"
-								],
-								[
-									"**",
-									"query",
-									"access_token"
-								],
-								[
-									"**",
-									"payload",
-									"password"
-								],
-								[
-									"**",
-									"payload",
-									"token"
-								],
-								[
-									"**",
-									"payload",
-									"tfa_secret"
-								],
-								[
-									"**",
-									"payload",
-									"external_identifier"
-								],
-								[
-									"**",
-									"payload",
-									"auth_data"
-								],
-								[
-									"**",
-									"payload",
-									"credentials"
-								],
-								[
-									"**",
-									"payload",
-									"ai_openai_api_key"
-								],
-								[
-									"**",
-									"payload",
-									"ai_anthropic_api_key"
-								],
-								[
-									"**",
-									"payload",
-									"ai_google_api_key"
-								],
-								[
-									"**",
-									"payload",
-									"ai_openai_compatible_api_key"
-								]
+			if (flow.accountability === "all") await new RevisionsService({
+				knex: database,
+				schema
+			}).createOne({
+				activity,
+				collection: "directus_flows",
+				item: flow.id,
+				data: {
+					steps: steps.map((step) => redactObject(step, { values: this.envs }, getRedactedString)),
+					data: redactObject(keyedData, {
+						keys: [
+							[
+								"**",
+								"headers",
+								"authorization"
 							],
-							values: this.envs
-						}, getRedactedString)
-					}
-				});
-			}
-		}
-		if ((flow.trigger === "manual" || flow.trigger === "webhook") && flow.options["async"] !== true && flow.options["error_on_reject"] === true && lastOperationStatus === "reject") {
-			throw keyedData[LAST_KEY];
-		}
-		if (flow.trigger === "event" && flow.options["type"] === "filter" && lastOperationStatus === "reject") {
-			throw keyedData[LAST_KEY];
-		}
-		if (flow.options["return"] === "$all") {
-			return keyedData;
-		} else if (flow.options["return"]) {
-			return get$1(keyedData, flow.options["return"]);
+							[
+								"**",
+								"headers",
+								"cookie"
+							],
+							[
+								"**",
+								"query",
+								"access_token"
+							],
+							[
+								"**",
+								"payload",
+								"password"
+							],
+							[
+								"**",
+								"payload",
+								"token"
+							],
+							[
+								"**",
+								"payload",
+								"tfa_secret"
+							],
+							[
+								"**",
+								"payload",
+								"external_identifier"
+							],
+							[
+								"**",
+								"payload",
+								"auth_data"
+							],
+							[
+								"**",
+								"payload",
+								"credentials"
+							],
+							[
+								"**",
+								"payload",
+								"ai_openai_api_key"
+							],
+							[
+								"**",
+								"payload",
+								"ai_anthropic_api_key"
+							],
+							[
+								"**",
+								"payload",
+								"ai_google_api_key"
+							],
+							[
+								"**",
+								"payload",
+								"ai_openai_compatible_api_key"
+							]
+						],
+						values: this.envs
+					}, getRedactedString)
+				}
+			});
 		}
-		return undefined;
+		if ((flow.trigger === "manual" || flow.trigger === "webhook") && flow.options["async"] !== true && flow.options["error_on_reject"] === true && lastOperationStatus === "reject") throw keyedData[LAST_KEY];
+		if (flow.trigger === "event" && flow.options["type"] === "filter" && lastOperationStatus === "reject") throw keyedData[LAST_KEY];
+		if (flow.options["return"] === "$all") return keyedData;
+		else if (flow.options["return"]) return get$1(keyedData, flow.options["return"]);
 	}
 	async executeOperation(operation, keyedData, context = {}) {
 		const logger = useLogger();
@@ -460,75 +425,73 @@ var FlowManager = class {
 		}
 		const handler = this.operations.get(operation.type);
 		let optionData = keyedData;
-		if (operation.type === "log") {
-			optionData = redactObject(keyedData, { keys: [
-				[
-					"**",
-					"headers",
-					"authorization"
-				],
-				[
-					"**",
-					"headers",
-					"cookie"
-				],
-				[
-					"**",
-					"query",
-					"access_token"
-				],
-				[
-					"**",
-					"payload",
-					"password"
-				],
-				[
-					"**",
-					"payload",
-					"token"
-				],
-				[
-					"**",
-					"payload",
-					"tfa_secret"
-				],
-				[
-					"**",
-					"payload",
-					"external_identifier"
-				],
-				[
-					"**",
-					"payload",
-					"auth_data"
-				],
-				[
-					"**",
-					"payload",
-					"credentials"
-				],
-				[
-					"**",
-					"payload",
-					"ai_openai_api_key"
-				],
-				[
-					"**",
-					"payload",
-					"ai_anthropic_api_key"
-				],
-				[
-					"**",
-					"payload",
-					"ai_google_api_key"
-				],
-				[
-					"**",
-					"payload",
-					"ai_openai_compatible_api_key"
-				]
-			] }, getRedactedString);
-		}
+		if (operation.type === "log") optionData = redactObject(keyedData, { keys: [
+			[
+				"**",
+				"headers",
+				"authorization"
+			],
+			[
+				"**",
+				"headers",
+				"cookie"
+			],
+			[
+				"**",
+				"query",
+				"access_token"
+			],
+			[
+				"**",
+				"payload",
+				"password"
+			],
+			[
+				"**",
+				"payload",
+				"token"
+			],
+			[
+				"**",
+				"payload",
+				"tfa_secret"
+			],
+			[
+				"**",
+				"payload",
+				"external_identifier"
+			],
+			[
+				"**",
+				"payload",
+				"auth_data"
+			],
+			[
+				"**",
+				"payload",
+				"credentials"
+			],
+			[
+				"**",
+				"payload",
+				"ai_openai_api_key"
+			],
+			[
+				"**",
+				"payload",
+				"ai_anthropic_api_key"
+			],
+			[
+				"**",
+				"payload",
+				"ai_google_api_key"
+			],
+			[
+				"**",
+				"payload",
+				"ai_openai_compatible_api_key"
+			]
+		] }, getRedactedString);
 		let options = operation.options;
 		try {
 			options = applyOptionsData(options, optionData);
@@ -543,9 +506,7 @@ var FlowManager = class {
 				...context
 			});
 			JSON.stringify(result ?? null);
-			if (typeof result === "object" && result !== null) {
-				result = deepMap(result, (value) => value === undefined ? null : value);
-			}
+			if (typeof result === "object" && result !== null) result = deepMap(result, (value) => value === void 0 ? null : value);
 			return {
 				successor: operation.resolve,
 				status: "resolve",
@@ -557,11 +518,8 @@ var FlowManager = class {
 			if (error instanceof Error) {
 				delete error.stack;
 				data = error;
-			} else if (typeof error === "string") {
-				data = isValidJSON(error) ? parseJSON(error) : error;
-			} else {
-				data = error ?? null;
-			}
+			} else if (typeof error === "string") data = isValidJSON(error) ? parseJSON(error) : error;
+			else data = error ?? null;
 			return {
 				successor: operation.reject,
 				status: "reject",

package/dist/lock/lib/use-lock.js

@@ -5,14 +5,12 @@ import { useEnv } from "@directus/env";
 import { createKv } from "@directus/memory";
 
 //#region src/lock/lib/use-lock.ts
-const _cache = { lock: undefined };
+const _cache = { lock: void 0 };
 /**
 * Returns globally shared lock kv instance.
 */
 const useLock = () => {
-	if (_cache.lock) {
-		return _cache.lock;
-	}
+	if (_cache.lock) return _cache.lock;
 	if (redisConfigAvailable()) {
 		const env = useEnv();
 		_cache.lock = createKv({
@@ -20,9 +18,7 @@ const useLock = () => {
 			redis: useRedis(),
 			namespace: env["REDIS_LOCK_NAMESPACE"] ?? "directus:lock"
 		});
-	} else {
-		_cache.lock = createKv({ type: "local" });
-	}
+	} else _cache.lock = createKv({ type: "local" });
 	return _cache.lock;
 };