Re-Sync

Author: NikolaRHristov

Source/Command/ProcessUserData/Error.ts

@@ -0,0 +1,22 @@
+/**
+ * @module Error (ProcessUserData)
+ * @description Defines custom, tagged errors for the ProcessUserData command workflow.
+ */
+
+import { Data } from "effect";
+
+export class ActiveEditorNotFoundError extends Data.TaggedError(
+	"ActiveEditorNotFoundError",
+)<{}> {
+	message = "No active text editor found. Please open a file to process.";
+}
+
+export class ProcessingServiceError extends Data.TaggedError(
+	"ProcessingServiceError",
+)<{
+	readonly cause: unknown;
+}> {
+	get message() {
+		return `Failed to connect to the processing service: ${this.cause}`;
+	}
+}

Source/Command/ProcessUserData/GetActiveTextEditor.ts

@@ -0,0 +1,16 @@
+/**
+ * @module GetActiveTextEditor
+ * @description An Effect that retrieves the active VS Code text editor.
+ */
+
+import { Effect, Option } from "effect";
+import * as Vscode from "vscode";
+
+/**
+ * An Effect that safely retrieves the active text editor.
+ * @returns An `Effect` that resolves to an `Option<Vscode.TextEditor>`, which
+ * will be `None` if no editor is active, and `Some` otherwise.
+ */
+export const GetActiveTextEditor = Effect.sync(() =>
+	Option.fromNullable(Vscode.window.activeTextEditor),
+);

Source/Command/ProcessUserData/GetDocumentText.ts

@@ -0,0 +1,16 @@
+/**
+ * @module GetDocumentText
+ * @description An Effect that retrieves the full text content of a document.
+ */
+
+import { Effect } from "effect";
+import type * as Vscode from "vscode";
+
+/**
+ * An Effect that gets the full text content of a given document.
+ * @param Document - The `vscode.TextDocument` to read from.
+ * @returns An `Effect` that synchronously resolves to the document's text content.
+ */
+export const GetDocumentText = (
+	Document: Vscode.TextDocument,
+): Effect.Effect<string> => Effect.sync(() => Document.getText());

Source/Command/ProcessUserData/InvokeProcessingService.ts

@@ -0,0 +1,39 @@
+/**
+ * @module InvokeProcessingService
+ * @description An Effect that sends text to a backend service for processing.
+ */
+
+import { Effect } from "effect";
+
+import { ProcessingServiceError } from "./Error.js";
+
+interface ProcessingResult {
+	Id: string;
+	Status: "Success";
+}
+
+/**
+ * An Effect that makes a `fetch` request to a local backend service.
+ * @param TextContent - The text to be processed.
+ * @returns An `Effect` that resolves to the JSON result from the service,
+ *   or fails with a `ProcessingServiceError`.
+ */
+export const InvokeProcessingService = (
+	TextContent: string,
+): Effect.Effect<ProcessingResult, ProcessingServiceError> =>
+	Effect.tryPromise({
+		try: () =>
+			fetch("http://localhost:3000/process", {
+				method: "POST",
+				headers: { "Content-Type": "text/plain" },
+				body: TextContent,
+			}).then((Response) => {
+				if (!Response.ok) {
+					throw new Error(
+						`Server responded with status: ${Response.status}`,
+					);
+				}
+				return Response.json() as Promise<ProcessingResult>;
+			}),
+		catch: (cause) => new ProcessingServiceError({ cause }),
+	});

Source/Command/ProcessUserData/mod.ts

@@ -0,0 +1,58 @@
+/**
+ * @module ProcessUserData (Command)
+ * @description The main module for the 'ProcessUserData' command.
+ *
+ * This orchestrates the entire workflow of getting text from the active
+ * editor, sending it to a backend service for processing, and then
+ * displaying the result to the user.
+ */
+
+import { Effect, pipe } from "effect";
+
+import { InvokeProcessingService } from "../../Service/Mountain/InvokeProcessingService.js";
+import { GetActiveTextEditor } from "../../Service/Window/GetActiveTextEditor.js";
+import {
+	ShowErrorMessage,
+	ShowInformationMessage,
+} from "../../Service/Window/mod.js";
+import { ActiveEditorNotFoundError, ProcessingServiceError } from "./Error.js";
+import { GetDocumentText } from "./GetDocumentText.js";
+
+/**
+ * An `Effect` that encapsulates the entire workflow for processing user data
+ * from the active text editor, demonstrating declarative, type-safe error
+ * handling.
+ */
+export const ProcessUserData = pipe(
+	Effect.gen(function* (_) {
+		// Safely get the active editor, which may not exist.
+		const MaybeEditor = yield* _(GetActiveTextEditor);
+
+		// Convert the Option into an Effect that fails with our specific error if empty.
+		const Editor = yield* _(
+			MaybeEditor,
+			Effect.mapError(() => new ActiveEditorNotFoundError()),
+		);
+
+		// If the above succeeds, the workflow proceeds.
+		const TextContent = yield* _(GetDocumentText(Editor.document));
+		const ProcessingResult = yield* _(InvokeProcessingService(TextContent));
+		yield* _(
+			ShowInformationMessage(
+				`Processing complete: ${ProcessingResult.Id}`,
+			),
+		);
+	}),
+	// Declaratively handle all known, tagged failure cases for this workflow.
+	Effect.catchTags({
+		ActiveEditorNotFoundError: (Error) => ShowErrorMessage(Error.message),
+		ProcessingServiceError: (Error) => ShowErrorMessage(Error.message),
+	}),
+	// Catch any other unexpected error that might have occurred, safely handling
+	// the error type.
+	Effect.catchAll((Error) =>
+		ShowErrorMessage(
+			`An unexpected error occurred: ${Error instanceof Error ? Error.message : String(Error)}`,
+		),
+	),
+);

