@remit/backend 0.0.142 → 0.0.144

package/src/service/export-identity.ts

@@ -1,39 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ConfigExportIdentity } from "@remit/config-transfer";
-
-const DEFAULT_CONTROL_DIR = "/data/control";
-
-/**
- * The version a file says it was written by. The updater owns this fact: it
- * reads the tag from `.env` and writes it into `state.json`, which is the only
- * honest source across an update that rewrites that tag underneath a
- * long-lived process. With no state file there is nothing authoritative to
- * stamp, and an export says so rather than inventing a version an importing
- * reader would then trust.
- */
-const runningVersion = (): string => {
-	const dir = process.env.REMIT_UPDATE_CONTROL_DIR ?? DEFAULT_CONTROL_DIR;
-	let raw: string;
-	try {
-		raw = readFileSync(join(dir, "state.json"), "utf8");
-	} catch {
-		return "unknown";
-	}
-	const state: unknown = JSON.parse(raw);
-	if (typeof state !== "object" || state === null) return "unknown";
-	const version = (state as { currentVersion?: unknown }).currentVersion;
-	return typeof version === "string" && version.length > 0
-		? version
-		: "unknown";
-};
-
-/** Who wrote a configuration file, and from where. Provenance only. */
-export const exportIdentity = (
-	now: Date = new Date(),
-): ConfigExportIdentity => ({
-	app: "reader",
-	version: runningVersion(),
-	exportedAt: now.toISOString(),
-	instance: process.env.PUBLIC_ORIGIN ?? "",
-});

package/src/service/filter.ts

@@ -1,40 +0,0 @@
-import { type AnchorPayload, buildMessageAnchor } from "@remit/search-service";
-import {
-	buildEmbeddingServiceFromEnv,
-	buildVectorStoreFromEnv,
-} from "@remit/search-service/from-env";
-
-/**
- * Build a filter's persisted semantic anchor from an already-indexed message's
- * chunk vectors (RFC 034 Decision 2.1), or `null` when the message has no
- * indexed chunks. Never embeds anything new — the vectors already exist from
- * index time.
- *
- * This is the only piece of filter CRUD not on the `RemitClient` port bundle:
- * the vector store and embedder are selected by env, independent of
- * `DATA_BACKEND`, so it works unchanged on either backend. The filter and
- * anchor rows themselves are written through
- * `client.filter`/`client.filterAnchor` so they land in the same backend as
- * everything else.
- */
-export type BuildFilterAnchor = (
-	accountConfigId: string,
-	anchorMessageId: string,
-) => Promise<AnchorPayload | null>;
-
-let cached: BuildFilterAnchor | null = null;
-
-const build = (): BuildFilterAnchor => {
-	const embedder = buildEmbeddingServiceFromEnv();
-	const store = buildVectorStoreFromEnv(embedder.dimensions);
-	return (accountConfigId, anchorMessageId) =>
-		buildMessageAnchor({ store }, { accountConfigId, anchorMessageId });
-};
-
-export const buildFilterAnchor: BuildFilterAnchor = (
-	accountConfigId,
-	anchorMessageId,
-) => {
-	if (!cached) cached = build();
-	return cached(accountConfigId, anchorMessageId);
-};

package/src/service/fire-and-forget.test.ts

