@flowdular/sdk 0.3.1 → 0.3.2

package/modules/users/src/client/member-columns.tsrx

@@ -11,14 +11,14 @@ export function memberColumns(
 		{
 			key: 'displayName',
 			header: t('users.table.user'),
-			width: '22%',
+			width: '20%',
 			value: (user) => user.displayName,
 			cell: (user) => <b>{user.displayName}</b>,
 		},
 		{
 			key: 'email',
 			header: t('users.table.email'),
-			width: '24%',
+			width: '22%',
 			value: (user) => user.email,
 			cell: (user) => <span>{user.email}</span>,
 		},
@@ -34,7 +34,7 @@ export function memberColumns(
 		{
 			key: 'status',
 			header: t('users.table.status'),
-			width: '28%',
+			width: '22%',
 			cell: (user) => <span class="ui-table__state">
 				<Tag
 					tone={user.membershipStatus === 'active' ? 'success' : 'neutral'}
@@ -55,11 +55,20 @@ export function memberColumns(
 		{
 			key: 'scopes',
 			header: t('users.table.scopes'),
-			width: '12%',
+			width: '10%',
 			numeric: true,
 			cell: (user) => new Intl.NumberFormat(activeLocale()).format(
 				user.scopes.length,
 			),
 		},
+		/* No `value`: the server's sorted read has no keyset over created_at. */
+		{
+			key: 'createdAt',
+			header: t('users.table.joined'),
+			width: '12%',
+			cell: (user) => new Intl.DateTimeFormat(activeLocale(), {
+				dateStyle: 'medium',
+			}).format(user.createdAt),
+		},
 	];
 }

package/modules/users/src/client/state.ts

@@ -46,6 +46,7 @@ export function createUsersClientState() {
 		actor: cell<UsersContext['actor'] | null>(null),
 		passwordMinLength: 12,
 		memberCount: 0,
+		ownerCount: 0,
 		query: '',
 		/** The term the rows on screen answer; typing moves `query` ahead of it. */
 		appliedQuery: '',
@@ -192,6 +193,21 @@ export function replaceMember(
 	);
 }
 
+/**
+ * The owner count after one row changed on screen: the count is read whole
+ * from the server, so a role change moves it by the difference between the row
+ * the page held and the row the server answered.
+ */
+export function ownerCountAfter(
+	ownerCount: number,
+	previous: TenantMember | undefined,
+	next: TenantMember,
+): number {
+	const before = previous?.role === 'owner' ? 1 : 0;
+	const after = next.role === 'owner' ? 1 : 0;
+	return ownerCount - before + after;
+}
+
 /* The membership route answers with stable codes; each one gets the sentence
    that says what to do instead, and anything else keeps the server message. */
 export function membershipStatusMessage(error: unknown): string {

package/modules/users/src/services/users-service.ts

@@ -54,6 +54,8 @@ export interface UsersContext {
 	readonly passwordMinLength: number;
 	/** Every membership of the workspace, counted in the database. */
 	readonly memberCount: number;
+	/** The memberships holding the owner role, counted the same way. */
+	readonly ownerCount: number;
 }
 
 function actor(principal: AuthPrincipal): AuthActor {
@@ -105,6 +107,7 @@ export class UsersService {
 			actor: { accountId: principal.accountId, role: principal.role },
 			passwordMinLength: this.#auth.settings.passwordMinLength,
 			memberCount: await service.countTenantMembers(principal.tenantId),
+			ownerCount: await service.countTenantOwners(principal.tenantId),
 		};
 	}
 

package/modules/users/translations/en.json

@@ -35,12 +35,13 @@
 	"denied.members": "Reading the user directory needs the users.members.read scope.",
 	"table.title": "Members",
 	"table.caption": "Workspace users",
-	"table.count": "{accounts} accounts",
+	"table.count": "{accounts} accounts, {owners} owners",
 	"table.user": "User",
 	"table.email": "Email",
 	"table.role": "Role",
 	"table.status": "Workspace access",
 	"table.scopes": "Scopes",
+	"table.joined": "Joined",
 	"table.actions": "User actions",
 	"table.loading": "Loading workspace accounts…",
 	"table.emptyTitle": "No accounts yet",

package/modules/users/translations/pl.json

@@ -35,12 +35,13 @@
 	"denied.members": "Odczyt katalogu użytkowników wymaga uprawnienia users.members.read.",
 	"table.title": "Członkowie",
 	"table.caption": "Użytkownicy przestrzeni roboczej",
-	"table.count": "Konta: {accounts}",
+	"table.count": "Konta: {accounts}, właściciele: {owners}",
 	"table.user": "Użytkownik",
 	"table.email": "E-mail",
 	"table.role": "Rola",
 	"table.status": "Dostęp do przestrzeni",
 	"table.scopes": "Zakresy",
+	"table.joined": "Dołączył(a)",
 	"table.actions": "Akcje użytkownika",
 	"table.loading": "Wczytywanie kont…",
 	"table.emptyTitle": "Brak kont",

package/modules/workflows/module.json

@@ -3,7 +3,7 @@
 	"schemaVersion": 1,
 	"id": "workflows.core",
 	"package": "@flowdular/module-workflows",
-	"version": "0.6.7",
+	"version": "0.6.8",
 	"profile": "full",
 	"capabilities": [
 		"api",
@@ -20,7 +20,7 @@
 	"dependencies": [
 		{
 			"id": "system.core",
-			"range": "^0.7.0"
+			"range": "^0.8.0"
 		},
 		{
 			"id": "auth.core",

package/modules/workflows/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@flowdular/module-workflows",
-	"version": "0.6.7",
+	"version": "0.6.8",
 	"type": "module",
 	"exports": {
 		".": "./src/index.ts",

package/modules/workflows/spec/module.yaml

@@ -1,6 +1,6 @@
 schemaVersion: 1
 id: workflows.core
-specVersion: 0.6.7
+specVersion: 0.6.8
 status: approved
 name: Agentic Workflows
 description: Builds, publishes, simulates, and executes durable tenant-scoped DAG workflows whose versioned nodes coordinate pinned agents, deterministic decisions, validated data, and registered module actions.
@@ -14,7 +14,7 @@ capabilities:
   - cli
 dependencies:
   - id: system.core
-    range: ^0.7.0
+    range: ^0.8.0
   - id: auth.core
     range: ^0.13.0
   - id: agents.core

package/modules/workflows/src/services/database-repository.ts

@@ -3,6 +3,7 @@ import {
 	integer,
 	runDatabaseMigrations,
 	type DatabaseHandle,
+	type DatabaseIsolationLevel,
 	type DatabaseTransaction,
 } from '@flowdular/sdk/database';
 import type { Actor, UserActor } from '@flowdular/sdk/kernel';
@@ -868,9 +869,14 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 		tenantId: string,
 		access: 'read' | 'write',
 		body: (transaction: DatabaseTransaction) => Promise<T>,
+		isolation?: DatabaseIsolationLevel,
 	): Promise<T> {
 		await this.readyPromise;
-		return this.handles.runtime.transaction(body, { access, tenantId });
+		return this.handles.runtime.transaction(body, {
+			access,
+			tenantId,
+			...(isolation ? { isolation } : {}),
+		});
 	}
 
 	async #query<Row extends object>(
@@ -1567,21 +1573,34 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 		tenantId: string,
 		runId: string,
 	): Promise<WorkflowRunDetail | null> {
-		const row = await this.#tx(
+		/* A worker commits a node transition together with its events, so the
+		   rebuild only agrees with the rows when every read here shares one
+		   snapshot. Read committed would take a new one per statement. */
+		const snapshot = await this.#tx(
 			tenantId,
 			'read',
-			async (transaction) =>
-				(
+			async (transaction) => {
+				const row = (
 					await this.#query<RunRow>(transaction, SQL.getRun, [tenantId, runId])
-				)[0],
-		);
-		if (!row) return null;
-		const events = await this.readEvents(
-			tenantId,
-			runId,
-			0,
-			WORKFLOW_LIMITS.maxRunEvents,
+				)[0];
+				if (!row) return null;
+				return {
+					row,
+					events: await this.#eventsIn(
+						transaction,
+						tenantId,
+						runId,
+						0,
+						WORKFLOW_LIMITS.maxRunEvents,
+					),
+					nodes: await this.#nodeStatesIn(transaction, tenantId, runId),
+					edges: await this.#edgeTransfersIn(transaction, tenantId, runId),
+				};
+			},
+			'repeatable-read',
 		);
+		if (!snapshot) return null;
+		const { row, events, nodes, edges } = snapshot;
 		const projection = projectWorkflowRunEvents(events);
 		if (projection.status !== row.status) {
 			throw new WorkflowEventProjectionError(
@@ -1589,7 +1608,6 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 				`Workflow run projection is ${row.status} but its event stream rebuilds as ${projection.status}.`,
 			);
 		}
-		const nodes = await this.readNodeStates(tenantId, runId);
 		for (const [nodeId, status] of Object.entries(projection.nodeStatuses)) {
 			if (nodes.find((node) => node.nodeId === nodeId)?.status !== status) {
 				throw new WorkflowEventProjectionError(
@@ -1612,7 +1630,6 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 				);
 			}
 		}
-		const edges = await this.readEdgeTransfers(tenantId, runId);
 		for (const [edgeId, state] of Object.entries(projection.edgeStates)) {
 			if (edges.find((edge) => edge.edgeId === edgeId)?.state !== state) {
 				throw new WorkflowEventProjectionError(
@@ -1826,21 +1843,28 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 		afterSequence: number,
 		limit: number,
 	): Promise<readonly WorkflowRunEventV1[]> {
-		return this.#tx(tenantId, 'read', async (transaction) =>
-			(
-				await this.#query<EventRow>(transaction, SQL.readEvents, [
-					tenantId,
-					runId,
-					Math.max(0, Math.trunc(afterSequence)),
-					Math.min(
-						Math.max(1, Math.trunc(limit)),
-						WORKFLOW_LIMITS.maxRunEvents,
-					),
-				])
-			).map(eventFromRow),
+		return this.#tx(tenantId, 'read', (transaction) =>
+			this.#eventsIn(transaction, tenantId, runId, afterSequence, limit),
 		);
 	}
 
+	async #eventsIn(
+		transaction: DatabaseTransaction,
+		tenantId: string,
+		runId: string,
+		afterSequence: number,
+		limit: number,
+	): Promise<readonly WorkflowRunEventV1[]> {
+		return (
+			await this.#query<EventRow>(transaction, SQL.readEvents, [
+				tenantId,
+				runId,
+				Math.max(0, Math.trunc(afterSequence)),
+				Math.min(Math.max(1, Math.trunc(limit)), WORKFLOW_LIMITS.maxRunEvents),
+			])
+		).map(eventFromRow);
+	}
+
 	async startAttempt(
 		write: StartAttemptWrite,
 		actor: Actor,
@@ -2516,42 +2540,58 @@ export class DatabaseWorkflowsRepository implements WorkflowsRepository {
 		tenantId: string,
 		runId: string,
 	): Promise<readonly WorkflowNodeExecution[]> {
-		return this.#tx(tenantId, 'read', async (transaction) => {
-			const states = await this.#query<NodeStateRow>(
-				transaction,
-				SQL.readNodeStates,
-				[tenantId, runId],
-			);
-			const attempts = await this.#query<AttemptRow>(
-				transaction,
-				SQL.readAttempts,
-				[tenantId, runId],
-			);
-			return states.map((state) =>
-				nodeExecutionFromRow(
-					state,
-					attempts
-						.filter((attempt) => attempt.node_id === state.node_id)
-						.map(attemptFromRow),
-				),
-			);
-		});
+		return this.#tx(tenantId, 'read', (transaction) =>
+			this.#nodeStatesIn(transaction, tenantId, runId),
+		);
+	}
+
+	async #nodeStatesIn(
+		transaction: DatabaseTransaction,
+		tenantId: string,
+		runId: string,
+	): Promise<readonly WorkflowNodeExecution[]> {
+		const states = await this.#query<NodeStateRow>(
+			transaction,
+			SQL.readNodeStates,
+			[tenantId, runId],
+		);
+		const attempts = await this.#query<AttemptRow>(
+			transaction,
+			SQL.readAttempts,
+			[tenantId, runId],
+		);
+		return states.map((state) =>
+			nodeExecutionFromRow(
+				state,
+				attempts
+					.filter((attempt) => attempt.node_id === state.node_id)
+					.map(attemptFromRow),
+			),
+		);
 	}
 
 	async readEdgeTransfers(
 		tenantId: string,
 		runId: string,
 	): Promise<readonly WorkflowEdgeTransfer[]> {
-		return this.#tx(tenantId, 'read', async (transaction) =>
-			(
-				await this.#query<EdgeRow>(transaction, SQL.readEdgeTransfers, [
-					tenantId,
-					runId,
-				])
-			).map(edgeFromRow),
+		return this.#tx(tenantId, 'read', (transaction) =>
+			this.#edgeTransfersIn(transaction, tenantId, runId),
 		);
 	}
 
