@shivaedev/work-board 0.4.1 → 0.6.0

package/src/render/documentLinks.ts

@@ -1,17 +1,28 @@
 import { defineHastPlugin } from "satteri";
 import { fileUrl } from "#files/url.ts";
+import { attachmentHref } from "#path/attachment.ts";
 
 export function documentLinks(file: string) {
 	return defineHastPlugin({
 		element: {
-			filter: ["a"],
+			filter: ["a", "img"],
 			visit: (element) => {
-				const href = element.properties.href;
-				if (typeof href !== "string" || href.startsWith("#") || href.startsWith("/") || /^[a-z][a-z\d+.-]*:/iu.exec(href) !== null) {
+				const attribute = element.tagName === "img" ? "src" : "href";
+				const href = element.properties[attribute];
+				if (typeof href !== "string" || href.startsWith("#") || href.startsWith("//") || /^[a-z][a-z\d+.-]*:/iu.exec(href) !== null) {
 					return;
 				}
 				const target = new URL(href, `http://work-board.local${fileUrl(file)}`);
-				return { ...element, properties: { ...element.properties, href: target.pathname + target.search + target.hash } };
+				const resolved = target.pathname + target.search + target.hash;
+				const image = attachmentHref(resolved);
+				return {
+					...element,
+					properties: {
+						...element.properties,
+						[attribute]: image ?? resolved,
+						...(element.tagName === "img" && image ? { dataLocalImage: image } : {}),
+					},
+				};
 			},
 		},
 		name: "work-board-document-links",

package/src/rpc/affected.ts

@@ -0,0 +1,77 @@
+import type { Key } from "@shivaedev/effect-contract/keys.ts";
+import { backlinksOf } from "#metadata/backlinks.ts";
+import type { MetadataModel } from "#metadata/model.ts";
+import { documents, identities, index, navigation } from "./keys.ts";
+
+function uncertain(previous: MetadataModel, current: MetadataModel, paths: readonly string[]) {
+	if (previous.unavailable.length > 0 || current.unavailable.length > 0) {
+		return true;
+	}
+	const before = new Map(previous.documents.map((doc) => [doc.file, doc.parsed]));
+	const after = new Map(current.documents.map((doc) => [doc.file, doc.parsed]));
+	const known = new Set([...before.keys(), ...after.keys()]);
+	if (paths.some((path) => !known.has(path))) {
+		return true;
+	}
+	const announced = new Set(paths);
+	return [...known].some((file) => {
+		const old = before.get(file);
+		const next = after.get(file);
+		return !announced.has(file) && (old?.body !== next?.body || old?.raw !== next?.raw || old?.bodyLine !== next?.bodyLine);
+	});
+}
+function connectIdentities(model: MetadataModel, connect: (from: string, to: string) => void) {
+	for (const duplicates of model.ids.values()) {
+		const first = duplicates[0];
+		if (first === undefined) {
+			continue;
+		}
+		for (const duplicate of duplicates.slice(1)) {
+			connect(first.file, duplicate.file);
+			connect(duplicate.file, first.file);
+		}
+	}
+}
+function linkedFiles(models: readonly MetadataModel[], paths: readonly string[]) {
+	const edges = new Map<string, Set<string>>();
+	function connect(from: string, to: string) {
+		const targets = edges.get(from) ?? new Set();
+		targets.add(to);
+		edges.set(from, targets);
+	}
+	for (const model of models) {
+		connectIdentities(model, connect);
+		for (const document of model.documents) {
+			for (const link of backlinksOf(document.file, model)) {
+				connect(document.file, link.file);
+				connect(link.file, document.file);
+			}
+		}
+	}
+	const files = new Set(paths);
+	for (const file of files) {
+		for (const linked of edges.get(file) ?? []) {
+			files.add(linked);
+		}
+	}
+	return files;
+}
+export function affected(previous: MetadataModel, current: MetadataModel, paths: readonly string[]): readonly Key[] | undefined {
+	if (uncertain(previous, current, paths)) {
+		return undefined;
+	}
+	const models = [previous, current];
+	const files = linkedFiles(models, paths);
+	const keys: Key[] = [index.list, navigation.list, ...[...files].map((file) => documents.item(file))];
+	for (const model of models) {
+		if (model.rootFile && files.has(model.rootFile)) {
+			keys.push(documents.item(""));
+		}
+		for (const document of model.documents) {
+			if (files.has(document.file) && document.parsed.fields.id) {
+				keys.push(identities.item(document.parsed.fields.id));
+			}
+		}
+	}
+	return keys;
+}

package/src/rpc/contract.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+import { Rpc } from "effect/unstable/rpc";
+import { contract } from "@shivaedev/effect-contract/contract.ts";
+import { LiveHint } from "@shivaedev/effect-contract/live.ts";
+import { query } from "@shivaedev/effect-contract/operation.ts";
+import { HistoryInput, HistoryOutput } from "#history/schema.ts";
+import { index, navigation, watcher, workspace } from "./keys.ts";
+import { pageKeys } from "./pageKeys.ts";
+
+export class ReadFailed extends Schema.TaggedError<ReadFailed>()("ReadFailed", { operation: Schema.String, status: Schema.Number }) {}
+const PageUrl = Schema.String.check(
+	Schema.isMaxLength(8192),
+	Schema.makeFilter((value) => {
+		if (!value.startsWith("/") || value.startsWith("//")) {
+			return "Expected a local reading URL";
+		}
+		try {
+			const path = new URL(value, "http://127.0.0.1").pathname;
+			return (
+				path === "/"
+				|| ["/_board/work", "/_board/overview", "/_board/changes"].includes(path)
+				|| /^\/_board\/item\/[^/]+\/$/u.exec(path) !== null
+				|| /\.md$/iu.exec(path) !== null
+				|| "Expected a local reading URL"
+			);
+		} catch {
+			return "Expected a local reading URL";
+		}
+	}),
+);
+const Page = Schema.Struct({ html: Schema.String, status: Schema.Number });
+const Entry = Schema.Struct({
+	file: Schema.String,
+	href: Schema.String,
+	kind: Schema.Literals(["document", "heading", "passage"]),
+	line: Schema.optional(Schema.Number),
+	snippet: Schema.String,
+	text: Schema.String,
+	title: Schema.String,
+});
+const ReadPage = query("page", { payload: { url: PageUrl }, reads: ({ url }) => pageKeys(url), rejections: { ReadFailed }, success: Page });
+const ReadNavigation = query("navigation", { reads: () => [workspace.list, navigation.list], rejections: { ReadFailed }, success: Schema.String });
+const ReadSearch = query("search", {
+	payload: { query: Schema.String.check(Schema.isMaxLength(8192)) },
+	reads: () => [workspace.list, index.list],
+	rejections: { ReadFailed },
+	success: Schema.Struct({ results: Schema.Array(Entry), total: Schema.Number, unavailable: Schema.Array(Schema.String) }),
+});
+const ReadHistory = query("history", {
+	payload: HistoryInput,
+	reads: () => [workspace.list, index.list],
+	rejections: { ReadFailed },
+	success: HistoryOutput,
+});
+const ReadWatcher = query("watcher", {
+	reads: () => [workspace.list, watcher.list],
+	rejections: { ReadFailed },
+	success: Schema.Struct({ watching: Schema.Boolean }),
+});
+export const workContract = contract("work-board", { queries: [ReadPage, ReadNavigation, ReadSearch, ReadHistory, ReadWatcher] });
+export const Subscribe = Rpc.make("work-board.subscribe", { error: ReadFailed, stream: true, success: LiveHint });
+export const workRpcs = workContract.add(Subscribe);

package/src/rpc/hints.ts

@@ -0,0 +1,34 @@
+import { Effect, PubSub, Stream } from "effect";
+import type { LiveHint } from "@shivaedev/effect-contract/live.ts";
+import type { Change, Changes } from "#files/changes.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { affected } from "./affected.ts";
+
+export function hints(changes: Changes, index: Effect.Effect<Snapshot, unknown>) {
+	return Stream.unwrap(
+		Effect.gen(function* () {
+			const subscription = yield* PubSub.subscribe(changes.events);
+			let sequence = changes.sequence ? yield* changes.sequence : undefined;
+			let previous = yield* Effect.option(index);
+			function nextHint(change: Change) {
+				return Effect.gen(function* () {
+					const current = yield* Effect.option(index);
+					const contiguous = sequence !== undefined && change.sequence === sequence + 1;
+					sequence = change.sequence;
+					let hint: LiveHint = { _tag: "Resync" };
+					if (contiguous && change._tag === "Changed" && previous._tag === "Some" && current._tag === "Some") {
+						const keys = affected(previous.value.model, current.value.model, change.paths);
+						if (keys !== undefined) {
+							hint = { _tag: "Changed", keys };
+						}
+					}
+					previous = current;
+					return hint;
+				});
+			}
+
+			const changesStream = Stream.fromSubscription(subscription).pipe(Stream.mapEffect(nextHint));
+			return Stream.concat(Stream.succeed<LiveHint>({ _tag: "Resync" }), changesStream);
+		}),
+	);
+}

package/src/rpc/keys.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+import { collection } from "@shivaedev/effect-contract/keys.ts";
+
+export const workspace = collection("work-board/workspace", Schema.String);
+export const documents = collection("work-board/documents", Schema.String);
+export const identities = collection("work-board/identities", Schema.String);
+export const navigation = collection("work-board/navigation", Schema.String);
+export const index = collection("work-board/index", Schema.String);
+export const watcher = collection("work-board/watcher", Schema.String);

package/src/rpc/pageKeys.ts

@@ -0,0 +1,14 @@
+import type { Key } from "@shivaedev/effect-contract/keys.ts";
+import { documents, identities, index, workspace } from "./keys.ts";
+
+export function pageKeys(url: string): readonly Key[] {
+	const path = new URL(url, "http://127.0.0.1").pathname;
+	const item = /^\/_board\/item\/(?<id>[^/]+)\/$/u.exec(path)?.groups?.id;
+	let key: Key = documents.item(decodeURIComponent(path.slice(1)));
+	if (item) {
+		key = identities.item(decodeURIComponent(item));
+	} else if (path.startsWith("/_board/")) {
+		key = index.list;
+	}
+	return [workspace.list, key];
+}

package/src/rpc/server.ts

@@ -0,0 +1,55 @@
+import { Clock, Effect, Layer, Ref } from "effect";
+import { HttpIncomingMessage, HttpServerResponse } from "effect/unstable/http";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import type { Changes } from "#files/changes.ts";
+import { MAX_BYTES } from "#history/limits.ts";
+import { historyResponse } from "#history/response.ts";
+import { HEADERS } from "#http/respond.ts";
+import { navHtml } from "#page/nav.ts";
+import { searchMatch } from "#search/match.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { ReadFailed, workRpcs } from "./contract.ts";
+import { hints } from "./hints.ts";
+
+export interface ServerOptions {
+	readonly changes: Changes;
+	readonly home: string | undefined;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly page: (url: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>;
+}
+
+export const server = Effect.fn("WorkBoard.server")(function* ({ changes, home, index, page }: ServerOptions) {
+	const handlers = workRpcs.toLayer({
+		"work-board.history": ({ action, baseline }) =>
+			Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				const snapshot = action === "check" ? undefined : yield* index;
+				return historyResponse(baseline, now, snapshot);
+			}).pipe(Effect.catch(() => Effect.fail(new ReadFailed({ operation: "history", status: 500 })))),
+		"work-board.navigation": () =>
+			Effect.map(changes.files, (files) => navHtml(files, "", home)).pipe(
+				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "navigation", status: 500 }))),
+			),
+		"work-board.page": ({ url }) =>
+			page(url).pipe(
+				Effect.flatMap((response) => {
+					if (response.status >= 500 || response.body._tag !== "Uint8Array") {
+						return Effect.fail(new ReadFailed({ operation: "page", status: response.status }));
+					}
+					return Effect.succeed({ html: new TextDecoder().decode(response.body.body), status: response.status });
+				}),
+				Effect.catch((error) => Effect.fail(error instanceof ReadFailed ? error : new ReadFailed({ operation: "page", status: 500 }))),
+			),
+		"work-board.search": ({ query }) =>
+			Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable })).pipe(
+				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "search", status: 500 }))),
+			),
+		"work-board.subscribe": () => hints(changes, index),
+		"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })),
+	});
+	const handler = yield* RpcServer.toHttpEffect(workRpcs).pipe(Effect.provide(Layer.merge(handlers, RpcSerialization.layerNdjson)));
+	return handler.pipe(
+		Effect.provideService(HttpIncomingMessage.MaxBodySize, BigInt(4 * MAX_BYTES + 4096)),
+		Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)),
+	);
+});