create-flowdular 0.2.4 → 0.2.5

package/agent-template/.ai/references/catalog/src/api/endpoints.ts

@@ -0,0 +1,243 @@
+import {
+	defineEndpoint,
+	HttpProblem,
+	jsonResponse,
+	problemResponse,
+	readJsonObject,
+	requiredInteger,
+	requiredString,
+} from '@flowdular/sdk/server';
+import { parseHistoryRequest } from '@flowdular/sdk/kernel';
+import type { AuthRuntime } from '@flowdular/sdk/modules/auth/server';
+import {
+	actorFromContext,
+	endpointIdentityFromContext,
+	principalFromContext,
+	sessionMutationDenial,
+} from '@flowdular/sdk/modules/auth/server';
+import { CATALOG_PERMISSIONS } from '../acl/permissions.ts';
+import type {
+	CatalogItemKind,
+	CreateCatalogItemInput,
+	UpdateCatalogItemInput,
+} from '../domain/types.ts';
+import { CatalogServiceError } from '../services/catalog-service.ts';
+import type { CatalogRuntime } from '../server/runtime.ts';
+
+function failure(error: unknown): Response {
+	if (error instanceof CatalogServiceError) {
+		return jsonResponse(
+			{ error: { code: error.code, message: error.message } },
+			error.status,
+		);
+	}
+	return problemResponse(error, 'The catalog operation failed.');
+}
+
+function mutableInput(
+	value: Record<string, unknown>,
+): Omit<UpdateCatalogItemInput, 'id'> {
+	const kind = requiredString(value, 'kind');
+	if (kind !== 'product' && kind !== 'service') {
+		throw new HttpProblem(
+			'INVALID_ITEM_KIND',
+			'kind must be product or service.',
+			400,
+		);
+	}
+	return {
+		name: requiredString(value, 'name', { min: 2, max: 160 }),
+		kind: kind as CatalogItemKind,
+		unit: requiredString(value, 'unit', { max: 24 }),
+		basePriceMinor: requiredInteger(value, 'basePriceMinor', { min: 0 }),
+		currency: requiredString(value, 'currency', { min: 3, max: 3 }),
+	};
+}
+
+export function createCatalogRoutes(
+	auth: AuthRuntime,
+	runtime: CatalogRuntime,
+) {
+	const list = defineEndpoint({
+		id: 'catalog.items.list',
+		path: '/api/catalog/items',
+		methods: ['GET'],
+		access: { kind: 'permission', permission: CATALOG_PERMISSIONS.read },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) =>
+			jsonResponse({
+				items: await (
+					await runtime.service()
+				).list(principalFromContext(octane)!.tenantId),
+			}),
+	});
+	const create = defineEndpoint({
+		id: 'catalog.items.create',
+		path: '/api/catalog/items',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: CATALOG_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const service = await runtime.service();
+				const value = await readJsonObject(octane.request);
+				const mutable = mutableInput(value);
+				const input: CreateCatalogItemInput = {
+					sku: requiredString(value, 'sku', { max: 64 }),
+					...mutable,
+				};
+				return jsonResponse(
+					{
+						item: await service.create(
+							principalFromContext(octane)!.tenantId,
+							input,
+							actorFromContext(octane)!,
+						),
+					},
+					201,
+				);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const update = defineEndpoint({
+		id: 'catalog.items.update',
+		path: '/api/catalog/items/update',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: CATALOG_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const service = await runtime.service();
+				const value = await readJsonObject(octane.request);
+				return jsonResponse({
+					item: await service.update(
+						principalFromContext(octane)!.tenantId,
+						{
+							id: requiredString(value, 'id', { max: 128 }),
+							...mutableInput(value),
+						},
+						actorFromContext(octane)!,
+					),
+				});
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const lifecycle = (action: 'archive' | 'restore', path: string, id: string) =>
+		defineEndpoint({
+			id,
+			path,
+			methods: ['POST'],
+			access: { kind: 'permission', permission: CATALOG_PERMISSIONS.manage },
+			resolveIdentity: endpointIdentityFromContext,
+			handler: async ({ octane }) => {
+				const denial = sessionMutationDenial(octane, auth);
+				if (denial) return denial;
+				try {
+					const value = await readJsonObject(octane.request);
+					const service = await runtime.service();
+					const item = await service[action](
+						principalFromContext(octane)!.tenantId,
+						requiredString(value, 'id', { max: 128 }),
+						actorFromContext(octane)!,
+					);
+					return jsonResponse({ item });
+				} catch (error) {
+					return failure(error);
+				}
+			},
+		});
+	const archive = lifecycle(
+		'archive',
+		'/api/catalog/items/archive',
+		'catalog.items.archive',
+	);
+	const restore = lifecycle(
+		'restore',
+		'/api/catalog/items/restore',
+		'catalog.items.restore',
+	);
+	const remove = defineEndpoint({
+		id: 'catalog.items.delete',
+		path: '/api/catalog/items/delete',
+		methods: ['POST'],
+		access: { kind: 'permission', permission: CATALOG_PERMISSIONS.manage },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const denial = sessionMutationDenial(octane, auth);
+			if (denial) return denial;
+			try {
+				const service = await runtime.service();
+				const value = await readJsonObject(octane.request);
+				await service.delete(
+					principalFromContext(octane)!.tenantId,
+					requiredString(value, 'id', { max: 128 }),
+					actorFromContext(octane)!,
+				);
+				return jsonResponse({ deleted: true });
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	const history = defineEndpoint({
+		id: 'catalog.items.history',
+		path: '/api/catalog/items/history',
+		methods: ['GET'],
+		access: { kind: 'permission', permission: CATALOG_PERMISSIONS.read },
+		resolveIdentity: endpointIdentityFromContext,
+		handler: async ({ octane }) => {
+			const request = parseHistoryRequest(
+				new URL(octane.request.url).searchParams,
+			);
+			if (!request) {
+				return jsonResponse(
+					{
+						error: {
+							code: 'INVALID_INPUT',
+							message: 'recordId is required.',
+						},
+					},
+					400,
+				);
+			}
+			try {
+				const service = await runtime.service();
+				return jsonResponse(
+					await service.history(
+						principalFromContext(octane)!.tenantId,
+						request,
+					),
+				);
+			} catch (error) {
+				return failure(error);
+			}
+		},
+	});
+	return [
+		list.serverRoute,
+		create.serverRoute,
+		update.serverRoute,
+		archive.serverRoute,
+		restore.serverRoute,
+		remove.serverRoute,
+		history.serverRoute,
+	] as const;
+}
+
+export const endpoints = [
+	'catalog.items.list',
+	'catalog.items.create',
+	'catalog.items.update',
+	'catalog.items.archive',
+	'catalog.items.restore',
+	'catalog.items.delete',
+	'catalog.items.history',
+] as const;

package/agent-template/.ai/references/catalog/src/client/CatalogHistoryDrawer.tsrx

@@ -0,0 +1,123 @@
+import type { HistoryEntry, HistoryValue } from '@flowdular/sdk/kernel';
+import { activeLocale, t } from '@flowdular/sdk/client';
+import {
+	Alert,
+	Drawer,
+	TableCard,
+	Tag,
+	type TableColumn,
+} from '@flowdular/sdk/ui';
+import type { CatalogItem } from '../domain/types.ts';
+
+export interface CatalogHistoryDrawerProps {
+	readonly open: boolean;
+	readonly item: CatalogItem | null;
+	readonly entries: readonly HistoryEntry[];
+	readonly loading: boolean;
+	readonly error: string;
+	readonly onClose: () => void;
+}
+
+function value(input: HistoryValue): string {
+	return input === null ? t('catalog.history.emptyValue') : String(input);
+}
+
+function changes(entry: HistoryEntry): string {
+	return Object.entries(entry.changes).map(
+		([field, change]) => `${t('catalog.history.field.' + field)}: ${value(
+			change.from,
+		)} → ${value(change.to)}`,
+	).join(', ');
+}
+
+function date(value: number): string {
+	return new Intl.DateTimeFormat(activeLocale(), {
+		dateStyle: 'medium',
+		timeStyle: 'short',
+	}).format(new Date(value));
+}
+
+function actorDetail(entry: HistoryEntry): string {
+	if (entry.actor.kind !== 'service') {
+		return t('catalog.history.actor.' + entry.actor.kind);
+	}
+	return t('catalog.history.actor.serviceConfiguredBy', {
+		name: entry.actor.configuredBy.label,
+	});
+}
+
+function columns(): readonly TableColumn<HistoryEntry>[] {
+	return [
+		{
+			key: 'version',
+			header: t('catalog.history.column.version'),
+			width: '10%',
+			cell: (entry) => <span class="ui-mono">{'v' + entry.version}</span>,
+		},
+		{
+			key: 'action',
+			header: t('catalog.history.column.action'),
+			width: '18%',
+			cell: (entry) =>
+				<Tag
+					tone={entry.action === 'deleted'
+						? 'danger'
+						: entry.action === 'archived'
+							? 'warning'
+							: 'neutral'}
+				>{t('catalog.history.action.' + entry.action)}</Tag>,
+		},
+		{
+			key: 'actor',
+			header: t('catalog.history.column.actor'),
+			width: '24%',
+			cell: (entry) => <span class="ui-cell">
+				<b>{entry.actor.label}</b>
+				<small>{actorDetail(entry)}</small>
+			</span>,
+		},
+		{
+			key: 'changes',
+			header: t('catalog.history.column.changes'),
+			width: '30%',
+			cell: (entry) => <small>{changes(entry)}</small>,
+		},
+		{
+			key: 'occurredAt',
+			header: t('catalog.history.column.date'),
+			width: '18%',
+			cell: (entry) => <small>{date(entry.occurredAt)}</small>,
+		},
+	];
+}
+
+export function CatalogHistoryDrawer(props: CatalogHistoryDrawerProps) @{
+	<Drawer
+		open={props.open}
+		title={t('catalog.history.title')}
+		subtitle={props.item?.name ?? ''}
+		width="lg"
+		onClose={props.onClose}
+	>
+		<div class="ui-drawer__body">
+			@if (props.error) {
+				<Alert>{props.error}</Alert>
+			}
+			<TableCard
+				title={t('catalog.history.tableTitle')}
+				count={t('catalog.history.count', { count: props.entries.length })}
+				caption={t('catalog.history.caption')}
+				columns={columns()}
+				rows={props.entries}
+				rowKey={(entry) => entry.id}
+				status={props.loading ? 'loading' : 'idle'}
+				loadingLabel={t('catalog.history.loading')}
+				empty={{
+					icon: 'activity',
+					title: t('catalog.history.emptyTitle'),
+					hint: t('catalog.history.emptyHint'),
+				}}
+			/>
+		</div>
+	</Drawer>
+}

package/agent-template/.ai/references/catalog/src/client/CatalogItemForm.tsrx

@@ -0,0 +1,190 @@
+import { useMemo } from 'octane';
+import { Alert, Button, FormField } from '@flowdular/sdk/ui';
+import { t } from '@flowdular/sdk/client';
+import { cell, createStore, useValue } from 'segment-state';
+import type { CatalogItem, CatalogItemKind } from '../domain/types.ts';
+
+export interface CatalogItemFormProps {
+	readonly item: CatalogItem | null;
+	readonly busy: boolean;
+	readonly error: string;
+	readonly onCancel: () => void;
+	readonly onArchive: (() => void) | undefined;
+	readonly onRestore: (() => void) | undefined;
+	readonly onDelete: (() => void) | undefined;
+	readonly onHistory: (() => void) | undefined;
+	readonly onSubmit: (event: SubmitEvent) => void;
+}
+
+export function CatalogItemForm(props: CatalogItemFormProps) @{
+	const formState = useMemo(
+		() => createStore({
+			name: props.item?.name ?? '',
+			sku: props.item?.sku ?? '',
+			kind: cell<CatalogItemKind>(props.item?.kind ?? 'product'),
+			unit: props.item?.unit ?? 'each',
+			basePriceMinor: String(props.item?.basePriceMinor ?? 0),
+			currency: props.item?.currency ?? 'EUR',
+		}),
+		[],
+	);
+	const [name, setName] = useValue(formState.state.name);
+	const [sku, setSku] = useValue(formState.state.sku);
+	const [kind, setKind] = useValue(formState.state.kind);
+	const [unit, setUnit] = useValue(formState.state.unit);
+	const [basePriceMinor, setBasePriceMinor] = useValue(
+		formState.state.basePriceMinor,
+	);
+	const [currency, setCurrency] = useValue(formState.state.currency);
+
+	<form class="ui-drawer__form" onSubmit={props.onSubmit}>
+		<div class="ui-drawer__body">
+			<div class="ui-form">
+				<div class="ui-form__row">
+					<FormField label={t('catalog.form.name')} required>
+						<input
+							class="ui-input"
+							name="name"
+							value={name}
+							onInput={(event) => setName(event.currentTarget.value)}
+							minlength={2}
+							maxlength={160}
+							autoFocus
+							required
+						/>
+					</FormField>
+					<FormField label={t('catalog.form.sku')} required>
+						<input
+							class="ui-input ui-mono"
+							name="sku"
+							value={sku}
+							onInput={(event) => setSku(event.currentTarget.value)}
+							disabled={props.item !== null}
+							maxlength={64}
+							required
+						/>
+					</FormField>
+				</div>
+				<div class="ui-form__row">
+					<FormField label={t('catalog.form.kind')}>
+						<select
+							class="ui-select"
+							name="kind"
+							value={kind}
+							onInput={(event) => setKind(
+								event.currentTarget.value as CatalogItemKind,
+							)}
+						>
+							<option value="product">{t('catalog.kind.product')}</option>
+							<option value="service">{t('catalog.kind.service')}</option>
+						</select>
+					</FormField>
+					<FormField label={t('catalog.form.unit')} required>
+						<input
+							class="ui-input"
+							name="unit"
+							value={unit}
+							onInput={(event) => setUnit(event.currentTarget.value)}
+							maxlength={24}
+							required
+						/>
+					</FormField>
+				</div>
+				<div class="ui-form__row">
+					<FormField
+						label={t('catalog.form.price')}
+						help={t('catalog.form.priceHelp')}
+						required
+					>
+						<input
+							class="ui-input"
+							name="basePriceMinor"
+							type="number"
+							min="0"
+							step="1"
+							value={basePriceMinor}
+							onInput={(event) => setBasePriceMinor(event.currentTarget.value)}
+							required
+						/>
+					</FormField>
+					<FormField label={t('catalog.form.currency')} required>
+						<input
+							class="ui-input ui-mono"
+							name="currency"
+							value={currency}
+							onInput={(event) => setCurrency(event.currentTarget.value)}
+							minlength={3}
+							maxlength={3}
+							required
+						/>
+					</FormField>
+				</div>
+				@if (props.error) {
+					<Alert>{props.error}</Alert>
+				}
+				@if (props.item) {
+					<>
+						<div class="ui-form__section">
+							<div class="ui-form__section-head">
+								<b>{t('catalog.lifecycle.title')}</b>
+								<small>{t('catalog.lifecycle.description')}</small>
+							</div>
+							<div class="ui-form__actions">
+								@if (props.onHistory) {
+									<Button
+										type="button"
+										disabled={props.busy}
+										onClick={props.onHistory}
+									>{t('catalog.lifecycle.history')}</Button>
+								}
+								@if (props.onArchive) {
+									<Button
+										type="button"
+										disabled={props.busy}
+										onClick={props.onArchive}
+									>{t('catalog.lifecycle.archive')}</Button>
+								}
+								@if (props.onRestore) {
+									<Button
+										type="button"
+										disabled={props.busy}
+										onClick={props.onRestore}
+									>{t('catalog.lifecycle.restore')}</Button>
+								}
+							</div>
+						</div>
+						@if (props.onDelete) {
+							<div class="ui-form__section ui-form__section--danger">
+								<div class="ui-form__section-head">
+									<b>{t('catalog.delete.title')}</b>
+									<small>{t('catalog.delete.drawerDescription')}</small>
+								</div>
+								<div class="ui-form__actions">
+									<Button
+										type="button"
+										variant="danger"
+										disabled={props.busy}
+										onClick={props.onDelete}
+									>{t('catalog.lifecycle.delete')}</Button>
+								</div>
+							</div>
+						}
+					</>
+				}
+			</div>
+		</div>
+		<div class="ui-drawer__foot">
+			<small>{t(
+				props.item ? 'catalog.form.editNote' : 'catalog.form.note',
+			)}</small>
+			<div class="ui-form__actions">
+				<Button onClick={props.onCancel}>{t('catalog.form.cancel')}</Button>
+				<Button variant="primary" type="submit" disabled={props.busy}>
+					{props.busy
+						? t(props.item ? 'catalog.form.saving' : 'catalog.form.submitting')
+						: t(props.item ? 'catalog.form.save' : 'catalog.form.submit')}
+				</Button>
+			</div>
+		</div>
+	</form>
+}