@openfairygui/backend 0.2.0 → 0.3.0-alpha.2

package/src/runtime.ts

@@ -1,4 +1,5 @@
 import type { ApplyUamTransactionAppError } from '@openfairygui/functions/uam';
+import type { ProjectValidationReport } from '@openfairygui/core';
 import type { PathPolicyViolationError } from './path-policy.js';
 import { AuthoringService } from './services/authoring-service.js';
 import { CacheService } from './services/cache-service.js';
@@ -21,6 +22,7 @@ import type {
 	BackendJobNotCancellableError,
 	BackendJobNotFoundError,
 	BackendJobSnapshot,
+	BackendProjectOutline,
 	BackendResult,
 	BackendRuntimeOptions,
 	BackendSessionSnapshot,
@@ -31,6 +33,8 @@ import type {
 	GetEventsInput,
 	GetEventsSnapshot,
 	GetJobInput,
+	GetProjectOutlineInput,
+	ValidateSessionInput,
 	InProcessLockConflictError,
 	ListJobsInput,
 	MaterializeSessionInput,
@@ -113,6 +117,18 @@ export class BackendRuntime {
 		return this.readService.getSession(input);
 	}
 
+	public getProjectOutline(
+		input: GetProjectOutlineInput,
+	): BackendResult<BackendProjectOutline, SessionNotFoundError> {
+		return this.readService.getProjectOutline(input);
+	}
+
+	public validateSession(
+		input: ValidateSessionInput,
+	): BackendResult<ProjectValidationReport, SessionNotFoundError> {
+		return this.readService.validateSession(input);
+	}
+
 	public async applyTransaction(
 		input: ApplySessionTransactionInput,
 	): Promise<

package/src/services/context.ts

@@ -29,6 +29,8 @@ export interface BackendSessionState {
 	sessionLock: BackendSessionLock | null;
 	fileSystem?: BackendFileSystem;
 	project: import('@openfairygui/core/uam').UamProject;
+	readDiagnostics: import('@openfairygui/core').ProjectDiagnostic[];
+	readComplete: boolean;
 	uamFidelity: 'full' | 'unsupported';
 	revision: number;
 	lastSavedRevision: number;

package/src/services/read-service.ts

@@ -1,6 +1,55 @@
-import { failure, success, type BackendContext } from './context.js';
-import type { BackendCapabilities, BackendResult, BackendSessionSnapshot, SessionNotFoundError } from '../runtime.js';
+import { failure, success, type BackendContext, type BackendSessionState } from './context.js';
+import type {
+	BackendCapabilities,
+	BackendProjectOutline,
+	BackendResult,
+	BackendSessionSnapshot,
+	GetProjectOutlineInput,
+	SessionNotFoundError,
+} from '../runtime.js';
 import { createSessionNotFoundError, toSessionSnapshot } from './session-utils.js';
+import { validateProject } from '@openfairygui/functions';
+import type { ProjectValidationReport } from '@openfairygui/core';
+
+function toProjectOutline(session: BackendSessionState): BackendProjectOutline {
+	const project = session.project;
+	// ponytail: full outline is O(project size); add filters or pagination only if payload size becomes a measured problem.
+	return {
+		sessionId: session.sessionId,
+		revision: session.revision,
+		projectId: project.projectId,
+		projectType: project.projectType,
+		version: project.version,
+		branches: [...project.branches],
+		packages: project.packages.map((pkg) => ({
+			id: pkg.id,
+			name: pkg.name,
+			branchNames: [...pkg.branchNames],
+			folders: pkg.folders.map((folder) => ({ branch: folder.branch, path: folder.path })),
+			resources: pkg.resources.map((resource) => ({
+				id: resource.id,
+				name: resource.name,
+				path: resource.path,
+				kind: resource.kind,
+				branch: resource.branch,
+				...(resource.kind === 'component' ? {
+					component: {
+						displayList: resource.component.displayList.map((node) => ({
+							id: node.id,
+							name: node.name,
+							kind: node.kind,
+						})),
+						controllers: resource.component.controllers.map((controller) => ({
+							name: controller.name,
+							pages: controller.pages.map((page) => ({ id: page.id, name: page.name })),
+						})),
+						transitions: resource.component.transitions.map((transition) => ({ name: transition.name })),
+					},
+				} : {}),
+			})),
+		})),
+	};
+}
 
 export class ReadService {
 	public constructor(private readonly context: BackendContext) {}
@@ -20,4 +69,38 @@ export class ReadService {
 			revision: session.revision,
 		});
 	}
+
+	public getProjectOutline(
+		input: GetProjectOutlineInput,
+	): BackendResult<BackendProjectOutline, 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, toProjectOutline(session), {
+			sessionId: session.sessionId,
+			revision: session.revision,
+		});
+	}
+
+	public validateSession(
+		input: { sessionId: string },
+	): BackendResult<ProjectValidationReport, SessionNotFoundError> {
+		const startedAt = Date.now();
+		const session = this.context.sessions.get(input.sessionId);
+		if (!session || session.closed) {
+			return failure('read', startedAt, createSessionNotFoundError(input.sessionId));
+		}
+		const report = validateProject(session.project, {
+			readDiagnostics: session.readDiagnostics,
+			complete: session.readComplete,
+			validateSources: true,
+		});
+		return success('read', startedAt, report, {
+			sessionId: session.sessionId,
+			revision: session.revision,
+			diagnostics: report.diagnostics.map(({ code, message, severity, path }) => ({ code, message, severity, path })),
+		});
+	}
 }

package/src/services/runtime-service.ts

@@ -220,7 +220,9 @@ export class RuntimeService {
 				),
 			);
 			const reader = new ProjectReader(createProjectReaderFileSystem(fileSystem));
-			const document = await reader.read(fairyPath, { hydrateResourceBytes: true });
+			const read = await reader.readDetailed(fairyPath, { hydrateResourceBytes: true });
+			if (!read.document) throw new Error(read.diagnostics[0]?.message ?? `Unable to read project: ${fairyPath}`);
+			const document = read.document;
 			const project = liftDocumentToUamProject(document);
 			const sessionId = randomId();
 			const session: BackendSessionState = {
@@ -232,6 +234,8 @@ export class RuntimeService {
 				sessionLock,
 				fileSystem,
 				project,
+				readDiagnostics: read.diagnostics,
+				readComplete: read.complete,
 				uamFidelity: (await hasFullUamFidelity(document, project)) ? 'full' : 'unsupported',
 				revision: 0,
 				lastSavedRevision: 0,
@@ -305,6 +309,8 @@ export class RuntimeService {
 			sessionLock: null,
 			fileSystem: storage?.fileSystem,
 			project: normalizeUamProject(input.project),
+			readDiagnostics: [],
+			readComplete: true,
 			uamFidelity: 'full',
 			revision: 0,
 			lastSavedRevision: 0,