@openfairygui/backend 0.2.0-alpha.1 → 0.2.0-alpha.13

package/src/services/runtime-service.ts

@@ -1,4 +1,5 @@
-import { ProjectReader, liftDocumentToUamProject, normalizeUamProject } from '@openfairygui/core';
+import { ProjectReader, type FileSystem } from '@openfairygui/core/project-io';
+import { liftDocumentToUamProject, normalizeUamProject } from '@openfairygui/core/uam';
 import { failure, success, type BackendContext, type BackendSessionState } from './context.js';
 import type { CacheService } from './cache-service.js';
 import type { EventService } from './event-service.js';
@@ -13,14 +14,16 @@ import type {
 	OpenProjectSessionInput,
 	SessionNotFoundError,
 } from '../runtime.js';
-import { resolveCanonicalProjectRoot } from '../path-policy.js';
+import { normalizeComparablePath, 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)}`;
 }
 
-function createCapabilityUnavailableError(capability: BackendCapabilityUnavailableError['capability']): BackendCapabilityUnavailableError {
+function createCapabilityUnavailableError(
+	capability: BackendCapabilityUnavailableError['capability'],
+): BackendCapabilityUnavailableError {
 	const artifactCapability = capability === 'artifact.publish' || capability === 'artifact.restore';
 	return {
 		code: 'capability_unavailable',
@@ -34,7 +37,7 @@ function createCapabilityUnavailableError(capability: BackendCapabilityUnavailab
 	};
 }
 
-function createProjectReaderFileSystem(fileSystem: NonNullable<BackendContext['fileSystem']>): import('@openfairygui/core').FileSystem {
+function createProjectReaderFileSystem(fileSystem: NonNullable<BackendContext['fileSystem']>): FileSystem {
 	return {
 		readFile(filePath: string): Promise<string> {
 			return fileSystem.readFile(filePath);
@@ -79,7 +82,14 @@ export class RuntimeService {
 		private readonly jobService: JobService,
 	) {}
 
-	public async openSession(input: { projectPath: string }): Promise<BackendResult<BackendSessionSnapshot, InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError>> {
+	public async openSession(input: {
+		projectPath: string;
+	}): Promise<
+		BackendResult<
+			BackendSessionSnapshot,
+			InProcessLockConflictError | AdvisoryLockConflictError | BackendCapabilityUnavailableError
+		>
+	> {
 		const startedAt = Date.now();
 		if (!this.context.fileSystem) {
 			return failure('runtime', startedAt, createCapabilityUnavailableError('fileSystem'));
@@ -104,14 +114,18 @@ export class RuntimeService {
 		let advisoryLock: BackendFileHandle | null = null;
 		try {
 			advisoryLock = await fileSystem.openExclusive(lockFilePath);
-			await advisoryLock.writeFile(JSON.stringify(this.context.host?.lockMetadata?.({
-				canonicalPathKey,
-				canonicalProjectPath,
-				lockFilePath,
-			}) ?? {
-				createdAt: new Date().toISOString(),
-				canonicalPathKey,
-			}));
+			await advisoryLock.writeFile(
+				JSON.stringify(
+					this.context.host?.lockMetadata?.({
+						canonicalPathKey,
+						canonicalProjectPath,
+						lockFilePath,
+					}) ?? {
+						createdAt: new Date().toISOString(),
+						canonicalPathKey,
+					},
+				),
+			);
 			await advisoryLock.close();
 
 			const reader = new ProjectReader(createProjectReaderFileSystem(fileSystem));
@@ -123,6 +137,7 @@ export class RuntimeService {
 				canonicalProjectPath,
 				canonicalPathKey,
 				lockFilePath,
+				fileSystem,
 				project,
 				revision: 0,
 				lastSavedRevision: 0,
@@ -160,8 +175,14 @@ export class RuntimeService {
 	public openProjectSession(input: OpenProjectSessionInput): BackendResult<BackendSessionSnapshot> {
 		const startedAt = Date.now();
 		const sessionId = input.sessionId ?? randomId();
-		const canonicalProjectPath = input.canonicalProjectPath ?? `memory://${sessionId}`;
-		const canonicalPathKey = input.canonicalPathKey ?? canonicalProjectPath.toLowerCase();
+		const storage = input.storage;
+		const memoryProjectPath = `memory://${sessionId}`;
+		const canonicalProjectPath = storage?.canonicalProjectPath
+			?? input.canonicalProjectPath
+			?? (storage ? storage.fileSystem.dirname(storage.fairyPath) || '.' : memoryProjectPath);
+		const canonicalPathKey = storage?.canonicalPathKey
+			?? input.canonicalPathKey
+			?? (storage ? normalizeComparablePath(canonicalProjectPath) : canonicalProjectPath.toLowerCase());
 		const existingSessionId = this.context.sessionsByPath.get(canonicalPathKey);
 		if (existingSessionId) {
 			return failure('runtime', startedAt, {
@@ -175,10 +196,11 @@ export class RuntimeService {
 
 		const session: BackendSessionState = {
 			sessionId,
-			fairyPath: canonicalProjectPath,
+			fairyPath: storage?.fairyPath ?? canonicalProjectPath,
 			canonicalProjectPath,
 			canonicalPathKey,
 			lockFilePath: '',
+			fileSystem: storage?.fileSystem,
 			project: normalizeUamProject(input.project),
 			revision: 0,
 			lastSavedRevision: 0,
@@ -197,16 +219,21 @@ export class RuntimeService {
 		});
 	}
 
-	public async closeSession(
-		input: { sessionId: string },
-	): Promise<BackendResult<{ sessionId: string; closed: true }, SessionNotFoundError>> {
+	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 });
+		this.eventService.emit({
+			kind: 'session.closeRequested',
+			sessionId: session.sessionId,
+			canonicalPathKey: session.canonicalPathKey,
+			revision: session.revision,
+		});
 		if (this.context.fileSystem && session.lockFilePath) {
 			await this.context.fileSystem.unlink(session.lockFilePath).catch(() => undefined);
 		}
@@ -216,12 +243,22 @@ export class RuntimeService {
 		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.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 });
+		return success(
+			'runtime',
+			startedAt,
+			{
+				sessionId: session.sessionId,
+				closed: true,
+			},
+			{ sessionId: session.sessionId, revision: session.revision },
+		);
 	}
 }