@@ -1,126 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { type FireAndForgetLogger, fireAndForget } from "./fire-and-forget.js";
-
-interface LogCall {
-	fields: Record<string, unknown>;
-	message: string;
-}
-
-const createLoggerSpy = () => {
-	const error: LogCall[] = [];
-	const logger: FireAndForgetLogger = {
-		error: (fields: Record<string, unknown>, message: string): void => {
-			error.push({ fields, message });
-		},
-	};
-	return { error, logger };
-};
-
-describe("fireAndForget", () => {
-	it("runs the work and stays quiet on success", async () => {
-		const { error, logger } = createLoggerSpy();
-		let ran = false;
-
-		await fireAndForget(
-			async () => {
-				ran = true;
-			},
-			{ source: "test", message: "should not log", logger },
-		);
-
-		assert.equal(ran, true);
-		assert.equal(error.length, 0);
-	});
-
-	it("does NOT reject when the work throws", async () => {
-		const { logger } = createLoggerSpy();
-
-		await assert.doesNotReject(
-			fireAndForget(
-				async () => {
-					throw new Error("boom");
-				},
-				{ source: "test", message: "contained", logger },
-			),
-		);
-	});
-
-	it("logs the failure loudly with the alertable structured fields and ids", async () => {
-		const { error, logger } = createLoggerSpy();
-		const econnrefused = Object.assign(new Error(""), {
-			name: "AggregateError",
-			code: "ECONNREFUSED",
-		});
-
-		await fireAndForget(
-			async () => {
-				throw econnrefused;
-			},
-			{
-				source: "config_load",
-				message: "Failed to trigger account sync on config load",
-				ids: { accountId: "acc-a", accountConfigId: "config-1" },
-				logger,
-			},
-		);
-
-		assert.equal(error.length, 1);
-		const call = error[0];
-		if (!call) throw new Error("expected an error log");
-		assert.equal(call.fields.alert, "sync_trigger_failed");
-		assert.equal(call.fields.source, "config_load");
-		assert.equal(call.fields.accountId, "acc-a");
-		assert.equal(call.fields.accountConfigId, "config-1");
-		assert.equal(call.fields.errorName, "AggregateError");
-		assert.equal(call.fields.errorCode, "ECONNREFUSED");
-		assert.equal(call.message, "Failed to trigger account sync on config load");
-	});
-
-	it("reads the SDK error code from the .Code field when present", async () => {
-		const { error, logger } = createLoggerSpy();
-		const sdkError = Object.assign(new Error("boom"), {
-			name: "QueueDoesNotExist",
-			Code: "AWS.SimpleQueueService.NonExistentQueue",
-		});
-
-		await fireAndForget(
-			async () => {
-				throw sdkError;
-			},
-			{ source: "test", message: "contained", logger },
-		);
-
-		const call = error[0];
-		if (!call) throw new Error("expected an error log");
-		assert.equal(
-			call.fields.errorCode,
-			"AWS.SimpleQueueService.NonExistentQueue",
-		);
-	});
-
-	it("never leaks an unhandled rejection even when void-fired", async () => {
-		const leaked: unknown[] = [];
-		const onUnhandled = (reason: unknown): void => {
-			leaked.push(reason);
-		};
-		process.on("unhandledRejection", onUnhandled);
-
-		try {
-			// Fire-and-forget exactly as a request handler does: no await.
-			void fireAndForget(
-				async () => {
-					throw Object.assign(new Error(""), { code: "ECONNREFUSED" });
-				},
-				{ source: "test", message: "contained", logger: { error: () => {} } },
-			);
-			// Let the microtask queue drain so any escaped rejection would surface.
-			await new Promise((resolve) => setImmediate(resolve));
-			await new Promise((resolve) => setImmediate(resolve));
-		} finally {
-			process.off("unhandledRejection", onUnhandled);
-		}
-
-		assert.equal(leaked.length, 0);
-	});
-});

package/src/service/fire-and-forget.ts

