@remit/account-worker 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/account-worker",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -48,19 +48,8 @@
     "@types/aws-lambda": "*"
   },
   "devDependencies": {
-    "@aws-sdk/client-cloudfront": "*",
-    "@aws-sdk/client-cognito-identity-provider": "*",
-    "@aws-sdk/client-dynamodb": "*",
-    "@aws-sdk/client-s3": "*",
     "@aws-sdk/core": "*",
-    "@aws-sdk/lib-dynamodb": "*",
-    "@aws-sdk/lib-storage": "*",
-    "@aws-sdk/s3-request-presigner": "*",
-    "@remit/domain-enums": "*",
-    "@remit/search-service": "*",
-    "aws-sdk-client-mock": "*",
-    "esbuild": "^0.28.1",
-    "p-map": "*"
+    "esbuild": "^0.28.1"
   },
   "license": "MIT",
   "publishConfig": {

package/src/handlers/organize-job.test.ts

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { RemitClient } from "@remit/backend/client";
+import type { OrganizeMatchDeps } from "@remit/backend/organize";
+import type { Logger } from "@remit/logger-lambda";
+import type { OrganizeJobEvent } from "../events.js";
+import { processOrganizeJob } from "./organize-job.js";
+
+const noopLog = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {},
+	fatal: () => {},
+	trace: () => {},
+	child: () => noopLog,
+} as unknown as Logger;
+
+interface Update {
+	state: string;
+	errorMessage?: string;
+	matchedCount?: number;
+	appliedCount?: number;
+	failedCount?: number;
+}
+
+const event: OrganizeJobEvent = {
+	type: "OrganizeJob",
+	accountConfigId: "cfg-1",
+	organizeJobId: "job-1",
+};
+
+const jobClient = (
+	updates: Update[],
+	literalClauses: Array<{ field: string; value: string }>,
+): RemitClient =>
+	({
+		organizeJobRequest: {
+			get: async () => ({
+				organizeJobId: "job-1",
+				accountConfigId: "cfg-1",
+				anchorMessageId: "None",
+				matchOperator: "And",
+				literalClauses,
+				similarityThreshold: 0.75,
+				actionLabelId: "lbl-1",
+				actionMailboxId: "None",
+			}),
+			update: async (_id: string, patch: Update) => {
+				updates.push(patch);
+			},
+		},
+	}) as unknown as RemitClient;
+
+/**
+ * Matcher deps whose corpus read is a landmine: reaching it at all means the
+ * predicate was not refused up front, and the thrown error stands in for the
+ * infrastructure-class failure a retry exists for.
+ */
+const explodingMatchDeps = (): OrganizeMatchDeps =>
+	({
+		semantic: () => {
+			throw new Error("the vector pipeline must not be reached");
+		},
+		listAccountFilterMessages: async () => {
+			throw new Error("SQLITE_BUSY");
+		},
+		filterAnchors: {
+			listByAccountConfig: async () => [],
+			put: async () => {
+				throw new Error("unreachable");
+			},
+		},
+	}) as unknown as OrganizeMatchDeps;
+
+describe("processOrganizeJob (reader #463)", () => {
+	it("fails the job on a refused rule and acknowledges the record", async () => {
+		const updates: Update[] = [];
+
+		await processOrganizeJob(event, noopLog, {
+			client: jobClient(updates, [{ field: "HasWords", value: "invoice" }]),
+			matchDeps: explodingMatchDeps(),
+		});
+
+		assert.deepEqual(
+			updates.map((u) => u.state),
+			["Running", "Failed"],
+		);
+		const failed = updates[1];
+		assert.match(String(failed?.errorMessage), /HasWords/);
+		assert.equal(failed?.matchedCount, 0);
+		assert.equal(failed?.appliedCount, 0);
+		assert.equal(failed?.failedCount, 0);
+	});
+
+	it("fails the job and propagates an infrastructure failure so the record retries", async () => {
+		const updates: Update[] = [];
+
+		await assert.rejects(
+			processOrganizeJob(event, noopLog, {
+				client: jobClient(updates, [
+					{ field: "Subject", value: "reservation" },
+				]),
+				matchDeps: explodingMatchDeps(),
+			}),
+			/SQLITE_BUSY/,
+			"an SQS/DDB-class failure must stay loud so partial batch failure redelivers it",
+		);
+
+		assert.deepEqual(
+			updates.map((u) => u.state),
+			["Running", "Failed"],
+		);
+		assert.equal(updates[1]?.errorMessage, "SQLITE_BUSY");
+	});
+});

