birdclaw 0.5.0 → 0.6.0

package/src/lib/moderation-target.ts

@@ -1,6 +1,8 @@
 import type { Database } from "./sqlite";
+import { Effect } from "effect";
 import { lookupProfileViaBird } from "./bird-actions";
 import { getNativeDb } from "./db";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import type { ProfileRecord, XurlMentionUser } from "./types";
 import { getExternalUserId, upsertProfileFromXUser } from "./x-profile";
 import {
@@ -14,6 +16,17 @@ export interface ResolvedModerationProfile {
 	externalUserId: string | null;
 }
 
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: toError,
+	});
+}
+
 export function toProfile(row: Record<string, unknown>): ProfileRecord {
 	const followingCount = Number(row.following_count ?? 0);
 	return {
@@ -90,90 +103,114 @@ export function resolveLocalProfile(
 	};
 }
 
-export async function resolveProfile(
+export function resolveProfileEffect(
 	query: string,
-): Promise<ResolvedModerationProfile> {
-	const db = getNativeDb();
-	const normalizedQuery = normalizeProfileQuery(query);
-	if (!normalizedQuery) {
-		throw new Error("Missing profile handle or id");
-	}
+): Effect.Effect<ResolvedModerationProfile, unknown> {
+	return Effect.gen(function* () {
+		const db = yield* trySync(() => getNativeDb());
+		const normalizedQuery = normalizeProfileQuery(query);
+		if (!normalizedQuery) {
+			return yield* Effect.fail(new Error("Missing profile handle or id"));
+		}
 
-	const local = resolveLocalProfile(db, normalizedQuery);
-	if (process.env.BIRDCLAW_DISABLE_LIVE_PROFILE_LOOKUP === "1") {
-		if (local) {
+		const local = yield* trySync(() =>
+			resolveLocalProfile(db, normalizedQuery),
+		);
+		if (process.env.BIRDCLAW_DISABLE_LIVE_PROFILE_LOOKUP === "1") {
+			if (local) {
+				return local;
+			}
+			return yield* Effect.fail(
+				new Error(`Profile not found locally: ${query}`),
+			);
+		}
+		if (
+			local &&
+			!local.profile.id.startsWith("profile_group_") &&
+			local.externalUserId
+		) {
 			return local;
 		}
-		throw new Error(`Profile not found locally: ${query}`);
-	}
-	if (
-		local &&
-		!local.profile.id.startsWith("profile_group_") &&
-		local.externalUserId
-	) {
-		return local;
-	}
-
-	let user: XurlMentionUser | undefined;
-	let lastError: unknown;
 
-	try {
-		user =
-			(await lookupProfileViaBird(local?.profile.handle ?? normalizedQuery)) ??
-			undefined;
-	} catch (error) {
-		lastError = error;
-	}
+		let user: XurlMentionUser | undefined;
+		let lastError: unknown;
+
+		const birdResult = yield* tryPromise(() =>
+			lookupProfileViaBird(local?.profile.handle ?? normalizedQuery),
+		).pipe(
+			Effect.map((value) => ({ ok: true as const, value })),
+			Effect.catchAll((error) => Effect.succeed({ ok: false as const, error })),
+		);
+		if (birdResult.ok) {
+			user = birdResult.value ?? undefined;
+		} else {
+			lastError = birdResult.error;
+		}
 
-	if (!user) {
-		try {
-			if (/^\d+$/.test(normalizedQuery)) {
-				[user] = await lookupUsersByIds([normalizedQuery]);
+		if (!user) {
+			const xurlResult = yield* tryPromise(() =>
+				/^\d+$/.test(normalizedQuery)
+					? lookupUsersByIds([normalizedQuery])
+					: lookupUsersByHandles([local?.profile.handle ?? normalizedQuery]),
+			).pipe(
+				Effect.map((value) => ({ ok: true as const, value })),
+				Effect.catchAll((error) =>
+					Effect.succeed({ ok: false as const, error }),
+				),
+			);
+			if (xurlResult.ok) {
+				[user] = xurlResult.value;
 			} else {
-				[user] = await lookupUsersByHandles([
-					local?.profile.handle ?? normalizedQuery,
-				]);
+				lastError = xurlResult.error;
 			}
-		} catch (error) {
-			lastError = error;
 		}
-	}
 
-	if (!user && lastError) {
-		if (local) {
-			return local;
+		if (!user && lastError) {
+			if (local) {
+				return local;
+			}
+			return yield* Effect.fail(lastError);
 		}
-		throw lastError;
-	}
 
-	if (!user) {
-		if (local) {
-			return local;
+		if (!user) {
+			if (local) {
+				return local;
+			}
+			return yield* Effect.fail(new Error(`Profile not found: ${query}`));
 		}
-		throw new Error(`Profile not found: ${query}`);
-	}
 
-	if (local) {
-		return upsertProfileFromXUser(db, user);
-	}
+		if (local) {
+			return yield* trySync(() => upsertProfileFromXUser(db, user));
+		}
 
-	const username = String(user.username ?? "").replace(/^@/, "");
-	if (username) {
-		const localByHandle = resolveLocalProfile(db, username);
-		if (localByHandle) {
-			return upsertProfileFromXUser(db, user);
+		const username = String(user.username ?? "").replace(/^@/, "");
+		if (username) {
+			const localByHandle = yield* trySync(() =>
+				resolveLocalProfile(db, username),
+			);
+			if (localByHandle) {
+				return yield* trySync(() => upsertProfileFromXUser(db, user));
+			}
 		}
-	}
 
-	return upsertProfileFromXUser(db, user);
+		return yield* trySync(() => upsertProfileFromXUser(db, user));
+	});
+}
+
+export function resolveProfile(
+	query: string,
+): Promise<ResolvedModerationProfile> {
+	return runEffectPromise(resolveProfileEffect(query));
 }
 
-export async function getAuthenticatedUserId() {
-	try {
-		const me = await lookupAuthenticatedUser();
+export function getAuthenticatedUserIdEffect() {
+	return Effect.gen(function* () {
+		const me = yield* tryPromise(() => lookupAuthenticatedUser());
 		const id = me?.id;
 		return typeof id === "string" && id.length > 0 ? id : null;
-	} catch {
-		return null;
-	}
+	}).pipe(Effect.catchAll(() => Effect.succeed(null)));
+}
+
+export function getAuthenticatedUserId() {
+	return runEffectPromise(getAuthenticatedUserIdEffect());
 }

package/src/lib/moderation-write.ts

@@ -1,12 +1,15 @@
 import type { Database } from "./sqlite";
+import { Effect } from "effect";
 import type { ActionsTransport } from "./config";
 import { getNativeDb } from "./db";
+import { runEffectPromise } from "./effect-runtime";
 import {
 	getAccountHandle,
 	getDefaultAccountId,
 	normalizeProfileQuery,
-	resolveProfile,
+	resolveProfileEffect,
 } from "./moderation-target";
+import { getExternalUserId } from "./x-profile";
 
 export interface ModerationActionOptions {
 	transport?: ActionsTransport;
@@ -18,28 +21,84 @@ interface ResolveModerationTargetParams {
 	selfActionError: string;
 }
 
-export async function resolveModerationTarget({
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: toError,
+	});
+}
+
+export function resolveModerationTargetEffect({
 	accountId,
 	query,
 	selfActionError,
 }: ResolveModerationTargetParams) {
-	const db = getNativeDb();
-	const resolvedAccountId = accountId || getDefaultAccountId(db);
-	const accountHandle = getAccountHandle(db, resolvedAccountId);
-	if (normalizeProfileQuery(query) === accountHandle) {
-		throw new Error(selfActionError);
-	}
+	return Effect.gen(function* () {
+		const db = yield* trySync(() => getNativeDb());
+		const resolvedAccountId = accountId || getDefaultAccountId(db);
+		const accountHandle = yield* trySync(() =>
+			getAccountHandle(db, resolvedAccountId),
+		);
+		if (!accountHandle) {
+			return yield* Effect.fail(
+				new Error(`Unknown account: ${resolvedAccountId}`),
+			);
+		}
+		const normalizedQuery = normalizeProfileQuery(query);
+		if (normalizedQuery.toLowerCase() === accountHandle.toLowerCase()) {
+			return yield* Effect.fail(new Error(selfActionError));
+		}
+
+		const resolved = yield* resolveProfileEffect(query);
+		const account = yield* trySync(
+			() =>
+				db
+					.prepare("select handle, external_user_id from accounts where id = ?")
+					.get(resolvedAccountId) as
+					| { handle: string; external_user_id: string | null }
+					| undefined,
+		);
+		const accountProfile = yield* trySync(() =>
+			account
+				? (db
+						.prepare("select id from profiles where handle = ? limit 1")
+						.get(account.handle.replace(/^@/, "")) as
+						| { id: string }
+						| undefined)
+				: undefined,
+		);
+		const accountExternalUserId =
+			account?.external_user_id ?? getExternalUserId(accountProfile?.id ?? "");
+		if (
+			resolved.profile.handle.toLowerCase() === accountHandle.toLowerCase() ||
+			(accountProfile?.id && resolved.profile.id === accountProfile.id) ||
+			(accountExternalUserId &&
+				resolved.externalUserId === accountExternalUserId)
+		) {
+			return yield* Effect.fail(new Error(selfActionError));
+		}
+
+		return {
+			db,
+			resolved,
+			resolvedAccountId,
+			accountIdentity: {
+				id: resolvedAccountId,
+				handle: account?.handle ?? accountHandle,
+				externalUserId: accountExternalUserId || null,
+			},
+			actionQuery:
+				resolved.externalUserId ?? resolved.profile.handle ?? normalizedQuery,
+		};
+	});
+}
 
-	const resolved = await resolveProfile(query);
-	return {
-		db,
-		resolved,
-		resolvedAccountId,
-		actionQuery:
-			resolved.externalUserId ??
-			resolved.profile.handle ??
-			normalizeProfileQuery(query),
-	};
+export function resolveModerationTarget(params: ResolveModerationTargetParams) {
+	return runEffectPromise(resolveModerationTargetEffect(params));
 }
 
 export function writeModerationRow(

package/src/lib/mutes-write.ts

@@ -1,118 +1,167 @@
+import { Effect } from "effect";
 import { runModerationAction } from "./actions-transport";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import {
 	deleteModerationRow,
 	type ModerationActionOptions,
-	resolveModerationTarget,
+	resolveModerationTargetEffect,
 	writeModerationRow,
 } from "./moderation-write";
 
-export async function addMute(
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: (error) =>
+			error instanceof Error ? error : new Error(String(error)),
+	});
+}
+
+export function addMuteEffect(
 	accountId: string,
 	query: string,
 	options: ModerationActionOptions = {},
 ) {
-	const { db, resolved, resolvedAccountId, actionQuery } =
-		await resolveModerationTarget({
-			accountId,
-			query,
-			selfActionError: "Cannot mute the current account",
-		});
-	const transport = await runModerationAction({
-		action: "mute",
-		query: actionQuery,
-		targetUserId: resolved.externalUserId ?? undefined,
-		transport: options.transport,
-	});
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot mute the current account",
+			});
+		const transport = yield* tryPromise(() =>
+			runModerationAction({
+				action: "mute",
+				query: actionQuery,
+				targetUserId: resolved.externalUserId ?? undefined,
+				transport: options.transport,
+				expectedAccount: accountIdentity,
+			}),
+		);
+
+		if (!transport.ok) {
+			return {
+				ok: false,
+				action: "mute",
+				accountId: resolvedAccountId,
+				profile: resolved.profile,
+				transport,
+			};
+		}
+
+		const mutedAt = new Date().toISOString();
+		yield* trySync(() =>
+			writeModerationRow(
+				db,
+				"mutes",
+				resolvedAccountId,
+				resolved.profile.id,
+				mutedAt,
+			),
+		);
 
-	if (!transport.ok) {
 		return {
-			ok: false,
+			ok: true,
 			action: "mute",
 			accountId: resolvedAccountId,
+			mutedAt,
 			profile: resolved.profile,
 			transport,
 		};
-	}
-
-	const mutedAt = new Date().toISOString();
-	writeModerationRow(
-		db,
-		"mutes",
-		resolvedAccountId,
-		resolved.profile.id,
-		mutedAt,
-	);
+	});
+}
 
-	return {
-		ok: true,
-		action: "mute",
-		accountId: resolvedAccountId,
-		mutedAt,
-		profile: resolved.profile,
-		transport,
-	};
+export function addMute(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	return runEffectPromise(addMuteEffect(accountId, query, options));
 }
 
-export async function recordMute(accountId: string, query: string) {
-	const { db, resolved, resolvedAccountId } = await resolveModerationTarget({
-		accountId,
-		query,
-		selfActionError: "Cannot mute the current account",
-	});
+export function recordMuteEffect(accountId: string, query: string) {
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot mute the current account",
+			});
 
-	const mutedAt = new Date().toISOString();
-	writeModerationRow(
-		db,
-		"mutes",
-		resolvedAccountId,
-		resolved.profile.id,
-		mutedAt,
-	);
+		const mutedAt = new Date().toISOString();
+		yield* trySync(() =>
+			writeModerationRow(
+				db,
+				"mutes",
+				resolvedAccountId,
+				resolved.profile.id,
+				mutedAt,
+			),
+		);
 
-	return {
-		ok: true,
-		action: "record-mute",
-		accountId: resolvedAccountId,
-		mutedAt,
-		profile: resolved.profile,
-	};
+		return {
+			ok: true,
+			action: "record-mute",
+			accountId: resolvedAccountId,
+			mutedAt,
+			profile: resolved.profile,
+		};
+	});
+}
+
+export function recordMute(accountId: string, query: string) {
+	return runEffectPromise(recordMuteEffect(accountId, query));
 }
 
-export async function removeMute(
+export function removeMuteEffect(
 	accountId: string,
 	query: string,
 	options: ModerationActionOptions = {},
 ) {
-	const { db, resolved, resolvedAccountId, actionQuery } =
-		await resolveModerationTarget({
-			accountId,
-			query,
-			selfActionError: "Cannot mute the current account",
-		});
-	const transport = await runModerationAction({
-		action: "unmute",
-		query: actionQuery,
-		targetUserId: resolved.externalUserId ?? undefined,
-		transport: options.transport,
-	});
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot mute the current account",
+			});
+		const transport = yield* tryPromise(() =>
+			runModerationAction({
+				action: "unmute",
+				query: actionQuery,
+				targetUserId: resolved.externalUserId ?? undefined,
+				transport: options.transport,
+				expectedAccount: accountIdentity,
+			}),
+		);
+
+		if (!transport.ok) {
+			return {
+				ok: false,
+				action: "unmute",
+				accountId: resolvedAccountId,
+				profile: resolved.profile,
+				transport,
+			};
+		}
+
+		yield* trySync(() =>
+			deleteModerationRow(db, "mutes", resolvedAccountId, resolved.profile.id),
+		);
 
-	if (!transport.ok) {
 		return {
-			ok: false,
+			ok: true,
 			action: "unmute",
 			accountId: resolvedAccountId,
 			profile: resolved.profile,
 			transport,
 		};
-	}
-
-	deleteModerationRow(db, "mutes", resolvedAccountId, resolved.profile.id);
+	});
+}
 
-	return {
-		ok: true,
-		action: "unmute",
-		accountId: resolvedAccountId,
-		profile: resolved.profile,
-		transport,
-	};
+export function removeMute(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	return runEffectPromise(removeMuteEffect(accountId, query, options));
 }

package/src/lib/mutes.ts

@@ -2,7 +2,14 @@ import { getNativeDb } from "./db";
 import { toProfile } from "./moderation-target";
 import type { BlockItem } from "./types";
 
-export { addMute, recordMute, removeMute } from "./mutes-write";
+export {
+	addMute,
+	addMuteEffect,
+	recordMute,
+	recordMuteEffect,
+	removeMute,
+	removeMuteEffect,
+} from "./mutes-write";
 
 export interface MuteItem {
 	accountId: string;