@flowdular/sdk 0.1.0

package/modules/automations/src/api/endpoints.ts

@@ -0,0 +1,480 @@
+import {
+	defineEndpoint,
+	jsonResponse,
+	problemResponse,
+	readJsonObject,
+	requiredString,
+} from '@flowdular/sdk/server';
+import type { AuthRuntime } from '@flowdular/sdk/modules/auth/server';
+import {
+	endpointIdentityFromContext,
+	principalFromContext,
+	sessionMutationDenial,
+} from '@flowdular/sdk/modules/auth/server';
+import { userActor } from '@flowdular/sdk/kernel';
+import { AUTOMATIONS_PERMISSIONS } from '../acl/permissions.ts';
+import type { CreateAutomationScheduleInput } from '../domain/types.ts';
+import { scheduleVariablesForScopes } from '../domain/variables.ts';
+import type { AutomationsRuntime } from '../server/runtime.ts';
+import { AutomationsServiceError } from '../services/automations-service.ts';
+import {
+	MAX_TRIGGER_BODY_BYTES,
+	TRIGGER_SIGNATURE_HEADER,
+	TRIGGER_TIMESTAMP_HEADER,
+	TriggerRejectedError,
+} from '../services/trigger-service.ts';
+
+function requiredBoolean(value: Record<string, unknown>, key: string): boolean {
+	if (typeof value[key] !== 'boolean') {
+		throw new AutomationsServiceError(
+			'INVALID_INPUT',
+			`${key} must be a boolean.`,
+		);
+	}
+	return value[key];
+}
+
+function failure(error: unknown): Response {
+	if (error instanceof AutomationsServiceError) {
+		return jsonResponse(
+			{ error: { code: error.code, message: error.message } },
+			error.status,
+		);
+	}
+	return problemResponse(error, 'The automations operation failed.');
+}
+
+function scheduleInput(
+	value: Record<string, unknown>,
+): CreateAutomationScheduleInput {
+	const targetKind =
+		typeof value.targetKind === 'string'
+			? requiredString(value, 'targetKind', { min: 2, max: 64 })
+			: undefined;
+	const targetKey =
+		typeof value.targetKey === 'string'
+			? requiredString(value, 'targetKey', { max: 128 })
+			: undefined;
+	const agentId =
+		typeof value.agentId === 'string'
+			? requiredString(value, 'agentId', { max: 128 })
+			: undefined;
+	return {
+		...(targetKind ? { targetKind } : {}),
+		...(targetKey ? { targetKey } : {}),
+		...(agentId ? { agentId } : {}),
+		label: requiredString(value, 'label', { min: 2, max: 120 }),
+		inputTemplate: requiredString(value, 'inputTemplate', {
+			min: 1,
+			max: 10_000,
+		}),
+		cadence: requiredString(value, 'cadence', { min: 7, max: 32 }),
+		enabled: requiredBoolean(value, 'enabled'),
+	};
+}
+
+function targetInput(value: Record<string, unknown>) {
+	const targetKind =
+		typeof value.targetKind === 'string'
+			? requiredString(value, 'targetKind', { min: 2, max: 64 })
+			: undefined;
+	const targetKey =
+		typeof value.targetKey === 'string'
+			? requiredString(value, 'targetKey', { max: 128 })
+			: undefined;
+	const agentId =
+		typeof value.agentId === 'string'
+			? requiredString(value, 'agentId', { max: 128 })
+			: undefined;
+	return {
+		...(targetKind ? { targetKind } : {}),
+		...(targetKey ? { targetKey } : {}),
+		...(agentId ? { agentId } : {}),
+	};
+}
+
+function optionalTargetInput(value: Record<string, unknown>) {
+	const target = targetInput(value);
+	return Object.keys(target).length === 0 ? undefined : target;
+}
+
+function triggerRejection(): Response {
+	return jsonResponse(
+		{
+			error: {
+				code: 'TRIGGER_REJECTED',
+				message: 'The trigger request was rejected.',
+			},
+		},
+		403,
+	);
+}
+
+export function createAutomationsRoutes(
+	auth: AuthRuntime,
+	runtime: AutomationsRuntime,
+) {
+	const listSchedules = defineEndpoint({
+		id: 'automations.schedules.list',
+		path: '/api/automations/schedules',
+		methods: ['GET'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.read },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const principal = principalFromContext(octane)!;
+			return jsonResponse({
+				schedules: await (
+					await runtime.scheduleService()
+				).list(principal.tenantId),
+				variables: scheduleVariablesForScopes(principal.scopes),
+				agents: await (
+					await runtime.scheduleService()
+				).agents(principal.tenantId),
+				targets: await (
+					await runtime.scheduleService()
+				).targetOptions(
+					principal.tenantId,
+					userActor(principal),
+					principal.scopes,
+				),
+			});
+		},
+	});
+	const createSchedule = defineEndpoint({
+		id: 'automations.schedules.create',
+		path: '/api/automations/schedules',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 32 * 1_024);
+				const principal = principalFromContext(octane)!;
+				return jsonResponse(
+					{
+						schedule: await (
+							await runtime.scheduleService()
+						).create(
+							principal.tenantId,
+							userActor(principal),
+							scheduleInput(value),
+							principal.scopes,
+						),
+					},
+					201,
+				);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const updateSchedule = defineEndpoint({
+		id: 'automations.schedules.update',
+		path: '/api/automations/schedules/update',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 32 * 1_024);
+				const principal = principalFromContext(octane)!;
+				return jsonResponse({
+					schedule: await (
+						await runtime.scheduleService()
+					).update(
+						principal.tenantId,
+						userActor(principal),
+						{
+							...scheduleInput(value),
+							id: requiredString(value, 'id', { max: 128 }),
+						},
+						principal.scopes,
+					),
+				});
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const deleteSchedule = defineEndpoint({
+		id: 'automations.schedules.delete',
+		path: '/api/automations/schedules/delete',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 4 * 1_024);
+				const principal = principalFromContext(octane)!;
+				await (
+					await runtime.scheduleService()
+				).delete(
+					principal.tenantId,
+					principal.accountId,
+					requiredString(value, 'id', { max: 128 }),
+				);
+				return jsonResponse({ deleted: true });
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const runSchedule = defineEndpoint({
+		id: 'automations.schedules.run',
+		path: '/api/automations/schedules/run',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 4 * 1_024);
+				const principal = principalFromContext(octane)!;
+				const accepted = await (
+					await runtime.scheduleService()
+				).runNow(
+					principal.tenantId,
+					userActor(principal),
+					requiredString(value, 'id', { max: 128 }),
+					principal.scopes,
+				);
+				return jsonResponse({ run: { id: accepted.id } }, 202);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const listTriggers = defineEndpoint({
+		id: 'automations.triggers.list',
+		path: '/api/automations/triggers',
+		methods: ['GET'],
+		access: {
+			kind: 'permission',
+			permission: AUTOMATIONS_PERMISSIONS.triggersRead,
+		},
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const principal = principalFromContext(octane)!;
+			return jsonResponse({
+				triggers: await (
+					await runtime.triggerService()
+				).list(principal.tenantId),
+				agents: await (
+					await runtime.scheduleService()
+				).agents(principal.tenantId),
+				targets: await (
+					await runtime.scheduleService()
+				).targetOptions(
+					principal.tenantId,
+					userActor(principal),
+					principal.scopes,
+				),
+			});
+		},
+	});
+	const createTrigger = defineEndpoint({
+		id: 'automations.triggers.create',
+		path: '/api/automations/triggers',
+		methods: ['POST'],
+		access: {
+			kind: 'permission',
+			permission: AUTOMATIONS_PERMISSIONS.triggersManage,
+		},
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 8 * 1_024);
+				const principal = principalFromContext(octane)!;
+				return jsonResponse(
+					await (
+						await runtime.triggerService()
+					).create(
+						principal.tenantId,
+						userActor(principal),
+						{
+							...targetInput(value),
+							label: requiredString(value, 'label', { min: 2, max: 120 }),
+							enabled: requiredBoolean(value, 'enabled'),
+						},
+						principal.scopes,
+					),
+					201,
+				);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const updateTrigger = defineEndpoint({
+		id: 'automations.triggers.update',
+		path: '/api/automations/triggers/update',
+		methods: ['POST'],
+		access: {
+			kind: 'permission',
+			permission: AUTOMATIONS_PERMISSIONS.triggersManage,
+		},
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 8 * 1_024);
+				const principal = principalFromContext(octane)!;
+				return jsonResponse({
+					trigger: await (
+						await runtime.triggerService()
+					).update(
+						principal.tenantId,
+						userActor(principal),
+						requiredString(value, 'id', { max: 128 }),
+						requiredString(value, 'label', { min: 2, max: 120 }),
+						requiredBoolean(value, 'enabled'),
+						principal.scopes,
+						optionalTargetInput(value),
+					),
+				});
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const rotateTrigger = defineEndpoint({
+		id: 'automations.triggers.rotate',
+		path: '/api/automations/triggers/rotate',
+		methods: ['POST'],
+		access: {
+			kind: 'permission',
+			permission: AUTOMATIONS_PERMISSIONS.triggersManage,
+		},
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 4 * 1_024);
+				const principal = principalFromContext(octane)!;
+				return jsonResponse(
+					await (
+						await runtime.triggerService()
+					).rotate(
+						principal.tenantId,
+						principal.accountId,
+						requiredString(value, 'id', { max: 128 }),
+					),
+				);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const deleteTrigger = defineEndpoint({
+		id: 'automations.triggers.delete',
+		path: '/api/automations/triggers/delete',
+		methods: ['POST'],
+		access: {
+			kind: 'permission',
+			permission: AUTOMATIONS_PERMISSIONS.triggersManage,
+		},
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const value = await readJsonObject(octane.request, 4 * 1_024);
+				const principal = principalFromContext(octane)!;
+				await (
+					await runtime.triggerService()
+				).delete(
+					principal.tenantId,
+					principal.accountId,
+					requiredString(value, 'id', { max: 128 }),
+				);
+				return jsonResponse({ deleted: true });
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const fireTrigger = defineEndpoint({
+		id: 'automations.triggers.fire',
+		path: '/api/automations/triggers/:id/fire',
+		methods: ['POST'],
+		/* A signed webhook has no browser session. HMAC and freshness are its
+		   authentication boundary, so CSRF does not apply. */
+		access: { kind: 'public' },
+		handler: async ({ octane }) => {
+			try {
+				const declared = Number(
+					octane.request.headers.get('content-length') ?? 0,
+				);
+				if (Number.isFinite(declared) && declared > MAX_TRIGGER_BODY_BYTES) {
+					return triggerRejection();
+				}
+				const run = await (
+					await runtime.triggerService()
+				).fire({
+					triggerId: octane.params.id ?? '',
+					body: await octane.request.text(),
+					signature: octane.request.headers.get(TRIGGER_SIGNATURE_HEADER),
+					timestamp: octane.request.headers.get(TRIGGER_TIMESTAMP_HEADER),
+				});
+				return jsonResponse({ accepted: true, runId: run.id }, 202);
+			} catch (error) {
+				if (error instanceof TriggerRejectedError) return triggerRejection();
+				return failure(error);
+			}
+		},
+	});
+	const listAudit = defineEndpoint({
+		id: 'automations.audit.list',
+		path: '/api/automations/audit',
+		methods: ['GET'],
+		access: { kind: 'permission', permission: AUTOMATIONS_PERMISSIONS.read },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const principal = principalFromContext(octane)!;
+			return jsonResponse({
+				events: await runtime.listAuditEvents(principal.tenantId, 100),
+				integrity: await runtime.verifyAudit(principal.tenantId),
+			});
+		},
+	});
+	return [
+		listSchedules.serverRoute,
+		createSchedule.serverRoute,
+		updateSchedule.serverRoute,
+		deleteSchedule.serverRoute,
+		runSchedule.serverRoute,
+		listTriggers.serverRoute,
+		createTrigger.serverRoute,
+		updateTrigger.serverRoute,
+		rotateTrigger.serverRoute,
+		deleteTrigger.serverRoute,
+		fireTrigger.serverRoute,
+		listAudit.serverRoute,
+	] as const;
+}
+
+export const endpoints = [
+	'automations.schedules.list',
+	'automations.schedules.create',
+	'automations.schedules.update',
+	'automations.schedules.delete',
+	'automations.schedules.run',
+	'automations.triggers.list',
+	'automations.triggers.create',
+	'automations.triggers.update',
+	'automations.triggers.rotate',
+	'automations.triggers.delete',
+	'automations.triggers.fire',
+	'automations.audit.list',
+] as const;

package/modules/automations/src/client/AutomationScheduleForm.tsrx

@@ -0,0 +1,218 @@
+import { useMemo } from 'octane';
+import { useTranslation } from '@flowdular/sdk/client';
+import { Button, FormField, VariableTextarea } from '@flowdular/sdk/ui';
+import type { VariableDefinition } from '@flowdular/sdk/contracts';
+import { createStore, useValue } from 'segment-state';
+import { cadenceMinutes } from '../domain/cadence.ts';
+import type {
+	AutomationSchedule,
+	AutomationTargetOption,
+	CreateAutomationScheduleInput,
+} from '../domain/types.ts';
+import {
+	automationTargetOptions,
+	automationTargetValue,
+	parseAutomationTargetValue,
+} from './target-selection.ts';
+
+export interface AutomationScheduleFormProps {
+	readonly schedule: AutomationSchedule | null;
+	readonly targets: readonly AutomationTargetOption[];
+	readonly variables: readonly VariableDefinition[];
+	readonly busy: boolean;
+	readonly onCancel: () => void;
+	readonly onDelete: (() => Promise<void>) | undefined;
+	readonly onSubmit: (input: CreateAutomationScheduleInput) => Promise<void>;
+}
+
+function stringValue(form: FormData, key: string): string {
+	const value = form.get(key);
+	return typeof value === 'string' ? value : '';
+}
+
+export function AutomationScheduleForm(props: AutomationScheduleFormProps) @{
+	const { t } = useTranslation();
+	const variables = props.variables.map(
+		(variable) => ({
+			...variable,
+			label: t('automations.variables.' + variable.key + '.label'),
+		}),
+	);
+	const formState = useMemo(
+		() => createStore({
+			enabled: props.schedule?.enabled ?? true,
+			inputTemplate: props.schedule?.inputTemplate ?? '',
+			targetValue: props.schedule
+				? automationTargetValue({
+						kind: props.schedule.targetKind,
+						key: props.schedule.targetKey,
+					})
+				: props.targets[0]
+					? automationTargetValue(props.targets[0])
+					: '',
+		}),
+		[],
+	);
+	const [enabled, setEnabled] = useValue(formState.state.enabled);
+	const [inputTemplate, setInputTemplate] = useValue(
+		formState.state.inputTemplate,
+	);
+	const [targetValue, setTargetValue] = useValue(formState.state.targetValue);
+	const target = parseAutomationTargetValue(targetValue);
+	const options = automationTargetOptions(
+		props.targets,
+		props.schedule
+			? {
+					kind: props.schedule.targetKind,
+					key: props.schedule.targetKey,
+					label: props.schedule.targetName,
+				}
+			: null,
+	);
+	const availableVariables = variables.filter(
+		(variable) => target.kind === 'agent' || variable.key !== 'agent.name',
+	);
+
+	const submit = async (event: SubmitEvent) => {
+		event.preventDefault();
+		const form = new FormData(event.currentTarget as HTMLFormElement);
+		await props.onSubmit({
+			targetKind: target.kind,
+			targetKey: target.key,
+			label: stringValue(form, 'label'),
+			inputTemplate: stringValue(form, 'inputTemplate'),
+			cadence: 'every:' + stringValue(form, 'minutes'),
+			enabled,
+		});
+	};
+
+	<form class="ui-drawer__form" onSubmit={submit}>
+		<div class="ui-drawer__body">
+			<div class="ui-form">
+				@if (options.length === 0) {
+					<p class="ui-note">{t('automations.schedules.form.noTargets')}</p>
+				}
+				<div class="ui-form__row">
+					<FormField label={t('automations.common.target')} required>
+						<select
+							class="ui-select"
+							name="target"
+							value={targetValue}
+							onChange={(event: Event) => setTargetValue(
+								(event.currentTarget as HTMLSelectElement).value,
+							)}
+							required
+						>
+							@for (const option of options; key option.value) {
+								<option value={option.value} disabled={!option.available}>
+									{option.label + ' · ' +
+										t('automations.targetKind.' + option.kind)}
+								</option>
+							}
+						</select>
+					</FormField>
+					<FormField label={t('automations.common.label')} required>
+						<input
+							class="ui-input"
+							name="label"
+							defaultValue={props.schedule?.label ?? ''}
+							placeholder={t('automations.schedules.form.labelPlaceholder')}
+							minlength={2}
+							maxlength={120}
+							required
+						/>
+					</FormField>
+				</div>
+				<FormField
+					label={t('automations.schedules.form.interval')}
+					help={t('automations.schedules.form.intervalHelp')}
+					required
+				>
+					<input
+						class="ui-input"
+						name="minutes"
+						type="number"
+						defaultValue={String(
+							props.schedule ? cadenceMinutes(props.schedule.cadence) : 60,
+						)}
+						min={1}
+						max={10080}
+						required
+					/>
+				</FormField>
+				<FormField
+					label={t('automations.schedules.form.input')}
+					help={t(
+						target.kind === 'workflow'
+							? 'automations.schedules.form.workflowInputHelp'
+							: 'automations.schedules.form.inputHelp',
+					)}
+					required
+				>
+					<VariableTextarea
+						name="inputTemplate"
+						value={inputTemplate}
+						onInput={setInputTemplate}
+						variables={availableVariables}
+						sampleValues={{
+							'context.today': '2026-09-02',
+							'context.now': '2026-09-02T09:30:00.000Z',
+							'automation.schedule.label': props.schedule?.label ??
+								t('automations.template.sample.schedule'),
+							'agent.name': options.find(
+								(option) => option.value === targetValue,
+							)?.label ??
+								t('automations.template.sample.agent'),
+						}}
+						label={t('automations.schedules.form.input')}
+						insertLabel={t('automations.template.insert')}
+						variablesLabel={t('automations.template.available')}
+						emptyLabel={t('automations.template.empty')}
+						placeholder={t('automations.schedules.form.inputPlaceholder')}
+						maxLength={10_000}
+						required
+					/>
+				</FormField>
+				<label class="ui-checkbox">
+					<input
+						type="checkbox"
+						checked={enabled}
+						onChange={(event: Event) => setEnabled(
+							(event.currentTarget as HTMLInputElement).checked,
+						)}
+					/>
+					<span>{t('automations.common.enabledLabel')}</span>
+				</label>
+				@if (props.schedule?.disabledReason) {
+					<p class="ui-help ui-help--error">{props.schedule.disabledReason}</p>
+				}
+				@if (props.onDelete) {
+					<div class="ui-form__section ui-form__section--danger">
+						<div class="ui-form__section-head">
+							<b>{t('automations.schedules.form.deleteTitle')}</b>
+							<small>{t('automations.schedules.form.deleteHint')}</small>
+						</div>
+						<div class="ui-form__actions">
+							<Button
+								variant="danger"
+								type="button"
+								disabled={props.busy}
+								onClick={() => void props.onDelete!()}
+							>{t('automations.schedules.form.delete')}</Button>
+						</div>
+					</div>
+				}
+			</div>
+		</div>
+		<div class="ui-drawer__foot">
+			<Button type="button" onClick={props.onCancel}>{t(
+				'automations.common.cancel',
+			)}</Button>
+			<Button variant="primary" type="submit" disabled={props.busy}>
+				{props.busy
+					? t('automations.common.saving')
+					: t('automations.schedules.form.save')}
+			</Button>
+		</div>
+	</form>
+}