@@ -1,79 +0,0 @@
-import { inspect } from "node:util";
-import { logger } from "@remit/logger-lambda";
-
-type StructuredLog = (fields: Record<string, unknown>, message: string) => void;
-
-export interface FireAndForgetLogger {
-	error: StructuredLog;
-}
-
-export interface FireAndForgetContext {
-	/**
-	 * Stable discriminator for the originating call site (e.g. `"config_load"`,
-	 * `"account_create"`). Surfaces on the log line as `source` so a CloudWatch
-	 * metric filter / alarm can attribute a leak to its origin.
-	 */
-	source: string;
-	/**
-	 * Message logged when the background work rejects. Should describe the work
-	 * and reassure that the failure is contained (e.g. "...best-effort").
-	 */
-	message: string;
-	/**
-	 * Identifiers carried onto the structured error line (accountId,
-	 * accountConfigId, …) so a failure is traceable without a stack dive.
-	 */
-	ids?: Record<string, unknown>;
-	/**
-	 * Alertable discriminator on the structured error line, the field CloudWatch
-	 * metric filters key on. Defaults to `"sync_trigger_failed"` for the original
-	 * sync-kick sites; a different fire-and-forget surface (e.g. a flag enqueue)
-	 * must pass its own so it is not mis-attributed to the sync-trigger alarm.
-	 */
-	alert?: string;
-	logger?: FireAndForgetLogger;
-}
-
-/**
- * Run unawaited background work that MUST NOT be able to fail the request that
- * spawned it.
- *
- * The dev/Lambda runtime shares one event loop across concurrent requests, so a
- * rejection escaping an unawaited background promise (a `void trigger()`) lands
- * on whatever request happens to be in flight when the deferred work finally
- * fails — turning an unrelated READ into a spurious 500. That is exactly how an
- * unreachable SQS queue 500'd `/mailboxes`, `/threads`, `/outbox` and `/config`.
- *
- * This helper is the single containment point: it awaits the work inside a
- * try/catch, logs every rejection LOUDLY with the alertable structured fields
- * (`alert` — defaulting to `"sync_trigger_failed"`, `source`, the SDK error
- * name/code, the caller ids), and ALWAYS resolves to void. Callers `void
- * fireAndForget(...)` with no
- * chance of an unhandled rejection escaping. Routing all fire-and-forget sites
- * through here keeps the containment from regressing one handler at a time.
- *
- * Use this ONLY for genuine side effects whose failure must not change the
- * response. A failure the caller is responsible for (the real DynamoDB read, an
- * enqueue that IS the request's purpose) must still propagate and 500.
- */
-export const fireAndForget = async (
-	work: () => Promise<unknown>,
-	context: FireAndForgetContext,
-): Promise<void> => {
-	await work().catch((error: unknown) => {
-		const log = context.logger ?? logger;
-		log.error(
-			{
-				alert: context.alert ?? "sync_trigger_failed",
-				source: context.source,
-				...context.ids,
-				errorName: (error as { name?: string })?.name,
-				errorCode:
-					(error as { Code?: string })?.Code ??
-					(error as { code?: string })?.code,
-				error: inspect(error),
-			},
-			context.message,
-		);
-	});
-};

package/src/service/localhost-env-config.test.ts

