@headless-lms/core 0.2.0 → 0.3.0

package/dist/automations/service.js

@@ -1,11 +1,13 @@
 import { deliverWebhookInputSchema } from "../types/schemas/automations.js";
-import { noopLogger } from "../shared/logger.js";
 import { ConflictError, NotFoundError } from "../shared/errors.js";
-import { DELIVER_WEBHOOK_ACTION, catalogActions, catalogTriggers } from "./catalog.js";
+import { noopLogger } from "../shared/logger.js";
+import { ActionFailedError, AutomationKindMismatchError, InvalidTriggerError, ReservedActionError } from "./model.js";
+import { DELIVER_WEBHOOK_ACTION, catalogActions, catalogTriggers, publicDataSchema } from "./catalog.js";
 import { generateWebhookSecret } from "./webhook-signing.js";
 import { executeAction } from "./actions.js";
 import { automationEvents } from "./events.js";
-import { AutomationKindMismatchError, InvalidTriggerError, ReservedActionError } from "./model.js";
+import { communitySeeds, orgSeeds } from "./seeds.js";
+import { cronSupported } from "./schedule.js";
 //#region src/automations/service.ts
 /** True only when `input` sets `enabled` and nothing else — emits automation.enabled|disabled instead of automation.updated. */
 function isEnabledOnlyUpdate(input) {
@@ -13,15 +15,79 @@ function isEnabledOnlyUpdate(input) {
 	const { enabled: _enabled, ...rest } = input;
 	return Object.values(rest).every((v) => v === void 0);
 }
+function floorMinute(at) {
+	const copy = new Date(at);
+	copy.setUTCSeconds(0, 0);
+	return copy.getTime();
+}
 function unique(values) {
 	return [...new Set(values)];
 }
+function recordString(value, key) {
+	if (typeof value !== "object" || value === null || !(key in value)) return null;
+	const found = value[key];
+	return typeof found === "string" ? found : null;
+}
+function filterMatches(filter, data) {
+	if (filter == null) return true;
+	if (typeof data !== "object" || data === null || Array.isArray(data)) return false;
+	const record = data;
+	return Object.entries(filter).every(([key, expected]) => {
+		if (!Object.prototype.hasOwnProperty.call(record, key)) return false;
+		return JSON.stringify(record[key]) === JSON.stringify(expected);
+	});
+}
 function assertAuthorableTriggers(triggers) {
-	for (const trigger of triggers) if (trigger.startsWith("automation.")) throw new InvalidTriggerError(trigger);
+	for (const trigger of triggers) {
+		if (trigger.startsWith("automation.")) throw new InvalidTriggerError(trigger);
+		if (trigger.startsWith("schedule:") && !cronSupported(trigger.slice(9))) throw new InvalidTriggerError(trigger, "schedule");
+	}
+}
+function assertCatalogTriggers(triggers, schedules) {
+	assertAuthorableTriggers(triggers);
+	const known = new Set(catalogTriggers().map((t) => t.type));
+	for (const trigger of triggers) if (!(schedules && trigger.startsWith("schedule:")) && !known.has(trigger)) throw new InvalidTriggerError(trigger, "unknown");
 }
 function assertAuthorableActions(actions) {
 	for (const action of actions) if (action.type === "deliverWebhook") throw new ReservedActionError(action.type);
 }
+const SCHEDULE_FIRED = "automation.schedule.fired";
+function publicEventData(event) {
+	const parsed = event.type === SCHEDULE_FIRED ? {
+		success: true,
+		data: event.data
+	} : publicDataSchema(event.type)?.safeParse(event.data);
+	return parsed?.success ? JSON.parse(JSON.stringify(parsed.data)) : null;
+}
+/** A run as callers see it: its event carries only what a webhook of that event would. */
+function toRunView(run) {
+	const { type, version, id, orgId, occurredAt } = run.event;
+	return {
+		...run,
+		event: {
+			type,
+			version,
+			id,
+			orgId,
+			occurredAt,
+			data: publicEventData(run.event)
+		}
+	};
+}
+/** An automation as callers see it: a webhook's credential reference stays internal. */
+function toAutomationView(automation) {
+	return {
+		...automation,
+		actions: automation.actions.map((action) => {
+			if (action.type !== "deliverWebhook") return action;
+			const { secretRef: _secretRef, ...input } = action.input;
+			return {
+				...action,
+				input
+			};
+		})
+	};
+}
 function webhookTarget(automation) {
 	return deliverWebhookInputSchema.parse(automation.actions[0]?.input);
 }
@@ -60,6 +126,10 @@ var AutomationsServiceImpl = class {
 	integrations;
 	credentials;
 	webhooks;
+	mail;
+	grants;
+	desk;
+	scheduledWork;
 	logger;
 	constructor(params) {
 		this.repo = params.repo;
@@ -71,12 +141,85 @@ var AutomationsServiceImpl = class {
 		this.integrations = params.integrations;
 		this.credentials = params.credentials;
 		this.webhooks = params.webhooks;
+		this.mail = {
+			...params.mail,
+			recentMessageRecipients: (orgId, automationId, chatId, since) => this.runsRepo.recentRecipients(orgId, automationId, chatId, since)
+		};
+		this.grants = params.grants;
+		this.desk = params.desk;
+		this.scheduledWork = params.scheduledWork;
 		this.logger = params.logger ?? noopLogger;
 	}
 	async handle(event) {
 		if (event.type.startsWith("automation.")) return;
+		await this.seedFor(event);
 		const automations = await this.safeListByTrigger(event);
-		for (const automation of automations.filter((a) => a.enabled)) await this.dispatchOne(automation, event);
+		for (const automation of automations) {
+			const matches = filterMatches(automation.filter, event.data);
+			if (!automation.enabled || !matches) {
+				if (automation.enabled && !matches) this.logger.debug("automation filter skipped", {
+					orgId: event.orgId,
+					automationId: automation.id,
+					trigger: event.type
+				});
+				continue;
+			}
+			await this.dispatchOne(automation, event);
+		}
+	}
+	seedsFor(event) {
+		if (event.type === "organization.created") return orgSeeds();
+		if (event.type !== "content.community.created") return null;
+		const communityId = recordString(event.data, "id");
+		if (!communityId) {
+			this.logger.error("community seed missing id", {
+				orgId: event.orgId,
+				eventId: event.id
+			});
+			return null;
+		}
+		return communitySeeds(communityId);
+	}
+	async seedFor(event) {
+		const rows = this.seedsFor(event);
+		if (!rows) return;
+		if (await this.uow.run(async ({ automations, outbox }) => {
+			const created = [];
+			for (const row of rows) {
+				const inserted = await automations.insertSeed(event.orgId, {
+					name: row.name,
+					description: row.description,
+					triggers: row.triggers,
+					actions: row.actions,
+					filter: row.filter,
+					kind: "workflow",
+					source: "system"
+				});
+				if (inserted) created.push(automationEvents.automationCreated.make({
+					orgId: event.orgId,
+					data: inserted
+				}));
+			}
+			if (created.length > 0) {
+				await outbox.append(created);
+				this.logger.info("system automations seeded", {
+					orgId: event.orgId,
+					trigger: event.type,
+					count: created.length
+				});
+			}
+			return created.length;
+		}) > 0) await this.reconcileSchedules(event.orgId);
+	}
+	async reconcileSchedules(orgId) {
+		try {
+			await this.engine.syncSchedules?.();
+		} catch (err) {
+			this.logger.error("automation schedules not reconciled", {
+				orgId,
+				err
+			});
+		}
 	}
 	async safeListByTrigger(event) {
 		try {
@@ -85,7 +228,7 @@ var AutomationsServiceImpl = class {
 			this.logger.error("automations: failed to load trigger matches", {
 				orgId: event.orgId,
 				trigger: event.type,
-				error: err instanceof Error ? err.message : String(err)
+				err
 			});
 			return [];
 		}
@@ -97,14 +240,15 @@ var AutomationsServiceImpl = class {
 			if (!run) return;
 			await this.engine.dispatch(this.dispatchFor(automation, run, event));
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
 			this.logger.error("automation run failed", {
 				orgId: event.orgId,
 				automationId: automation.id,
 				runId: run?.id,
-				error: message
+				trigger: event.type,
+				eventId: event.id,
+				err
 			});
-			if (run) await this.recordFailure(run, message);
+			if (run) await this.recordFailure(run, err instanceof Error ? err.message : String(err));
 		}
 	}
 	openRun(automation, event) {
@@ -157,8 +301,9 @@ var AutomationsServiceImpl = class {
 		} catch (err) {
 			this.logger.error("failed to record automation run failure", {
 				orgId: run.orgId,
+				automationId: run.automationId,
 				runId: run.id,
-				error: err instanceof Error ? err.message : String(err),
+				err,
 				originalError: error
 			});
 			return null;
@@ -167,17 +312,97 @@ var AutomationsServiceImpl = class {
 	async runAction(d, index) {
 		const action = d.actions[index];
 		if (!action) throw new Error(`automation ${d.automationId} run ${d.runId}: no action at index ${index}`);
-		await executeAction(action, d.event, {
-			mailer: this.mailer,
-			lookups: this.lookups,
-			credentials: this.credentials,
-			webhooks: this.webhooks
+		let outcome;
+		try {
+			outcome = await executeAction(action, d.event, {
+				mailer: this.mailer,
+				lookups: this.lookups,
+				credentials: this.credentials,
+				webhooks: this.webhooks,
+				mail: this.mail,
+				grants: this.grants,
+				desk: this.desk,
+				scheduledWork: this.scheduledWork,
+				automationId: d.automationId,
+				actionInput: action.input,
+				logger: this.logger
+			});
+		} catch (err) {
+			this.logger.error("automation action failed", {
+				orgId: d.orgId,
+				automationId: d.automationId,
+				runId: d.runId,
+				trigger: d.event.type,
+				index,
+				type: action.type,
+				err
+			});
+			throw err instanceof ActionFailedError ? err : new ActionFailedError();
+		}
+		const { recipients, failed } = outcome;
+		this.logger.info("automation action completed", {
+			orgId: d.orgId,
+			automationId: d.automationId,
+			runId: d.runId,
+			type: action.type,
+			recipients: recipients.length,
+			failed: failed.length
 		});
 		return {
 			index,
 			type: action.type,
-			status: "completed"
+			status: "completed",
+			...recipients.length > 0 ? { recipients } : {},
+			...failed.length > 0 ? { error: `delivery failed for ${failed.length} recipients: ${failed.join(", ")}` } : {}
+		};
+	}
+	async listSchedules() {
+		return this.repo.listSchedules();
+	}
+	async fireSchedule(orgId, automationId, at) {
+		const firedAt = new Date(floorMinute(at));
+		const automation = await this.repo.findById(orgId, automationId);
+		if (!automation?.enabled || firedAt.getTime() < floorMinute(automation.createdAt)) {
+			this.logger.debug("schedule skipped", {
+				orgId,
+				automationId
+			});
+			return;
+		}
+		if (!await this.scheduleHasWork(orgId, automation, firedAt)) {
+			this.logger.debug("schedule idle", {
+				orgId,
+				automationId
+			});
+			return;
+		}
+		const event = {
+			type: SCHEDULE_FIRED,
+			id: `schedule_${automationId}_${firedAt.toISOString()}`,
+			orgId,
+			version: 1,
+			occurredAt: firedAt.toISOString(),
+			data: {
+				automationId,
+				firedAt: firedAt.toISOString()
+			}
 		};
+		await this.dispatchOne(automation, event);
+	}
+	async scheduleHasWork(orgId, automation, firedAt) {
+		const checks = automation.actions.map((action) => this.pendingWork(action.type));
+		const known = checks.filter((check) => check !== null);
+		if (checks.length === 0 || known.length < checks.length) return true;
+		for (const check of known) if (await check(orgId, firedAt)) return true;
+		return false;
+	}
+	pendingWork(type) {
+		switch (type) {
+			case "publishDuePosts": return (orgId, now) => this.scheduledWork.hasDuePosts(orgId, now);
+			case "expireDueGrants": return (orgId, now) => this.scheduledWork.hasDueGrants(orgId, now);
+			case "removeUnattachedUploads": return (orgId, now) => this.scheduledWork.hasUnattachedUploads(orgId, now);
+			default: return null;
+		}
 	}
 	async finalize(d, results) {
 		const status = results.length === d.actions.length && results.every((r) => r.status === "completed") ? "completed" : "failed";
@@ -201,9 +426,39 @@ var AutomationsServiceImpl = class {
 			}) }));
 			await outbox.append([runEvent, ...actionFailedEvents]);
 		});
+		this.logOutcome(d, status, results);
+	}
+	logOutcome(d, status, results) {
+		const run = {
+			orgId: d.orgId,
+			automationId: d.automationId,
+			runId: d.runId,
+			trigger: d.event.type,
+			eventId: d.event.id
+		};
+		if (status === "failed") {
+			const failed = results.find((r) => r.status === "failed");
+			const index = failed?.index ?? results.length;
+			this.logger.error("automation run failed", {
+				...run,
+				index,
+				action: failed?.type ?? d.actions[index]?.type,
+				error: failed?.error ?? "not every action ran"
+			});
+			return;
+		}
+		const partial = results.filter((r) => r.error !== void 0);
+		if (partial.length > 0) this.logger.warn("automation run completed with failed deliveries", {
+			...run,
+			actions: partial.map(({ index, type, error }) => ({
+				index,
+				type,
+				error
+			}))
+		});
 	}
 	async create(orgId, input) {
-		assertAuthorableTriggers(input.triggers);
+		assertCatalogTriggers(input.triggers, true);
 		assertAuthorableActions(input.actions);
 		const automation = await this.uow.run(async ({ automations, outbox }) => {
 			const created = await automations.insert(orgId, {
@@ -221,10 +476,11 @@ var AutomationsServiceImpl = class {
 			orgId,
 			automationId: automation.id
 		});
+		await this.reconcileSchedules(orgId);
 		return automation;
 	}
 	async update(orgId, id, input) {
-		if (input.triggers !== void 0) assertAuthorableTriggers(input.triggers);
+		if (input.triggers !== void 0) assertCatalogTriggers(input.triggers, true);
 		if (input.actions !== void 0) assertAuthorableActions(input.actions);
 		const existing = await this.repo.findById(orgId, id);
 		if (!existing) return null;
@@ -239,16 +495,20 @@ var AutomationsServiceImpl = class {
 			await outbox.append([updateEvent(orgId, input, updated)]);
 			return updated;
 		});
-		if (automation) this.logger.info("automation updated", {
-			orgId,
-			automationId: id
-		});
+		if (automation) {
+			this.logger.info("automation updated", {
+				orgId,
+				automationId: id
+			});
+			await this.reconcileSchedules(orgId);
+		}
 		return automation;
 	}
 	async delete(orgId, id) {
 		const existing = await this.repo.findById(orgId, id);
 		if (!existing) return false;
 		if (existing.kind !== "workflow") throw new AutomationKindMismatchError(id, existing.kind);
+		if (existing.source === "system") throw new ConflictError("A system automation cannot be deleted");
 		const deleted = await this.uow.run(async ({ automations, outbox }) => {
 			const removed = await automations.delete(orgId, id);
 			if (!removed) return null;
@@ -258,20 +518,28 @@ var AutomationsServiceImpl = class {
 			})]);
 			return removed;
 		});
-		if (deleted) this.logger.info("automation deleted", {
-			orgId,
-			automationId: id
-		});
+		if (deleted) {
+			this.logger.info("automation deleted", {
+				orgId,
+				automationId: id
+			});
+			await this.reconcileSchedules(orgId);
+		}
 		return deleted !== null;
 	}
-	list(orgId, query) {
-		return this.repo.listByOrg(orgId, query?.kind);
+	async list(orgId, query) {
+		return (await this.repo.listByOrg(orgId, query?.kind)).map(toAutomationView);
 	}
-	get(orgId, id) {
-		return this.repo.findById(orgId, id);
+	async get(orgId, id) {
+		const automation = await this.repo.findById(orgId, id);
+		return automation ? toAutomationView(automation) : null;
 	}
-	listRuns(orgId, automationId, query) {
-		return this.runsRepo.list(orgId, automationId, query);
+	async listRuns(orgId, automationId, query) {
+		const page = await this.runsRepo.list(orgId, automationId, query);
+		return {
+			...page,
+			rows: page.rows.map(toRunView)
+		};
 	}
 	async rerun(orgId, automationId, runId) {
 		const existing = await this.runsRepo.findById(orgId, runId);
@@ -291,21 +559,21 @@ var AutomationsServiceImpl = class {
 		try {
 			await this.engine.dispatch(this.dispatchFor(automation, run, run.event));
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
 			this.logger.error("automation rerun failed", {
 				orgId,
 				automationId,
 				runId: run.id,
-				error: message
+				trigger: run.trigger,
+				err
 			});
-			return await this.recordFailure(run, message) ?? run;
+			return toRunView(await this.recordFailure(run, err instanceof Error ? err.message : String(err)) ?? run);
 		}
 		this.logger.info("automation rerun started", {
 			orgId,
 			automationId,
 			runId: run.id
 		});
-		return run;
+		return toRunView(run);
 	}
 	async listWebhooks(orgId) {
 		return (await this.repo.listByOrg(orgId, "webhook")).map(toWebhook);
@@ -316,7 +584,7 @@ var AutomationsServiceImpl = class {
 	}
 	async createWebhook(orgId, input) {
 		const events = unique(input.events);
-		this.assertSubscribableEvents(events);
+		assertCatalogTriggers(events, false);
 		const secret = generateWebhookSecret();
 		const automation = await this.uow.run(async ({ automations, credentials, outbox }) => {
 			const secretRef = await credentials.store(orgId, { secret });
@@ -352,7 +620,7 @@ var AutomationsServiceImpl = class {
 		const existing = await this.findWebhook(orgId, id);
 		if (!existing) return null;
 		const events = input.events === void 0 ? void 0 : unique(input.events);
-		if (events) this.assertSubscribableEvents(events);
+		if (events) assertCatalogTriggers(events, false);
 		const { secretRef } = webhookTarget(existing);
 		const patch = {
 			name: input.url,
@@ -422,11 +690,6 @@ var AutomationsServiceImpl = class {
 		const automation = await this.repo.findById(orgId, id);
 		return automation?.kind === "webhook" ? automation : null;
 	}
-	assertSubscribableEvents(events) {
-		assertAuthorableTriggers(events);
-		const known = new Set(catalogTriggers().map((t) => t.type));
-		for (const event of events) if (!known.has(event)) throw new InvalidTriggerError(event, "unknown");
-	}
 	availableActions() {
 		return [...catalogActions(), ...this.integrations.available().flatMap((integration) => integration.actions.map((action) => ({
 			type: `${integration.id}.${action.id}`,