@flowdular/sdk 0.2.4 → 0.3.0

package/modules/automations/src/cli/index.ts

@@ -0,0 +1,114 @@
+import {
+	defineCliExtension,
+	type CliExtensionContext,
+} from '@flowdular/sdk/cli-protocol';
+import {
+	DATABASE_CAPABILITY_IDS,
+	DATABASE_DIALECT_IDS,
+	type DatabaseAdapterLease,
+} from '@flowdular/sdk/database';
+import { migrateAutomationsDatabase } from '../services/database-repository.ts';
+import { rotateTriggerSecrets } from '../services/secret-rotation.ts';
+import { secretVaultFromEnvironment } from '../services/secret-vault.ts';
+
+const rotateCapability = {
+	id: 'automations.secrets.rotate',
+	version: 1,
+	summary: 'Re-seal stored trigger secrets with the current encryption key.',
+	risk: 'process' as const,
+	requiresApprovedSpec: false,
+	supportsDryRun: true,
+};
+
+interface OpenDatabase {
+	readonly leases: readonly DatabaseAdapterLease[];
+	readonly runtime: DatabaseAdapterLease;
+	readonly background: DatabaseAdapterLease;
+}
+
+/* The operator commands read the same deployment database the platform does;
+   there is no module-owned file to open. The runner owns the provider and a
+   module owns no driver, so it arrives on the context. An operator command may
+   be the first thing to touch a fresh database, so it migrates before reading. */
+async function open(context: CliExtensionContext): Promise<OpenDatabase> {
+	const databases = context.databases;
+	if (!databases) {
+		throw new Error(
+			'automations.core CLI commands read the deployment database, and this workspace has none configured.',
+		);
+	}
+	const requirements = {
+		dialectIds: [DATABASE_DIALECT_IDS.postgresql],
+		capabilities: [DATABASE_CAPABILITY_IDS.TRANSACTIONS],
+	};
+	const migration = await databases.acquire({
+		namespace: 'automations.core',
+		purpose: 'migration',
+		requirements,
+	});
+	await migrateAutomationsDatabase(migration.database);
+	const runtime = await databases.acquire({
+		namespace: 'automations.core',
+		purpose: 'runtime',
+		requirements,
+	});
+	/* The inventory counts rows across the whole deployment, which only the
+	   cross-tenant read-only role may do. */
+	const background = await databases.acquire({
+		namespace: 'automations.core',
+		purpose: 'background',
+		requirements,
+	});
+	return { leases: [migration, runtime, background], runtime, background };
+}
+
+/* The provider belongs to the runner; only the leases this command took are
+   released here. */
+async function close(open: OpenDatabase): Promise<void> {
+	for (const lease of open.leases) await lease.release();
+}
+
+export const cliExtension = defineCliExtension({
+	protocolVersion: 1,
+	moduleId: 'automations.core',
+	commands: [
+		{
+			path: ['automations', 'secrets-rotate'],
+			capability: rotateCapability,
+			execute: async (context) => {
+				/* The report names key ids and row counts only; a secret never
+				   reaches the command output. */
+				const vault = secretVaultFromEnvironment(
+					process.env,
+					context.workspaceRoot,
+				);
+				const opened = await open(context);
+				try {
+					const report = await rotateTriggerSecrets({
+						runtime: opened.runtime.database,
+						background: opened.background.database,
+						vault,
+						apply: context.apply,
+					});
+					return {
+						data: { moduleId: 'automations.core', ...report },
+						evidence: [
+							'modules/automations/spec/module.yaml',
+							'docs/operations.md',
+						],
+						warnings:
+							report.skipped > 0
+								? [
+										`${report.skipped} rows were rewritten by the application while this ran and keep their own envelope. Run the command again.`,
+									]
+								: [],
+					};
+				} finally {
+					await close(opened);
+				}
+			},
+		},
+	],
+});
+
+export default cliExtension;

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