+	async #edgeTransfersIn(
+		transaction: DatabaseTransaction,
+		tenantId: string,
+		runId: string,
+	): Promise<readonly WorkflowEdgeTransfer[]> {
+		return (
+			await this.#query<EdgeRow>(transaction, SQL.readEdgeTransfers, [
+				tenantId,
+				runId,
+			])
+		).map(edgeFromRow);
+	}
+
 	/* The chain order is the sequence; the time order rides the index 0001 made
 	   for it, with the sequence as the tie breaker in both. */
 	async listAudit(

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@flowdular/sdk",
-	"version": "0.3.1",
+	"version": "0.3.2",
 	"type": "module",
 	"description": "Flowdular platform SDK: server, client, UI, data, agents and core modules through separate exports.",
 	"license": "MIT",

package/packages/client/package.json

@@ -13,6 +13,7 @@
 		"test": "vitest run --passWithNoTests"
 	},
 	"dependencies": {
+		"@flowdular/contracts": "workspace:*",
 		"@flowdular/ui": "workspace:*",
 		"@octanejs/seo": "0.0.38",
 		"octane": "0.1.51",

package/packages/client/src/ApplicationShell.tsrx

@@ -13,6 +13,10 @@ import { CommandPalette } from './shell/CommandPalette.tsrx';
 import { widgetsForSlot } from './shell/ContributionOutlets.tsrx';
 import { registerModuleTranslations, useTranslation } from './i18n/runtime.ts';
 import { MobileHeader } from './shell/MobileHeader.tsrx';
+import {
+	contributionsForActiveModules,
+	loadActiveModules,
+} from './shell/modules.ts';
 import {
 	coreNavigation,
 	navigationForIdentity,
@@ -44,10 +48,6 @@ export function ApplicationShell(props: ApplicationShellProps) @{
    locale is side-effect free for subscribers. */
 	registerModuleTranslations(props.contributions ?? []);
 	const { t } = useTranslation();
-	const registry = useMemo(
-		() => createClientContributionRegistry(props.contributions ?? []),
-		[props.contributions],
-	);
 	const shell = useMemo(() => createShellState(props.initialView), [
 		props.initialView,
 	]);
@@ -60,12 +60,28 @@ export function ApplicationShell(props: ApplicationShellProps) @{
 					? null
 					: props.identity.tenantId,
 			),
+			/* The workspace whose active modules are known, and which they are;
+   null ids show every module, so a failed read never empties the shell. */
+			activationTenantId: cell<string | null>(null),
+			activeModules: cell<readonly string[] | null>(null),
 		}),
 		[],
 	);
 	const [initializedTenant, setInitializedTenant] = useValue(
 		initialization.state.tenantId,
 	);
