@shivaedev/work-board 0.15.0 → 0.17.0

package/src/server/rpc/handlers.ts

@@ -1,19 +1,19 @@
 import { Effect, Layer, Ref, Stream } from "effect";
-import { InternalServerError, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { InternalServerError, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
 import { requestTracingLayer } from "@shivaedev/platform/rpc-server/tracing.ts";
-import { Diagnostics } from "#diagnostics/source.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import { DocumentRejection, ResponseRejection } from "#rpc/rejections.ts";
 import { HandoffsService } from "#server/handoffs/Service.ts";
 import { libraryData } from "#server/navigation/libraryData.ts";
 import { navigationData } from "#server/navigation/model.ts";
-import { Responses } from "#server/responses/service.ts";
+import { Responses } from "#server/Responses.ts";
 import { searchMatch } from "#server/search/match.ts";
 import { fleetItems } from "#server/views/fleetItems.ts";
 import { goals } from "#server/views/goals.ts";
 import { projectionQueries } from "#server/views/projectionQueries.ts";
 import { remainingQueries } from "#server/views/remainingQueries.ts";
+import { Workspace } from "#server/workspace.ts";
 import type { HandlerOptions } from "./HandlerOptions.ts";
 import { hints } from "./hints.ts";
 
@@ -21,25 +21,29 @@ const readBoundary = rpcBoundary(InternalServerError, { unexpected: (message) =>
 const documentBoundary = rpcBoundary(DocumentRejection, { unexpected: (message) => new InternalServerError({ message }) });
 const responseBoundary = rpcBoundary(ResponseRejection, { unexpected: (message) => new InternalServerError({ message }) });
 
-export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: HandlerOptions) {
-	const { changes, document, home, index } = options;
-	const projections = projectionQueries({ document, index });
+export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: HandlerOptions = {}) {
+	const workspace = yield* Workspace;
+	const { changes, home } = yield* workspace.settings();
+	const index = workspace.index();
+	const document = workspace.document;
+	const projections = yield* projectionQueries;
 	const handoffs = yield* HandoffsService;
 	const responses = yield* Responses;
-	const diagnostics = yield* Diagnostics;
-	const remaining = remainingQueries(options, { diagnostics, handoffs, responses });
+	const remaining = yield* remainingQueries;
 	return workRpcs
 		.toLayer({
 			"work-board.awaitResponse": (input) => Effect.suspend(() => responses.awaitResponse(input)).pipe(responseBoundary),
 			"work-board.board": ({ url }) => Effect.suspend(() => projections.board(url)).pipe(documentBoundary),
 			"work-board.diagnostics": () => remaining.diagnostics().pipe(readBoundary),
-			"work-board.document": ({ url }) =>
-				Effect.suspend(() => (document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." })))).pipe(documentBoundary),
-			"work-board.fleetItems": () => fleetItems(options),
+			"work-board.document": ({ url }) => Effect.suspend(() => document(url)).pipe(documentBoundary),
+			"work-board.fleetItems": () => fleetItems(options.fleetPort).pipe(readBoundary),
 			"work-board.goals": () =>
 				Effect.gen(function* () {
 					const snapshot = yield* index;
-					return goals(snapshot, yield* fleetItems({ ...options, index: Effect.succeed(snapshot) }));
+					return goals(
+						snapshot,
+						yield* fleetItems(options.fleetPort).pipe(Effect.provideService(Workspace, { ...workspace, index: () => Effect.succeed(snapshot) })),
+					);
 				}).pipe(readBoundary),
 			"work-board.handoff": ({ url }) => remaining.handoff(url).pipe(documentBoundary),
 			"work-board.handoffSource": ({ item }) => Effect.suspend(() => handoffs.locate(item)).pipe(responseBoundary),
@@ -57,7 +61,6 @@ export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: Hand
 			"work-board.question": ({ item, request }) => Effect.suspend(() => responses.locate(item, request)).pipe(responseBoundary),
 			"work-board.recordResponse": (input) => Effect.suspend(() => responses.record(input)).pipe(responseBoundary),
 			"work-board.registerQuestion": (input) => Effect.suspend(() => responses.register(input)).pipe(responseBoundary),
-			"work-board.respond": ({ url }) => remaining.respond(url).pipe(documentBoundary),
 			"work-board.responses": ({ question }) => Effect.suspend(() => responses.read(question)).pipe(responseBoundary),
 			"work-board.result": ({ url }) => remaining.result(url).pipe(documentBoundary),
 			"work-board.search": ({ query }) =>
@@ -66,8 +69,7 @@ export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: Hand
 				),
 			"work-board.server": () => options.server ?? Effect.fail(new ServiceUnavailable({ message: "The board server address is unavailable." })),
 			"work-board.start": () => remaining.start().pipe(readBoundary),
-			"work-board.subscribe": () =>
-				hints(changes, index).pipe(Stream.catchCause((cause) => Stream.fromEffect(Effect.failCause(cause).pipe(readBoundary)))),
+			"work-board.subscribe": () => hints().pipe(Stream.catchCause((cause) => Stream.fromEffect(Effect.failCause(cause).pipe(readBoundary)))),
 			"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })).pipe(readBoundary),
 			"work-board.work": ({ url }) => Effect.suspend(() => projections.work(url)).pipe(documentBoundary),
 		})

package/src/server/rpc/hints.ts

@@ -1,12 +1,15 @@
 import { Effect, PubSub, Stream } from "effect";
 import type { LiveHint } from "@shivaedev/effect-contract/live.ts";
-import type { Change, Changes } from "#server/files/changes.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
+import type { Change } from "#server/files/changes.ts";
+import { Workspace } from "#server/workspace.ts";
 import { affected } from "./affected.ts";
 
-export function hints(changes: Changes, index: Effect.Effect<Snapshot, unknown>) {
+export function hints() {
 	return Stream.unwrap(
 		Effect.gen(function* () {
+			const workspace = yield* Workspace;
+			const { changes } = yield* workspace.settings();
+			const index = workspace.index();
 			const subscription = yield* PubSub.subscribe(changes.events);
 			let sequence = changes.sequence ? yield* changes.sequence : undefined;
 			let previous = yield* Effect.option(index);

package/src/server/views/fleetItems.ts

@@ -2,10 +2,10 @@ import { Effect } from "effect";
 import type { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
 import { DAEMON_PORT } from "#diagnostics/daemonContract.ts";
 import { daemonUnavailableReason, readDaemon } from "#server/diagnostics/daemon.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
 import { itemsOf } from "#server/views/items.ts";
+import { Workspace } from "#server/workspace.ts";
 
-export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptions, "index" | "fleetPort">): Effect.Effect<FleetItemsProjection> {
+export function fleetItems(fleetPort: number | null = DAEMON_PORT): Effect.Effect<FleetItemsProjection, never, Workspace> {
 	if (fleetPort === null) {
 		return Effect.succeed({ reason: "Fleet daemon is not configured for this Board", state: "unavailable" });
 	}
@@ -15,7 +15,11 @@ export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptio
 			return { reason: daemonUnavailableReason(result.failure, fleetPort), state: "unavailable" as const };
 		}
 		const data = result.success;
-		const snapshot = yield* index;
+		const workspace = yield* Workspace;
+		const snapshot = yield* workspace.index().pipe(Effect.catch(() => Effect.succeed(undefined)));
+		if (!snapshot) {
+			return { reason: "Board documents could not be read for Fleet items", state: "unavailable" as const };
+		}
 		const documents = new Map(
 			itemsOf(snapshot).map(({ id, document, title }) => [id, { file: document.file, metadata: document.parsed.fields, title }]),
 		);
@@ -24,5 +28,5 @@ export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptio
 			items: data.items.map((item) => ({ ...item, document: documents.get(item.workId) ?? null })),
 			state: "ready" as const,
 		};
-	}).pipe(Effect.catchCause(() => Effect.succeed({ reason: "Board documents could not be read for Fleet items", state: "unavailable" as const })));
+	});
 }

package/src/server/views/projectionQueries.ts

@@ -1,21 +1,20 @@
 import { Effect } from "effect";
-import { NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { BoardProjection, WorkProjection } from "#browser/views/schema.ts";
 import { stateOf } from "#browser/views/state.ts";
 import { inboxItems } from "#server/attention/inbox.ts";
 import { attentionProjection } from "#server/attention/projection.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import { boardOf, countsOf } from "#server/render/board.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import { Workspace } from "#server/workspace.ts";
 import { fleetApproval } from "./fleetApproval.ts";
 import type { Item } from "./items.ts";
 import { projectItems } from "./projection.ts";
 
-export function projectionQueries({ index, document }: { readonly index: HandlerOptions["index"]; readonly document: HandlerOptions["document"] }) {
-	function read(url: string) {
-		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
-	}
+export const projectionQueries = Effect.gen(function* () {
+	const workspace = yield* Workspace;
+	const index = workspace.index();
+	const read = workspace.document;
 	return {
 		board: (url: string) => Effect.map(read(url), (data): BoardProjection => ({ counts: countsOf(boardOf(data.source)), document: data })),
 		inbox: () => Effect.map(index, attentionProjection),
@@ -54,7 +53,7 @@ export function projectionQueries({ index, document }: { readonly index: Handler
 				} satisfies WorkProjection;
 			}),
 	};
-}
+});
 function selectionProblem(snapshot: Snapshot, item: string) {
 	return (snapshot.model.ids.get(item)?.length ?? 0) > 1 ? "has a duplicate ID" : "is missing or its identity changed";
 }

package/src/server/views/remainingQueries.ts

@@ -1,24 +1,18 @@
 import { Clock, Effect } from "effect";
-import { Conflict, NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
-import type { Diagnostics } from "#diagnostics/source.ts";
-import type { HandoffsService } from "#server/handoffs/Service.ts";
+import { Conflict } from "@shivaedev/platform/errors/taxonomy.ts";
+import { Diagnostics } from "#diagnostics/source.ts";
+import { HandoffsService } from "#server/handoffs/Service.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import { metadataParse } from "#server/metadata/parse.ts";
 import { startTemplates } from "#server/page/startTemplates.ts";
-import type { Responses } from "#server/responses/service.ts";
-import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import { Workspace } from "#server/workspace.ts";
 import { resultProjection } from "./resultProjection.ts";
-export function remainingQueries(
-	{ changes, document, index, writable }: HandlerOptions,
-	services: {
-		readonly diagnostics: typeof Diagnostics.Service;
-		readonly responses: typeof Responses.Service;
-		readonly handoffs: typeof HandoffsService.Service;
-	},
-) {
-	function read(url: string) {
-		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
-	}
+export const remainingQueries = Effect.gen(function* () {
+	const workspace = yield* Workspace;
+	const { changes, writable } = yield* workspace.settings();
+	const index = workspace.index();
+	const read = workspace.document;
+	const services = { diagnostics: yield* Diagnostics, handoffs: yield* HandoffsService };
 	return {
 		diagnostics: () =>
 			Effect.gen(function* () {
@@ -42,20 +36,6 @@ export function remainingQueries(
 					writable: writable === true,
 				};
 			}),
-		respond: (url: string) =>
-			Effect.gen(function* () {
-				const params = new URL(url, "http://127.0.0.1").searchParams;
-				const service = services.responses;
-				const preview = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
-				yield* service.read(preview.id).pipe(Effect.catch((error) => (error._tag === "NotFound" ? Effect.void : Effect.fail(error))));
-				const responses = yield* service.history(preview);
-				const data = yield* read(identityUrl(preview.item));
-				const request = data.requests.find((entry) => entry.id === preview.request);
-				if (!request) {
-					return yield* Effect.fail(new Conflict({ message: "The response request is unavailable." }));
-				}
-				return { document: data, request: { ...request, preview, responses } };
-			}),
 		result: (url: string) =>
 			Effect.gen(function* () {
 				const item = new URL(url, "http://127.0.0.1").searchParams.get("item") ?? "";
@@ -71,4 +51,4 @@ export function remainingQueries(
 			}),
 		start: () => Effect.map(changes.files, (files) => ({ empty: files.length === 0, templates: startTemplates })),
 	};
-}
+});

package/src/server/workspace.ts

@@ -0,0 +1,41 @@
+import { Context, Effect, FileSystem, Path, type PlatformError } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import type { Document } from "#browser/document/schema.ts";
+import { readDocument } from "#server/document/read.ts";
+import type { Changes } from "#server/files/changes.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export interface WorkspaceOptions {
+	readonly changes: Changes;
+	readonly home?: string | undefined;
+	readonly index: Effect.Effect<Snapshot, PlatformError.PlatformError>;
+	readonly root: string;
+	readonly writable: boolean;
+}
+
+export interface WorkspaceSettings extends Omit<WorkspaceOptions, "index"> {
+	readonly realRoot: string;
+}
+
+export class WorkspaceConfig extends Context.Service<WorkspaceConfig, WorkspaceOptions>()("WorkBoard/WorkspaceConfig") {}
+
+export const Workspace = defineService({
+	id: "WorkBoard/Workspace",
+	initialize: Effect.gen(function* () {
+		return yield* WorkspaceConfig;
+	}),
+	methods: ({ index, ...options }) => {
+		const settings = { ...options, realRoot: options.changes.realRoot };
+		const read = readDocument(settings);
+		function document(url: string): Effect.Effect<Document, Effect.Error<ReturnType<typeof read>>, Effect.Services<ReturnType<typeof read>>> {
+			return Effect.flatMap(index, (snapshot) => read(url, snapshot));
+		}
+		return {
+			document,
+			index: () => index,
+			settings: () => Effect.succeed(settings),
+		};
+	},
+	requires: [WorkspaceConfig, FileSystem.FileSystem, Path.Path],
+});
+export type Workspace = typeof Workspace.Identifier;