@openfairygui/backend 0.2.0-alpha.0

package/src/services/read-service.ts

@@ -0,0 +1,24 @@
+import { failure, success, type BackendContext } from './context.js';
+import type { BackendCapabilities, BackendResult, BackendSessionSnapshot, SessionNotFoundError } from '../runtime.js';
+import { createSessionNotFoundError, toSessionSnapshot } from './session-utils.js';
+import { cloneCapabilitiesSnapshot } from './snapshot-utils.js';
+
+export class ReadService {
+	public constructor(private readonly context: BackendContext) {}
+
+	public getCapabilities(): BackendResult<BackendCapabilities> {
+		return success('read', Date.now(), cloneCapabilitiesSnapshot(this.context.capabilities));
+	}
+
+	public getSession(input: { sessionId: string }): BackendResult<BackendSessionSnapshot, SessionNotFoundError> {
+		const startedAt = Date.now();
+		const session = this.context.sessions.get(input.sessionId);
+		if (!session || session.closed) {
+			return failure('read', startedAt, createSessionNotFoundError(input.sessionId));
+		}
+		return success('read', startedAt, toSessionSnapshot(session, this.context.capabilities), {
+			sessionId: session.sessionId,
+			revision: session.revision,
+		});
+	}
+}

package/src/services/runtime-service.ts