+	const [activationTenant, setActivationTenant] = useValue(
+		initialization.state.activationTenantId,
+	);
+	const [activeModules, setActiveModules] = useValue(
+		initialization.state.activeModules,
+	);
+	const registry = useMemo(
+		() => createClientContributionRegistry(
+			contributionsForActiveModules(props.contributions ?? [], activeModules),
+		),
+		[props.contributions, activeModules],
+	);
 	const [activeView, setActiveView] = useValue(shell.state.activeView);
 	const [commandOpen, setCommandOpen] = useValue(shell.state.commandOpen);
 	const [navigationOpen, setNavigationOpen] = useValue(
@@ -80,7 +96,9 @@ export function ApplicationShell(props: ApplicationShellProps) @{
 	const [query, setQuery] = useValue(shell.state.query);
 	const [tenantBusy, setTenantBusy] = useValue(shell.state.tenantBusy);
 	const [tenantError, setTenantError] = useValue(shell.state.tenantError);
-	const workspaceInitialized = initializedTenant === props.identity.tenantId;
+	const workspaceInitialized =
+		initializedTenant === props.identity.tenantId &&
+			activationTenant === props.identity.tenantId;
 	const grantedScopes = new Set(props.identity.scopes);
 	const visibleNavigation = navigationForIdentity(
 		[...coreNavigation(t), ...registry.navigation],
@@ -222,6 +240,29 @@ export function ApplicationShell(props: ApplicationShellProps) @{
 		return () => controller.abort();
 	}, [props.identity.accountId, props.identity.tenantId]);
 
+	useEffect(() => {
+		const controller = new AbortController();
+		setActivationTenant(null);
+		const resolveActiveModules = props.loadActiveModules ?? loadActiveModules;
+		void resolveActiveModules({
+			accountId: props.identity.accountId,
+			tenantId: props.identity.tenantId,
+			signal: controller.signal,
+		}).then(
+			(ids) => {
+				if (controller.signal.aborted) return;
+				setActiveModules(ids);
+				setActivationTenant(props.identity.tenantId);
+			},
+			() => {
+				if (controller.signal.aborted) return;
+				setActiveModules(null);
+				setActivationTenant(props.identity.tenantId);
+			},
+		);
+		return () => controller.abort();
+	}, [props.identity.accountId, props.identity.tenantId]);
+
 	useEffect(() => {
 		try {
 			if (localStorage.getItem(SIDEBAR_STORAGE_KEY) === 'rail') {

package/packages/client/src/index.ts

@@ -25,6 +25,11 @@ export type {
 	WorkspaceSlot,
 } from './contributions.ts';
 export { openCommandPalette } from './shell/command.ts';
+export {
+	contributionsForActiveModules,
+	loadActiveModules,
+} from './shell/modules.ts';
+export type { ActiveModulesLoader } from './shell/modules.ts';
 export {
 	COMMAND_SEARCH_DEBOUNCE_MS,
 	COMMAND_SEARCH_MINIMUM,

package/packages/client/src/shell/modules.ts

@@ -0,0 +1,49 @@
+import { REQUIRED_MODULE_IDS } from '@flowdular/sdk/contracts';
+import type {
+	ModuleClientContribution,
+	ModuleClientInitializationContext,
+} from '../contributions.ts';
+
+const REQUIRED = new Set<string>(REQUIRED_MODULE_IDS);
+
+export type ActiveModulesLoader = (
+	context: ModuleClientInitializationContext,
+) => Promise<readonly string[] | null>;
+
+/**
+ * The contributions the workspace may show: every required module, and the
+ * optional ones the workspace has active. `null` means the activation could
+ * not be read, and the shell shows everything rather than nothing; the server
+ * gate still refuses the API of an inactive module.
+ */
+export function contributionsForActiveModules(
+	contributions: readonly ModuleClientContribution[],
+	activeModules: readonly string[] | null,
+): readonly ModuleClientContribution[] {
+	if (activeModules === null) return contributions;
+	const active = new Set(activeModules);
+	return contributions.filter(
+		(contribution) =>
+			REQUIRED.has(contribution.moduleId) || active.has(contribution.moduleId),
+	);
+}
+
+/* system.core answers the active composed module ids to any member of the
+   workspace; an application without it, or a failed read, answers null. */
+export const loadActiveModules: ActiveModulesLoader = async (context) => {
+	try {
+		const response = await fetch('/api/system/modules/active', {
+			headers: { accept: 'application/json' },
+			credentials: 'same-origin',
+			signal: context.signal,
+		});
+		if (!response.ok) return null;
+		const body = (await response.json()) as { modules?: unknown };
+		return Array.isArray(body.modules) &&
+			body.modules.every((id) => typeof id === 'string')
+			? (body.modules as string[])
+			: null;
+	} catch {
+		return null;
+	}
+};

package/packages/client/src/shell/types.ts

@@ -1,5 +1,6 @@
 import type { ModuleClientContribution } from '../contributions.ts';
 import type { ShellView } from '../state.ts';
+import type { ActiveModulesLoader } from './modules.ts';
 
 export interface ShellTenant {
 	readonly tenantId: string;
@@ -22,6 +23,8 @@ export interface ApplicationShellProps {
 	initialView?: ShellView;
 	contributions?: readonly ModuleClientContribution[];
 	identity: ShellIdentity;
+	/** Reads the active module ids of the workspace; defaults to system.core's endpoint. */
+	loadActiveModules?: ActiveModulesLoader;
 	onSignOut: () => void | Promise<void>;
 	onSwitchTenant: (tenantId: string) => void | Promise<void>;
 }

package/packages/contracts/src/index.ts

@@ -4,7 +4,7 @@
    removed or changed. The surface is pinned by
    packages/kernel/platform-api.snapshot.d.ts; `pnpm platform-api:check` fails
    when the surface changes without a bump here. */
-export const PLATFORM_API_VERSION = '0.1.8';
+export const PLATFORM_API_VERSION = '0.1.9';
 
 /* The workspace time zone: one tenant setting, declared by the module named
    here and read by any module that shows or schedules a local time. The id, the
@@ -15,6 +15,16 @@ export const TENANT_TIME_ZONE_SETTING = {
 	defaultValue: 'UTC',
 } as const;
 
+/* Modules every workspace needs to sign in, hold members and show the shell.
+   They are composed like any other module but never deactivated per workspace,
+   and the endpoint gate never asks about them. */
+export const REQUIRED_MODULE_IDS = [
+	'system.core',
+	'auth.core',
+	'users.core',
+	'profile.core',
+] as const;
+
 export type ModuleCapability =
 	| 'api'
 	| 'database'

package/packages/server/src/endpoint.ts

@@ -1,6 +1,7 @@
 import { ServerRoute, type Context } from '@octanejs/app-core';
 import { serverLogger } from './log.ts';
 import { serverMetrics } from './metrics.ts';
+import { MODULE_INACTIVE, routeActiveForTenant } from './module-activation.ts';
 import {
 	formatTraceParent,
 	runWithTrace,
@@ -11,6 +12,8 @@ import { serverTracer, type Span } from './trace/tracer.ts';
 export interface EndpointIdentity {
 	readonly subjectId: string;
 	readonly permissions: ReadonlySet<string>;
+	/** The workspace the identity acts in; the module activation gate reads it. */
+	readonly tenantId?: string;
 }
 
 export interface EndpointExecutionContext {
@@ -131,6 +134,19 @@ export function defineEndpoint(
 						traceparent,
 					);
 				}
+				if (
+					identity.tenantId !== undefined &&
+					!(await routeActiveForTenant(serverRoute, identity.tenantId))
+				) {
+					status = 403;
+					return problem(
+						403,
+						MODULE_INACTIVE,
+						'This module is inactive in the workspace.',
+						requestId,
+						traceparent,
+					);
+				}
 			}
 
 			const response = await definition.handler({
@@ -171,7 +187,7 @@ export function defineEndpoint(
 		}
 	};
 
-	const serverRoute = new ServerRoute({
+	const serverRoute: ServerRoute = new ServerRoute({
 		path: definition.path,
 		methods: definition.methods.map((method) => method.toUpperCase()),
 		handler: (context) => {

package/packages/server/src/index.ts

@@ -202,3 +202,13 @@ export type {
 	ModuleServerContext,
 	ModuleServerComposition,
 } from './composition.ts';
+export {
+	bindModuleCompositions,
+	bindModuleRoutes,
+	installModuleActivationGate,
+	isRequiredModule,
+	MODULE_INACTIVE,
+	moduleOfRoute,
+	routeActiveForTenant,
+} from './module-activation.ts';
+export type { ModuleActivationGate } from './module-activation.ts';