package/src/storage.ts

@@ -0,0 +1,192 @@
+import type { FileSystem as CoreProjectFileSystem } from '@openfairygui/core/project-io';
+import type { BackendFileHandle, BackendFileStat, BackendFileSystem } from './runtime.js';
+
+type StorageStatKind = 'file' | 'directory';
+
+export interface BackendStorageStatLike {
+	kind?: StorageStatKind;
+	type?: StorageStatKind;
+	isFile?(): boolean;
+	isDirectory?(): boolean;
+}
+
+export interface BackendAsyncStorageAdapter {
+	readFile(filePath: string): Promise<string>;
+	readFileRaw(filePath: string): Promise<Uint8Array>;
+	writeFile(filePath: string, content: string): Promise<void>;
+	writeFileRaw(filePath: string, data: Uint8Array): Promise<void>;
+	mkdir(dirPath: string, options?: { recursive?: boolean }): Promise<void>;
+	readdir(dirPath: string): Promise<string[]>;
+	exists?(filePath: string): Promise<boolean>;
+	stat?(filePath: string): Promise<BackendStorageStatLike>;
+	resolvePath?(filePath: string): Promise<string>;
+	openExclusive?(filePath: string): Promise<BackendFileHandle>;
+	unlink?(filePath: string): Promise<void>;
+	join?(...paths: string[]): string;
+	dirname?(filePath: string): string;
+	resolve?(...paths: string[]): string;
+}
+
+class StorageFileStat implements BackendFileStat {
+	public constructor(private readonly kind: StorageStatKind) {}
+
+	public isFile(): boolean {
+		return this.kind === 'file';
+	}
+
+	public isDirectory(): boolean {
+		return this.kind === 'directory';
+	}
+}
+
+function createPathError(code: string, message: string): Error & { code: string } {
+	const error = new Error(message) as Error & { code: string };
+	error.code = code;
+	return error;
+}
+
+function normalizeStoragePath(value: string): string {
+	const normalized = value.replace(/\\/g, '/').replace(/\/+/g, '/');
+	const absolute = normalized.startsWith('/');
+	const rawSegments = normalized.split('/').filter((segment) => segment.length > 0);
+	const segments: string[] = [];
+
+	for (const segment of rawSegments) {
+		if (segment === '.') continue;
+		if (segment === '..') {
+			if (segments.length > 0) segments.pop();
+			continue;
+		}
+		segments.push(segment);
+	}
+
+	const joined = segments.join('/');
+	if (absolute) return joined ? `/${joined}` : '/';
+	return joined || '.';
+}
+
+function joinStoragePath(...paths: string[]): string {
+	return normalizeStoragePath(paths.filter((part) => part.length > 0).join('/'));
+}
+
+function dirnameStoragePath(filePath: string): string {
+	const normalized = normalizeStoragePath(filePath);
+	if (normalized === '/' || normalized === '.') return '.';
+	const absolute = normalized.startsWith('/');
+	const parts = normalized.split('/').filter((part) => part.length > 0);
+	parts.pop();
+	if (parts.length === 0) return absolute ? '/' : '.';
+	return `${absolute ? '/' : ''}${parts.join('/')}`;
+}
+
+function statFromLike(stat: BackendStorageStatLike): BackendFileStat {
+	if (typeof stat.isFile === 'function' && typeof stat.isDirectory === 'function') {
+		return stat as BackendFileStat;
+	}
+	const kind = stat.kind ?? stat.type;
+	if (kind === 'file' || kind === 'directory') return new StorageFileStat(kind);
+	throw createPathError('EINVAL', 'Storage stat must provide kind/type or isFile()/isDirectory().');
+}
+
+async function inferStat(storage: BackendAsyncStorageAdapter, filePath: string): Promise<BackendFileStat> {
+	if (storage.stat) return statFromLike(await storage.stat(filePath));
+
+	try {
+		await storage.readdir(filePath);
+		return new StorageFileStat('directory');
+	} catch {
+		// Try file probes below.
+	}
+
+	try {
+		await storage.readFileRaw(filePath);
+		return new StorageFileStat('file');
+	} catch {
+		try {
+			await storage.readFile(filePath);
+			return new StorageFileStat('file');
+		} catch {
+			throw createPathError('ENOENT', `Storage path not found: ${filePath}`);
+		}
+	}
+}
+
+export type BackendStorageFileSystem = BackendFileSystem & CoreProjectFileSystem;
+
+export function createBackendStorageFileSystem(storage: BackendAsyncStorageAdapter): BackendStorageFileSystem {
+	const lockedPaths = new Set<string>();
+
+	const fileSystem: BackendStorageFileSystem = {
+		stat(filePath: string): Promise<BackendFileStat> {
+			return inferStat(storage, fileSystem.resolve(filePath));
+		},
+		readdir(dirPath: string): Promise<string[]> {
+			return storage.readdir(fileSystem.resolve(dirPath));
+		},
+		readFile(filePath: string): Promise<string> {
+			return storage.readFile(fileSystem.resolve(filePath));
+		},
+		readFileRaw(filePath: string): Promise<Uint8Array> {
+			return storage.readFileRaw(fileSystem.resolve(filePath));
+		},
+		writeFile(filePath: string, content: string): Promise<void> {
+			return storage.writeFile(fileSystem.resolve(filePath), content);
+		},
+		writeFileRaw(filePath: string, data: Uint8Array): Promise<void> {
+			return storage.writeFileRaw(fileSystem.resolve(filePath), data);
+		},
+		mkdir(dirPath: string, options?: { recursive?: boolean }): Promise<void> {
+			return storage.mkdir(fileSystem.resolve(dirPath), options);
+		},
+		async exists(filePath: string): Promise<boolean> {
+			if (storage.exists) return storage.exists(fileSystem.resolve(filePath));
+			try {
+				await fileSystem.stat(filePath);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		resolvePath(filePath: string): Promise<string> {
+			const resolved = fileSystem.resolve(filePath);
+			return storage.resolvePath ? storage.resolvePath(resolved) : Promise.resolve(resolved);
+		},
+		async openExclusive(filePath: string): Promise<BackendFileHandle> {
+			const resolved = fileSystem.resolve(filePath);
+			if (storage.openExclusive) return storage.openExclusive(resolved);
+			if (lockedPaths.has(resolved) || await fileSystem.exists(resolved)) {
+				throw createPathError('EEXIST', `Storage path already exists: ${resolved}`);
+			}
+			lockedPaths.add(resolved);
+			let closed = false;
+			return {
+				async writeFile(content: string): Promise<void> {
+					if (closed) throw createPathError('EBADF', `Storage lock handle is closed: ${resolved}`);
+					await fileSystem.mkdir(fileSystem.dirname(resolved), { recursive: true });
+					await storage.writeFile(resolved, content);
+				},
+				async close(): Promise<void> {
+					closed = true;
+					lockedPaths.delete(resolved);
+				},
+			};
+		},
+		unlink(filePath: string): Promise<void> {
+			const resolved = fileSystem.resolve(filePath);
+			lockedPaths.delete(resolved);
+			if (storage.unlink) return storage.unlink(resolved);
+			throw createPathError('ENOTSUP', 'Storage adapter does not provide unlink().');
+		},
+		join(...paths: string[]): string {
+			return storage.join ? storage.join(...paths) : joinStoragePath(...paths);
+		},
+		dirname(filePath: string): string {
+			return storage.dirname ? storage.dirname(filePath) : dirnameStoragePath(filePath);
+		},
+		resolve(...paths: string[]): string {
+			return storage.resolve ? storage.resolve(...paths) : joinStoragePath(...paths);
+		},
+	};
+
+	return fileSystem;
+}