@@ -3,7 +3,12 @@ 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 {
+	cadenceKind,
+	cadenceMinutes,
+	cronExpression,
+	MAX_CRON_LENGTH,
+} from '../domain/cadence.ts';
 import type {
 	AutomationSchedule,
 	AutomationTargetOption,
@@ -19,6 +24,8 @@ export interface AutomationScheduleFormProps {
 	readonly schedule: AutomationSchedule | null;
 	readonly targets: readonly AutomationTargetOption[];
 	readonly variables: readonly VariableDefinition[];
+	/** Workspace zone a cron expression is read in. */
+	readonly timeZone: string;
 	readonly busy: boolean;
 	readonly onCancel: () => void;
 	readonly onDelete: (() => Promise<void>) | undefined;
@@ -40,6 +47,9 @@ export function AutomationScheduleForm(props: AutomationScheduleFormProps) @{
 	);
 	const formState = useMemo(
 		() => createStore({
+			cadenceMode: props.schedule
+				? cadenceKind(props.schedule.cadence)
+				: 'every',
 			enabled: props.schedule?.enabled ?? true,
 			inputTemplate: props.schedule?.inputTemplate ?? '',
 			targetValue: props.schedule
@@ -53,6 +63,7 @@ export function AutomationScheduleForm(props: AutomationScheduleFormProps) @{
 		}),
 		[],
 	);
+	const [cadenceMode, setCadenceMode] = useValue(formState.state.cadenceMode);
 	const [enabled, setEnabled] = useValue(formState.state.enabled);
 	const [inputTemplate, setInputTemplate] = useValue(
 		formState.state.inputTemplate,
@@ -81,7 +92,9 @@ export function AutomationScheduleForm(props: AutomationScheduleFormProps) @{
 			targetKey: target.key,
 			label: stringValue(form, 'label'),
 			inputTemplate: stringValue(form, 'inputTemplate'),
-			cadence: 'every:' + stringValue(form, 'minutes'),
+			cadence: cadenceMode === 'cron'
+				? 'cron:' + stringValue(form, 'cron')
+				: 'every:' + stringValue(form, 'minutes'),
 			enabled,
 		});
 	};
@@ -123,23 +136,68 @@ export function AutomationScheduleForm(props: AutomationScheduleFormProps) @{
 						/>
 					</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>
+				<div class="ui-form__row">
+					<FormField label={t('automations.schedules.form.cadenceMode')}>
+						<select
+							class="ui-select"
+							name="cadenceMode"
+							value={cadenceMode}
+							onChange={(event: Event) => setCadenceMode(
+								(event.currentTarget as HTMLSelectElement).value === 'cron'
+									? 'cron'
+									: 'every',
+							)}
+						>
+							<option value="every">{t(
+								'automations.schedules.form.cadenceModeInterval',
+							)}</option>
+							<option value="cron">{t(
+								'automations.schedules.form.cadenceModeCron',
+							)}</option>
+						</select>
+					</FormField>
+					@if (cadenceMode === 'cron') {
+						<FormField
+							label={t('automations.schedules.form.cron')}
+							help={t('automations.schedules.form.cronHelp', {
+								zone: props.timeZone,
+							})}
+							required
+						>
+							<input
+								class="ui-input"
+								name="cron"
+								defaultValue={props.schedule
+									? cronExpression(props.schedule.cadence)
+									: '0 6 * * 1-5'}
+								placeholder="0 6 * * 1-5"
+								maxlength={MAX_CRON_LENGTH}
+								required
+							/>
+						</FormField>
+					} @else {
+						<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 &&
+									cadenceKind(props.schedule.cadence) === 'every'
+										? cadenceMinutes(props.schedule.cadence)
+										: 60,
+								)}
+								min={1}
+								max={10080}
+								required
+							/>
+						</FormField>
+					}
+				</div>
 				<FormField
 					label={t('automations.schedules.form.input')}
 					help={t(

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

@@ -6,14 +6,15 @@ import {
 	Filters,
 	Icon,
 	PageHeader,
+	Pagination,
 	SearchField,
 	TableCard,
 	Tag,
 	type TableColumn,
+	type TableSort,
 } from '@flowdular/sdk/ui';
-import { activeLocale, t } from '@flowdular/sdk/client';
+import { t } from '@flowdular/sdk/client';
 import { useValue } from 'segment-state';
-import { cadenceMinutes } from '../domain/cadence.ts';
 import type {
 	AutomationSchedule,
 	CreateAutomationScheduleInput,
@@ -21,12 +22,21 @@ import type {
 import {
 	createAutomationSchedule,
 	deleteAutomationSchedule,
+	loadAutomationOptions,
 	loadAutomationSchedules,
 	runAutomationSchedule,
 	updateAutomationSchedule,
 } from './api.ts';
 import { AutomationScheduleForm } from './AutomationScheduleForm.tsrx';
-import { createAutomationScheduleClientState } from './state.ts';
+import {
+	AUTOMATION_LIST_PAGE_SIZE,
+	FIRST_PAGE,
+	createAutomationScheduleClientState,
+	listRequest,
+	listSort,
+	movePage,
+	pageLoaded,
+} from './state.ts';
 import { cadenceLabel, timestampLabel } from './presentation.ts';
 
 export interface AutomationSchedulesViewProps {
@@ -34,6 +44,9 @@ export interface AutomationSchedulesViewProps {
 	readonly canManage: boolean;
 }
 
+/* Keystrokes and page clicks coalesce into one request. */
+const LIST_DEBOUNCE_MS = 200;
+
 function ScheduleSummary(props: { readonly schedule: AutomationSchedule }) @{
 	<span class="ui-cell">
 		<b>{props.schedule.label}</b>
@@ -43,18 +56,21 @@ function ScheduleSummary(props: { readonly schedule: AutomationSchedule }) @{
 	</span>
 }
 
-function scheduleColumns(): readonly TableColumn<AutomationSchedule>[] {
+function scheduleColumns(
+	timeZone: string,
+): readonly TableColumn<AutomationSchedule>[] {
 	return [
 		{
-			key: 'schedule',
+			key: 'label',
 			header: t('automations.schedules.column.schedule'),
-			width: '24%',
+			width: '22%',
+			value: (schedule) => schedule.label,
 			cell: (schedule) => <ScheduleSummary schedule={schedule} />,
 		},
 		{
 			key: 'target',
 			header: t('automations.common.target'),
-			width: '18%',
+			width: '16%',
 			cell: (schedule) => <span class="ui-cell">
 				<span>{schedule.targetName}</span>
 				<small class="ui-cell__muted">
@@ -69,27 +85,34 @@ function scheduleColumns(): readonly TableColumn<AutomationSchedule>[] {
 		{
 			key: 'cadence',
 			header: t('automations.schedules.column.cadence'),
-			width: '12%',
-			cell: (schedule) => cadenceLabel(cadenceMinutes(schedule.cadence)),
+			width: '10%',
+			cell: (schedule) => cadenceLabel(schedule.cadence),
 		},
 		{
 			key: 'last-run',
 			header: t('automations.schedules.column.lastRun'),
-			width: '16%',
-			cell: (schedule) => timestampLabel(schedule.lastRunAt),
+			width: '14%',
+			cell: (schedule) => timestampLabel(schedule.lastRunAt, timeZone),
 		},
 		{
 			key: 'next-run',
 			header: t('automations.schedules.column.nextRun'),
-			width: '16%',
+			width: '14%',
 			cell: (schedule) => schedule.enabled
-				? timestampLabel(schedule.nextRunAt)
+				? timestampLabel(schedule.nextRunAt, timeZone)
 				: t('automations.common.paused'),
 		},
+		{
+			key: 'updatedAt',
+			header: t('automations.common.updated'),
+			width: '12%',
+			value: (schedule) => schedule.updatedAt,
+			cell: (schedule) => timestampLabel(schedule.updatedAt, timeZone),
+		},
 		{
 			key: 'state',
 			header: t('automations.common.state'),
-			width: '14%',
+			width: '12%',
 			cell: (schedule) =>
 				<Tag tone={schedule.enabled ? 'success' : 'neutral'} dot>{t(
 					schedule.enabled
@@ -102,54 +125,110 @@ function scheduleColumns(): readonly TableColumn<AutomationSchedule>[] {
 
 export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 	const client = useMemo(() => createAutomationScheduleClientState(), []);
+	const requests = useMemo(() => ({ sequence: 0 }), []);
 	const [schedules] = useValue(client.state.schedules);
 	const [targets] = useValue(client.state.targets);
 	const [variables] = useValue(client.state.variables);
+	const [timeZone] = useValue(client.state.timeZone);
 	const [selectedId, setSelectedId] = useValue(client.state.selectedScheduleId);
 	const [status, setStatus] = useValue(client.state.status);
 	const [error, setError] = useValue(client.state.error);
 	const [notice, setNotice] = useValue(client.state.notice);
-	const [query, setQuery] = useValue(client.state.query);
-	const [enabledOnly, setEnabledOnly] = useValue(client.state.enabledOnly);
+	const [query] = useValue(client.state.query);
+	const [enabledOnly] = useValue(client.state.enabledOnly);
+	const [sorting] = useValue(client.state.sorting);
+	const [paging, setPaging] = useValue(client.state.paging);
 	const [filtersOpen, setFiltersOpen] = useValue(client.state.filtersOpen);
 	const [editorOpen, setEditorOpen] = useValue(client.state.editorOpen);
 	const selected =
 		schedules.find((schedule) => schedule.id === selectedId) ?? null;
-	const term = query.trim().toLocaleLowerCase(activeLocale());
-	const visible = schedules.filter(
-		(schedule) =>
-			(!enabledOnly || schedule.enabled) &&
-				(term === '' ||
-					schedule.label.toLocaleLowerCase(activeLocale()).includes(term) ||
-					schedule.targetName.toLocaleLowerCase(activeLocale()).includes(term)),
-	);
-	const filtered = term !== '' || enabledOnly;
+	const filtered = query.trim() !== '' || enabledOnly;
+	const order = listSort(sorting);
 
-	const refresh = async () => {
+	const loadPage = async () => {
+		const sequence = requests.sequence += 1;
 		setStatus('loading');
 		setError('');
 		try {
-			const result = await loadAutomationSchedules();
+			const result = await loadAutomationSchedules(
+				listRequest({ sorting, query, enabledOnly, paging }),
+			);
+			if (sequence !== requests.sequence) return;
+			client.store.act((transaction) => {
+				transaction.set(client.state.schedules, result.items);
+				transaction.set(
+					client.state.paging,
+					pageLoaded(paging, result.page.nextCursor),
+				);
+			}, 'automation-schedules/page');
+		} catch (loadError) {
+			if (sequence !== requests.sequence) return;
+			setError(
+				loadError instanceof Error
+					? loadError.message
+					: t('automations.schedules.error.load'),
+			);
+		} finally {
+			if (sequence === requests.sequence) setStatus('idle');
+		}
+	};
+
+	const loadOptions = async () => {
+		try {
+			const result = await loadAutomationOptions();
 			client.store.act((transaction) => {
-				transaction.set(client.state.schedules, result.schedules);
 				transaction.set(client.state.targets, result.targets);
 				transaction.set(client.state.variables, result.variables);
-			}, 'automation-schedules/loaded');
+				transaction.set(client.state.timeZone, result.timeZone);
+			}, 'automation-schedules/options');
 		} catch (loadError) {
 			setError(
 				loadError instanceof Error
 					? loadError.message
 					: t('automations.schedules.error.load'),
 			);
-		} finally {
-			setStatus('idle');
 		}
 	};
 
+	const refresh = async () => {
+		await Promise.all([loadOptions(), loadPage()]);
+	};
+
 	useEffect(() => {
-		void refresh();
+		void loadOptions();
 	}, []);
 
+	useEffect(() => {
+		const handle = setTimeout(() => void loadPage(), LIST_DEBOUNCE_MS);
+		return () => clearTimeout(handle);
+	}, [query, enabledOnly, order.sort, order.direction, paging.pageIndex]);
+
+	/* A narrower or reordered list starts from its first page. */
+	const restart = (
+		change: Parameters<typeof client.store.act>[0],
+		label: string,
+	) => {
+		client.store.act((transaction) => {
+			change(transaction);
+			transaction.set(client.state.paging, FIRST_PAGE);
+		}, label);
+	};
+	const changeQuery = (value: string) => restart(
+		(transaction) => transaction.set(client.state.query, value),
+		'automation-schedules/query',
+	);
+	const changeEnabledOnly = (value: boolean) => restart(
+		(transaction) => transaction.set(client.state.enabledOnly, value),
+		'automation-schedules/enabled-only',
+	);
+	const changeSorting = (value: readonly TableSort[]) => restart(
+		(transaction) => transaction.set(client.state.sorting, value),
+		'automation-schedules/sorting',
+	);
+	const changePage = (pageIndex: number) => setPaging(
+		movePage(paging, pageIndex),
+	);
+
 	const open = (scheduleId: string) => {
 		setSelectedId(scheduleId);
 		setEditorOpen(true);
@@ -211,7 +290,7 @@ export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 					label: schedule.label,
 				}),
 			);
-			await refresh();
+			await loadPage();
 		} catch (runError) {
 			setError(
 				runError instanceof Error
@@ -249,14 +328,14 @@ export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 		<TableCard
 			title={t('automations.schedules.table.title')}
 			count={t('automations.schedules.table.count', {
-				enabled: schedules.filter((schedule) => schedule.enabled).length,
-				total: schedules.length,
+				count: schedules.length,
+				page: paging.pageIndex + 1,
 			})}
 			search={<SearchField
 				value={query}
 				placeholder={t('automations.schedules.search.placeholder')}
 				label={t('automations.schedules.search.label')}
-				onInput={setQuery}
+				onInput={changeQuery}
 			/>}
 			filters={<Filters
 				open={filtersOpen}
@@ -268,16 +347,26 @@ export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 					<input
 						type="checkbox"
 						checked={enabledOnly}
-						onChange={(event: Event) => setEnabledOnly(
+						onChange={(event: Event) => changeEnabledOnly(
 							(event.currentTarget as HTMLInputElement).checked,
 						)}
 					/>
 					<span>{t('automations.common.enabledOnly')}</span>
 				</label>
 			</Filters>}
-			columns={scheduleColumns()}
-			rows={visible}
+			mode="server"
+			columns={scheduleColumns(timeZone)}
+			rows={schedules}
 			rowKey={(schedule) => schedule.id}
+			sorting
+			sortingState={sorting}
+			onSortingChange={changeSorting}
+			pagination={{
+				pageIndex: paging.pageIndex,
+				pageSize: AUTOMATION_LIST_PAGE_SIZE,
+				onPageChange: changePage,
+				hasMore: paging.nextCursor !== null,
+			}}
 			status={status === 'loading' && schedules.length === 0
 				? 'loading'
 				: 'idle'}
@@ -311,7 +400,21 @@ export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 						},
 					]
 				: undefined}
-			note={t('automations.schedules.note')}
+			after={<Pagination
+				pageIndex={paging.pageIndex}
+				pageSize={AUTOMATION_LIST_PAGE_SIZE}
+				hasMore={paging.nextCursor !== null}
+				onPageChange={changePage}
+				label={t('automations.schedules.pagination.label')}
+				previousLabel={t('automations.common.pagination.previous')}
+				nextLabel={t('automations.common.pagination.next')}
+				summary={(page) => t('automations.common.pagination.summary', {
+					page: page.pageIndex + 1,
+					from: page.from,
+				})}
+			/>}
+			note={t('automations.schedules.note') + ' ' +
+				t('automations.schedules.timeZoneNote', { zone: timeZone })}
 			noteIcon="shield"
 			caption={t('automations.schedules.table.caption')}
 		/>
@@ -329,6 +432,7 @@ export function AutomationSchedulesView(props: AutomationSchedulesViewProps) @{
 				schedule={selected}
 				targets={targets}
 				variables={variables}
+				timeZone={timeZone}
 				busy={status === 'submitting'}
 				onCancel={() => setEditorOpen(false)}
 				onDelete={selected && props.canManage ? () => remove() : undefined}