Source/Core/ApiFactory/AsExtensionEvent.ts

@@ -0,0 +1,50 @@
+/**
+ * @module AsExtensionEvent
+ * @description Defines a higher-order function that wraps a raw event emitter
+ * to provide safe error handling for extension listeners.
+ */
+
+import type * as Vscode from "vscode";
+
+import type { Log } from "../../Service/mod.js";
+
+/**
+ * Creates a safe `vscode.Event` by wrapping an existing event emitter.
+ *
+ * This function takes a raw `Event` and returns a new `Event` function. When an
+ * extension subscribes to the new event, its listener is wrapped in a
+ * `try...catch` block. This prevents a faulty or poorly-written listener in
+ * one extension from throwing an unhandled exception and crashing the entire
+ * extension host. Any errors caught are logged using the provided `LogService`.
+ *
+ * @param ExtensionId The identifier of the extension that will be listening.
+ * @param LogService An instance of the logging service to report errors.
+ * @param ActualEvent The original `vscode.Event<T>` to wrap.
+ * @returns A new, safe `vscode.Event<T>` that can be exposed to extensions.
+ */
+export const AsExtensionEvent = <T>(
+	ExtensionId: Vscode.ExtensionIdentifier,
+	LogService: Log.Interface,
+	ActualEvent: Vscode.Event<T>,
+): Vscode.Event<T> => {
+	// Return a new event subscription function.
+	return (Listener, ThisArgument, Disposables) => {
+		// Create a "safe" listener that wraps the original extension-provided listener.
+		const SafeListener = (Event: T) => {
+			try {
+				Listener.call(ThisArgument, Event);
+			} catch (Error) {
+				LogService.Error(
+					`[${ExtensionId.value}] FAILED to handle event:`,
+					Error,
+				);
+				// This is also where telemetry reporting for extension errors would be triggered.
+			}
+		};
+
+		// Subscribe the safe listener to the actual event.
+		const Handle = ActualEvent(SafeListener);
+		Disposables?.push(Handle);
+		return Handle;
+	};
+};

Source/Core/ApiFactory/Create.ts