package/src/handlers/organize-job.ts

@@ -1,15 +1,21 @@
-import { getClient } from "@remit/backend/client";
+import { getClient, type RemitClient } from "@remit/backend/client";
 import {
 	applyOrganize,
 	buildOrganizeMatchDeps,
 	buildOrganizeMoveService,
 	matchOrganize,
 	ORGANIZE_MATCH_LIMIT,
+	type OrganizeMatchDeps,
 	predicateFromJob,
 } from "@remit/backend/organize";
 import type { Logger } from "@remit/logger-lambda";
 import type { OrganizeJobEvent } from "../events.js";
 
+export interface ProcessOrganizeJobDeps {
+	client?: RemitClient;
+	matchDeps?: OrganizeMatchDeps;
+}
+
 /**
  * Run a "all like these" back-apply job (RFC 034, #1278): match the corpus
  * against the job's snapshotted predicate and apply the action to every match,
@@ -22,13 +28,22 @@ import type { OrganizeJobEvent } from "../events.js";
  * additive label upsert and the exclusive folder move, the latter through the
  * same local-first placement mover body sync uses (`buildOrganizeMoveService`),
  * so a redelivered job re-applies both idempotently.
+ *
+ * Two failures, two treatments (reader #463). A predicate this deployment's
+ * matcher refuses is a rejected client input: the job row records the reason and
+ * the record is acknowledged, because redelivering the same snapshotted
+ * predicate can only be refused again — retrying it to the DLQ buries a 4xx in
+ * the infrastructure alarms. Everything else — the SQS/DDB/S3-class failure a
+ * retry can actually clear — fails the row and propagates, so partial batch
+ * failure redelivers it.
  */
 export const processOrganizeJob = async (
 	event: OrganizeJobEvent,
 	log: Logger,
+	deps: ProcessOrganizeJobDeps = {},
 ): Promise<void> => {
 	const { accountConfigId, organizeJobId } = event;
-	const client = await getClient();
+	const client = deps.client ?? (await getClient());
 
 	const job = await client.organizeJobRequest.get(organizeJobId);
 	await client.organizeJobRequest.update(organizeJobId, { state: "Running" });
@@ -39,13 +54,30 @@ export const processOrganizeJob = async (
 
 	try {
 		const predicate = predicateFromJob(job);
-		const matchDeps = buildOrganizeMatchDeps(client);
-		const { messageIds, semanticUnavailable } = await matchOrganize(
+		const matchDeps = deps.matchDeps ?? buildOrganizeMatchDeps(client);
+		const match = await matchOrganize(
 			matchDeps,
 			accountConfigId,
 			predicate,
 			ORGANIZE_MATCH_LIMIT,
 		);
+
+		if (match.rejected) {
+			await client.organizeJobRequest.update(organizeJobId, {
+				state: "Failed",
+				matchedCount: 0,
+				appliedCount: 0,
+				failedCount: 0,
+				errorMessage: match.rejected.message,
+			});
+			log.warn(
+				{ accountConfigId, organizeJobId, reason: match.rejected.reason },
+				"Organize back-apply refused the job's rule; failing the job without a retry",
+			);
+			return;
+		}
+
+		const { messageIds, semanticUnavailable } = match;
 		const { applied, failed } = await applyOrganize(
 			{
 				client,