@@ -1,36 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, readFileSync } from "node:fs";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-const repoRoot = fileURLToPath(new URL("../../../../", import.meta.url));
-
-const parseEnvFile = (relativePath: string): Record<string, string> => {
-	const contents = readFileSync(`${repoRoot}${relativePath}`, "utf8");
-	const entries: Record<string, string> = {};
-	for (const line of contents.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const eq = trimmed.indexOf("=");
-		if (eq === -1) continue;
-		entries[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
-	}
-	return entries;
-};
-
-describe("local dev SQS routing (localhost-dev-aws.env)", {
-	// localhost-dev-aws.env is AWS-local-dev config, stripped from the open-core
-	// tree; skip where it is absent.
-	skip: !existsSync(`${repoRoot}localhost-dev-aws.env`),
-}, () => {
-	const env = parseEnvFile("localhost-dev-aws.env");
-
-	it("publishes backend writes to the FIFO mailboxes queue the sync consumer drains", () => {
-		// Prod wires the API's SQS_QUEUE_URL to the mailboxes FIFO queue
-		// (infra remit-api-stack.ts). Onboarding publishes SYNC_MAILBOXES there;
-		// the imap worker consumes it. Local dev must mirror that or onboarding
-		// events land in a queue nothing drains and accounts never sync.
-		assert.equal(env.SQS_QUEUE_URL, env.SQS_QUEUE_URL_MAILBOXES);
-		assert.ok(env.SQS_QUEUE_URL?.endsWith(".fifo"));
-	});
-});

package/src/service/organize-queue.ts

@@ -1,98 +0,0 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
-import type {
-	CreateOrganizeJobRequestInput,
-	OrganizeJobRequestItem,
-} from "@remit/data-ports";
-import { FilterMatchOperator } from "@remit/domain-enums";
-import { logger } from "@remit/logger-lambda";
-import {
-	DEFAULT_SEMANTIC_MATCH_THRESHOLD,
-	NO_ACTION,
-} from "@remit/mailbox-service";
-import { env } from "expect-env";
-import type { RemitClient } from "./data-client.js";
-import type { OrganizePredicate } from "./organize.js";
-import { sqsClient } from "./sqs.js";
-
-/**
- * How long a finished (or abandoned) job row lingers before the table-wide TTL
- * reclaims it (RFC 034 Decision 1). A back-apply runs once and needs no standing
- * lifetime; a week is ample for a client to poll the result.
- */
-const ORGANIZE_JOB_TTL_SECONDS = 7 * 24 * 60 * 60;
-
-interface JobOwner {
-	accountConfigId: string;
-	userId: string;
-}
-
-/**
- * An "all like these" pass carries its predicate; a filter job names only the
- * filter, which the worker reads when it runs.
- */
-export type OrganizeJobRequest = JobOwner &
-	({ predicate: OrganizePredicate } | { filterId: string });
-
-/** A filter job's row: the filter id, every predicate column at its sentinel. */
-const filterJobColumns = (
-	filterId: string,
-): Omit<CreateOrganizeJobRequestInput, keyof JobOwner | "ttl"> => ({
-	filterId,
-	anchorMessageId: NO_ACTION,
-	matchOperator: FilterMatchOperator.And,
-	literalClauses: [],
-	similarityThreshold: DEFAULT_SEMANTIC_MATCH_THRESHOLD,
-	actionLabelId: NO_ACTION,
-	actionMailboxId: NO_ACTION,
-});
-
-const predicateColumns = (
-	predicate: OrganizePredicate,
-): Omit<CreateOrganizeJobRequestInput, keyof JobOwner | "ttl"> => ({
-	filterId: NO_ACTION,
-	...predicate,
-});
-
-/**
- * Write a Pending job row and hand it to the account-fanout worker. Every
- * back-apply goes through here: "all like these", a new filter's first pass,
- * and Run now on a saved filter.
- */
-export const queueOrganizeJob = async (
-	client: Pick<RemitClient, "organizeJobRequest">,
-	request: OrganizeJobRequest,
-): Promise<OrganizeJobRequestItem> => {
-	const { accountConfigId, userId } = request;
-	const columns =
-		"filterId" in request
-			? filterJobColumns(request.filterId)
-			: predicateColumns(request.predicate);
-	const job = await client.organizeJobRequest.create({
-		accountConfigId,
-		userId,
-		...columns,
-		ttl: Math.floor(Date.now() / 1000) + ORGANIZE_JOB_TTL_SECONDS,
-	});
-
-	await sqsClient.send(
-		new SendMessageCommand({
-			QueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
-			MessageBody: JSON.stringify({
-				type: "OrganizeJob",
-				accountConfigId,
-				organizeJobId: job.organizeJobId,
-			}),
-		}),
-	);
-
-	// biome-ignore lint/plugin/no-logger-info: a back-apply is an audit-grade signal
-	logger.info(
-		{
-			accountConfigId,
-			organizeJobId: job.organizeJobId,
-			filterId: job.filterId,
-		},
-		"Organize back-apply job initiated",
-	);
-	return job;
-};