@@ -0,0 +1,125 @@
+import { NodeIO, readProjectAsUam } from '@openfairygui/core';
+import { failure, success, type BackendContext, type BackendSessionState } from './context.js';
+import type { CacheService } from './cache-service.js';
+import type { EventService } from './event-service.js';
+import type { JobService } from './job-service.js';
+import type {
+	AdvisoryLockConflictError,
+	BackendFileHandle,
+	BackendResult,
+	BackendSessionSnapshot,
+	InProcessLockConflictError,
+	SessionNotFoundError,
+} from '../runtime.js';
+import { resolveCanonicalProjectRoot } from '../path-policy.js';
+import { createSessionNotFoundError, toSessionSnapshot } from './session-utils.js';
+
+function randomId(): string {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export class RuntimeService {
+	public constructor(
+		private readonly context: BackendContext,
+		private readonly cacheService: CacheService,
+		private readonly eventService: EventService,
+		private readonly jobService: JobService,
+	) {}
+
+	public async openSession(input: { projectPath: string }): Promise<BackendResult<BackendSessionSnapshot, InProcessLockConflictError | AdvisoryLockConflictError>> {
+		const startedAt = Date.now();
+		const resolved = await resolveCanonicalProjectRoot(this.context.fileSystem, input.projectPath);
+		const { fairyPath, canonicalProjectPath, canonicalPathKey } = resolved;
+		const existingSessionId = this.context.sessionsByPath.get(canonicalPathKey);
+		const lockFilePath = this.context.fileSystem.join(canonicalProjectPath, '.openfairygui.backend.lock');
+
+		if (existingSessionId) {
+			return failure('runtime', startedAt, {
+				code: 'lock_conflict',
+				kind: 'in_process_session_exists',
+				message: `Project is already open in this backend runtime: ${canonicalProjectPath}`,
+				canonicalPathKey,
+				holderSessionId: existingSessionId,
+				lockFilePath,
+			});
+		}
+
+		let advisoryLock: BackendFileHandle | null = null;
+		try {
+			advisoryLock = await this.context.fileSystem.openExclusive(lockFilePath);
+			await advisoryLock.writeFile(JSON.stringify({
+				pid: process.pid,
+				createdAt: new Date().toISOString(),
+				canonicalPathKey,
+			}));
+			await advisoryLock.close();
+
+			const io = new NodeIO();
+			const project = await readProjectAsUam(io, fairyPath);
+			const sessionId = randomId();
+			const session: BackendSessionState = {
+				sessionId,
+				fairyPath,
+				canonicalProjectPath,
+				canonicalPathKey,
+				lockFilePath,
+				project,
+				revision: 0,
+				lastSavedRevision: 0,
+				dirty: false,
+				lockHeld: true,
+				closed: false,
+			};
+			this.context.sessions.set(sessionId, session);
+			this.context.sessionsByPath.set(canonicalPathKey, sessionId);
+			this.cacheService.refreshSession(session);
+			this.eventService.emit({ kind: 'session.opened', sessionId, canonicalPathKey, revision: session.revision });
+
+			return success('runtime', startedAt, toSessionSnapshot(session, this.context.capabilities), {
+				sessionId: session.sessionId,
+				revision: session.revision,
+			});
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException)?.code === 'EEXIST') {
+				return failure('runtime', startedAt, {
+					code: 'lock_conflict',
+					kind: 'advisory_lock_conflict',
+					message: `Advisory lock already exists for project: ${canonicalProjectPath}`,
+					canonicalPathKey,
+					lockFilePath,
+				});
+			}
+			if (advisoryLock) {
+				await advisoryLock.close().catch(() => undefined);
+				await this.context.fileSystem.unlink(lockFilePath).catch(() => undefined);
+			}
+			throw error;
+		}
+	}
+
+	public async closeSession(
+		input: { sessionId: string },
+	): Promise<BackendResult<{ sessionId: string; closed: true }, SessionNotFoundError>> {
+		const startedAt = Date.now();
+		const session = this.context.sessions.get(input.sessionId);
+		if (!session || session.closed) {
+			return failure('runtime', startedAt, createSessionNotFoundError(input.sessionId));
+		}
+
+		this.eventService.emit({ kind: 'session.closeRequested', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
+		await this.context.fileSystem.unlink(session.lockFilePath).catch(() => undefined);
+		session.lockHeld = false;
+		session.closed = true;
+		this.context.sessions.delete(session.sessionId);
+		this.context.sessionsByPath.delete(session.canonicalPathKey);
+		this.cacheService.removeSession(session.sessionId);
+		this.jobService.removeSession(session.sessionId);
+		this.eventService.emit({ kind: 'session.closed', sessionId: session.sessionId, canonicalPathKey: session.canonicalPathKey, revision: session.revision });
+		this.eventService.removeSession(session.sessionId);
+
+		return success('runtime', startedAt, {
+			sessionId: session.sessionId,
+			closed: true,
+		}, { sessionId: session.sessionId, revision: session.revision });
+	}
+}

package/src/services/session-utils.ts

@@ -0,0 +1,42 @@
+import type {
+	BackendCapabilities,
+	BackendSessionSnapshot,
+	SessionNotFoundError,
+	SessionStaleWriteError,
+} from '../runtime.js';
+import type { BackendSessionState } from './context.js';
+import { cloneCapabilitiesSnapshot } from './snapshot-utils.js';
+
+export function toSessionSnapshot(session: BackendSessionState, capabilities: BackendCapabilities): BackendSessionSnapshot {
+	return {
+		sessionId: session.sessionId,
+		canonicalProjectPath: session.canonicalProjectPath,
+		revision: session.revision,
+		lastSavedRevision: session.lastSavedRevision,
+		dirty: session.dirty,
+		lockHeld: session.lockHeld,
+		capabilities: cloneCapabilitiesSnapshot(capabilities),
+	};
+}
+
+export function createSessionNotFoundError(sessionId: string): SessionNotFoundError {
+	return {
+		code: 'session_not_found',
+		message: `Session was not found: ${sessionId}`,
+		sessionId,
+	};
+}
+
+export function createStaleWriteError(
+	session: Pick<BackendSessionState, 'sessionId' | 'canonicalPathKey' | 'revision'>,
+	expectedRevision: number,
+): SessionStaleWriteError {
+	return {
+		code: 'stale_write',
+		message: `Expected revision ${expectedRevision} does not match current revision ${session.revision}.`,
+		sessionId: session.sessionId,
+		canonicalPathKey: session.canonicalPathKey,
+		expectedRevision,
+		actualRevision: session.revision,
+	};
+}

package/src/services/snapshot-utils.ts

@@ -0,0 +1,43 @@
+import type {
+	BackendCacheEntry,
+	BackendCapabilities,
+	BackendEvent,
+	BackendJobSnapshot,
+} from '../runtime.js';
+
+function cloneJsonValue<T>(value: T): T {
+	if (value === undefined || value === null) return value;
+	return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export function cloneEventSnapshot(event: BackendEvent): BackendEvent {
+	return {
+		...event,
+		diagnostics: event.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+		payload: cloneJsonValue(event.payload),
+	};
+}
+
+export function cloneJobSnapshot(job: BackendJobSnapshot): BackendJobSnapshot {
+	return {
+		...job,
+		diagnostics: job.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+		progress: job.progress ? { ...job.progress } : undefined,
+		result: cloneJsonValue(job.result),
+		error: cloneJsonValue(job.error),
+	};
+}
+
+export function cloneCacheEntrySnapshot(entry: BackendCacheEntry): BackendCacheEntry {
+	return {
+		...entry,
+		summary: {
+			...entry.summary,
+			diagnostics: entry.summary.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+		},
+	};
+}
+
+export function cloneCapabilitiesSnapshot(capabilities: BackendCapabilities): BackendCapabilities {
+	return cloneJsonValue(capabilities);
+}