@@ -0,0 +1,116 @@
+/**
+ * @module CreateApiFactory
+ * @description The primary factory function that constructs the `vscode` API
+ * object for a given extension.
+ */
+
+import type { IExtensionDescription } from "vs/platform/extensions/common/extensions.js";
+import type * as Vscode from "vscode";
+
+import type * as Service from "../../Service/mod.js";
+import * as ExtHostType from "../../Type/ExtHostTypes.js";
+import { AsExtensionEvent } from "./AsExtensionEvent.js";
+import { CreateCommandsNamespace } from "./CreateCommandsNamespace.js";
+import { CreateLanguagesNamespace } from "./CreateLanguagesNamespace.js";
+import { CreateWindowNamespace } from "./CreateWindowNamespace.js";
+import { CreateWorkspaceNamespace } from "./CreateWorkspaceNamespace.js";
+import type { Interface as ApiFactory } from "./Service.js";
+
+// Placeholders for other namespace creators
+// import { CreateDebugNamespace } from "./CreateDebugNamespace.js";
+// import { CreateTasksNamespace } from "./CreateTasksNamespace.js";
+// import { CreateWebviewNamespace } from "./CreateWebviewNamespace.js";
+
+/**
+ * Creates an `ApiFactory` instance.
+ *
+ * This function uses a dependency injection pattern, taking all necessary
+ * extension host services as arguments. It returns a factory object with a
+ * `Create` method, which is then used to construct the specific `vscode` API
+ * object for each individual extension.
+ *
+ * @param LogService The service for logging messages.
+ * @param DeprecationService The service for handling API deprecations.
+ * @param CommandsService The service for command registration and execution.
+ * @param WorkspaceService The service for workspace-related information and events.
+ * @param WindowService The service for window-related UI and events.
+ * @param LanguageFeaturesService The service for registering language providers.
+ * @param StatusBarService The service for managing status bar items.
+ * @param WebviewPanelService The service for creating and managing webview panels.
+ * @param CustomEditorService The service for registering custom editors.
+ * @param TreeViewService The service for creating and managing tree views.
+ * @returns An `ApiFactory` object capable of creating `vscode` API instances.
+ */
+export const CreateApiFactory = (
+	LogService: Service.Log.Interface,
+	DeprecationService: Service.ApiDeprecation.Interface,
+	CommandsService: Service.Commands.Interface,
+	WorkspaceService: Service.Workspace.Interface,
+	WindowService: Service.Window.Interface,
+	LanguageFeaturesService: Service.LanguageFeatures.Interface,
+	StatusBarService: Service.StatusBar.Interface,
+	WebviewPanelService: Service.WebviewPanel.Interface,
+	CustomEditorService: Service.CustomEditor.Interface,
+	TreeViewService: Service.TreeView.Interface,
+	// Add other services like Debug, Tasks, etc. as they are implemented
+): ApiFactory => ({
+	/**
+	 * Creates a new, sandboxed `vscode` API object for a specific extension.
+	 * @param Extension The full description of the extension.
+	 * @returns A frozen `vscode` API object.
+	 */
+	Create: (Extension: IExtensionDescription): typeof Vscode => {
+		// --- Create Namespaces ---
+		const CommandsNamespace = CreateCommandsNamespace(
+			CommandsService,
+			Extension,
+		);
+		const WorkspaceNamespace = CreateWorkspaceNamespace(
+			WorkspaceService,
+			DeprecationService,
+			Extension,
+		);
+		const WindowNamespace = CreateWindowNamespace(
+			WindowService,
+			WorkspaceService,
+			StatusBarService,
+			WebviewPanelService,
+			CustomEditorService,
+			TreeViewService,
+			(Event) =>
+				AsExtensionEvent(Extension.identifier, LogService, Event),
+			Extension,
+		);
+		const LanguagesNamespace = CreateLanguagesNamespace(
+			LanguageFeaturesService,
+			Extension,
+		);
+		// const DebugNamespace = CreateDebugNamespace(DebugService, Extension);
+		// const TasksNamespace = CreateTasksNamespace(TasksService, Extension);
+
+		// --- Assemble Final API Object ---
+		const Api = {
+			// This version should come from a centralized product service.
+			version: "1.85.0",
+			commands: CommandsNamespace,
+			window: WindowNamespace,
+			workspace: WorkspaceNamespace,
+			languages: LanguagesNamespace,
+			// Other namespaces would be added here.
+			// debug: DebugNamespace,
+			// tasks: TasksNamespace,
+
+			// --- Static Types and Enums from VS Code ---
+			...ExtHostType,
+		};
+
+		// --- Freeze API to prevent runtime modification by extensions ---
+		Object.freeze(Api.commands);
+		Object.freeze(Api.window);
+		Object.freeze(Api.workspace);
+		Object.freeze(Api.languages);
+		// ... freeze other namespaces ...
+
+		return Object.freeze(Api) as typeof Vscode;
+	},
+});

Source/Core/ApiFactory/CreateCommandsNamespace.ts

@@ -0,0 +1,62 @@
+/**
+ * @module CreateCommandsNamespace
+ * @description Constructs the `vscode.commands` namespace for the API object
+ * provided to an extension.
+ */
+
+import { Effect } from "effect";
+import type { IExtensionDescription } from "vs/platform/extensions/common/extensions.js";
+import type * as Vscode from "vscode";
+
+import type { Commands as CommandsService } from "../../Service/mod.js";
+
+/**
+ * Creates the `vscode.commands` namespace object.
+ *
+ * This factory function takes the central `CommandsService` and the specific
+ * extension's description to create a sandboxed `commands` object. The methods
+ * on this object delegate to the central service, ensuring that command
+ * registration and execution are managed globally while providing the standard
+ * `vscode` API to the extension.
+ *
+ * @param CommandsService The central service for command management.
+ * @param Extension The description of the extension for which this API is being created.
+ * @returns An object that implements the `vscode.commands` API.
+ */
+export const CreateCommandsNamespace = (
+	CommandsService: CommandsService.Interface,
+	Extension: IExtensionDescription,
+): typeof Vscode.commands => ({
+	/**
+	 * Registers a command.
+	 */
+	registerCommand: (Id, Handler, ThisArgument) =>
+		CommandsService.RegisterCommand(Id, Handler, ThisArgument, Extension),
+
+	/**
+	 * Registers a command that is only active when a text editor has focus.
+	 */
+	registerTextEditorCommand: (Id, Handler, ThisArgument) =>
+		CommandsService.RegisterTextEditorCommand(
+			Id,
+			Handler,
+			ThisArgument,
+			Extension,
+		),
+
+	/**
+	 * Executes a command.
+	 * It converts the `Effect`-based service call into a `Promise`, as
+	 * expected by the `vscode` API.
+	 */
+	executeCommand: <T>(Id: string, ...Argument: any[]) =>
+		Effect.runPromise(CommandsService.ExecuteCommand<T>(Id, ...Argument)),
+
+	/**
+	 * Retrieves a list of all available command IDs.
+	 * It converts the `Effect`-based service call into a `Promise`, as
+	 * expected by the `vscode` API.
+	 */
+	getCommands: (FilterInternal?: boolean) =>
+		Effect.runPromise(CommandsService.GetCommands(FilterInternal)),
+});