@remit/account-worker 0.0.25 → 0.0.27

package/src/handlers/account-purge.ts

@@ -1,19 +1,9 @@
-import { randomUUID } from "node:crypto";
-import {
-	SendMessageBatchCommand,
-	SendMessageCommand,
-	type SQSClient,
-} from "@aws-sdk/client-sqs";
-import { Message } from "@remit/electrodb-entities";
-import type { Logger } from "@remit/logger-lambda";
-import type { SearchIndexMessage } from "@remit/search-index-worker";
-import { Entity } from "electrodb";
+import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import type { Logger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import {
-	dataBackend as defaultDataBackend,
 	getAccountPurgeDeleteQueueUrl,
 	getCascadeServices,
-	getSearchIndexQueueUrl,
 	getSqsClient,
 } from "../config.js";
 import type {
@@ -26,12 +16,8 @@ export interface ProcessPurgeFanoutDeps {
 	services?: CascadeServices;
 	sqs?: SQSClient;
 	accountPurgeDeleteQueueUrl?: string;
-	searchIndexQueueUrl?: string;
-	dataBackend?: string;
 }
 
-const SQS_BATCH_SIZE = 10;
-
 /**
  * Message subtrees carried per FIFO finalize message. Each item is two ids
  * (~70 bytes of JSON), so 100 stays far under the 256 KB SQS limit, and the
@@ -40,59 +26,6 @@ const SQS_BATCH_SIZE = 10;
  */
 const SUBTREE_BATCH_SIZE = 100;
 
-const messageEntity = new Entity(Message, { table: "purge-keys" });
-
-const messageKeys = (messageId: string): { pk: string; sk: string } => {
-	const { Key } = messageEntity.delete({ messageId }).params<{
-		Key: { pk: string; sk: string };
-	}>();
-	return Key;
-};
-
-const buildVectorDeleteEvent = (
-	accountId: string,
-	messageId: string,
-): SearchIndexMessage => ({
-	eventName: "REMOVE",
-	entity: "Message",
-	eventID: randomUUID(),
-	eventTimestamp: Date.now(),
-	accountId,
-	keys: messageKeys(messageId),
-	messageId,
-});
-
-const enqueueVectorDeletes = async (
-	sqs: SQSClient,
-	queueUrl: string,
-	accountId: string,
-	messageIds: string[],
-): Promise<void> => {
-	for (let i = 0; i < messageIds.length; i += SQS_BATCH_SIZE) {
-		const batch = messageIds.slice(i, i + SQS_BATCH_SIZE);
-		const result = await sqs.send(
-			new SendMessageBatchCommand({
-				QueueUrl: queueUrl,
-				Entries: batch.map((messageId, idx) => ({
-					Id: `${i + idx}`,
-					MessageBody: JSON.stringify(
-						buildVectorDeleteEvent(accountId, messageId),
-					),
-				})),
-			}),
-		);
-		// SendMessageBatch returns HTTP 200 with per-entry failures in `Failed`;
-		// throw so the failed deletes surface to the DLQ and the whole fanout
-		// replays idempotently rather than silently skipping vector deletes.
-		if (result.Failed?.length) {
-			const failedIds = result.Failed.map((f) => f.Id).join(", ");
-			throw new Error(
-				`Search-index vector-delete batch had ${result.Failed.length} failed entries: ${failedIds}`,
-			);
-		}
-	}
-};
-
 /**
  * Enqueue the destructive purge work onto the FIFO finalize queue, single
  * message group per account so the worker processes everything strictly in
@@ -141,9 +74,8 @@ const enqueuePurgeFinalize = async (
  * manifest (`pk = accountConfigId`, scoped to this account's mailbox set) —
  * since the threading-visibility fix every persisted Message has exactly one
  * manifest row, so the partition is a complete, describe-free index of the
- * account's messages. Enqueues the per-message search-index (vector) deletes
- * (#457), then hands the destructive DDB+S3+CloudFront work to the finalize
- * worker as a stream of FIFO messages (subtree batches + one container
+ * account's messages. Hands the destructive DDB+S3+CloudFront work to the
+ * finalize worker as a stream of FIFO messages (subtree batches + one container
  * leftover, single message group). No self-loop, no recursion: the producer
  * enqueues all the work and the worker only ever consumes (#1069).
  *
@@ -151,8 +83,8 @@ const enqueuePurgeFinalize = async (
  * its sibling accounts, the tenant-shared Address rows, and the soft-deleted
  * account row are untouched.
  *
- * Replay-safe: the manifest read is read-only and the search-index/finalize
- * enqueues are idempotent. A redelivery after the account's rows are gone reads
+ * Replay-safe: the manifest read is read-only and the finalize enqueues are
+ * idempotent. A redelivery after the account's rows are gone reads
  * an empty manifest and enqueues only a container leftover that no-ops.
  */
 export const processAccountDataPurge = async (
@@ -162,13 +94,8 @@ export const processAccountDataPurge = async (
 ): Promise<void> => {
 	const { accountId, accountConfigId } = event;
 	const services = deps.services ?? (await getCascadeServices());
-	const sqsFor = (queueUrl: string): SQSClient =>
-		deps.sqs ?? getSqsClient(queueUrl);
 	const accountPurgeDeleteQueueUrl =
 		deps.accountPurgeDeleteQueueUrl ?? getAccountPurgeDeleteQueueUrl();
-	const searchIndexQueueUrl =
-		deps.searchIndexQueueUrl ?? getSearchIndexQueueUrl();
-	const dataBackend = deps.dataBackend ?? defaultDataBackend;
 
 	let mailboxIds: Set<string>;
 	try {
@@ -194,27 +121,8 @@ export const processAccountDataPurge = async (
 			messageId: tm.messageId,
 		}));
 
-	const messageIds = [...new Set(items.map((i) => i.messageId))];
-
-	// On the relational backend the destructive delete emits a `message.removed`
-	// outbox row per message, which the search-index worker relays as a
-	// search-index REMOVE; enqueuing here too would double the removal. On
-	// DynamoDB this fanout is the sole producer of the vector deletes (#457).
-	if (dataBackend !== "sqlite") {
-		await enqueueVectorDeletes(
-			sqsFor(searchIndexQueueUrl),
-			searchIndexQueueUrl,
-			accountId,
-			messageIds,
-		);
-		log.info(
-			{ accountConfigId, accountId, count: messageIds.length },
-			"Enqueued search-index deletes for purged account",
-		);
-	}
-
 	await enqueuePurgeFinalize(
-		sqsFor(accountPurgeDeleteQueueUrl),
+		deps.sqs ?? getSqsClient(accountPurgeDeleteQueueUrl),
 		accountPurgeDeleteQueueUrl,
 		accountId,
 		accountConfigId,

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

@@ -1,10 +1,24 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { randomUUID } from "node:crypto";
+import { afterEach, describe, it } from "node:test";
 import type { RemitClient } from "@remit/backend/client";
-import type { OrganizeMatchDeps } from "@remit/backend/organize";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import {
+	buildOrganizeMatchDeps,
+	type OrganizeMatchDeps,
+} from "@remit/backend/organize";
+import type { FilterItem } from "@remit/data-ports";
+import { NotFoundError } from "@remit/data-ports/errors";
+import {
+	DrizzleThreadMessageRepository,
+	SearchIndex,
+} from "@remit/drizzle-service";
+import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
+import { noopLogger } from "@remit/logger";
 import type { OrganizeJobEvent } from "../events.js";
-import { processOrganizeJob } from "./organize-job.js";
+import {
+	type ProcessOrganizeJobDeps,
+	processOrganizeJob,
+} from "./organize-job.js";
 
 interface Update {
 	state: string;
@@ -29,10 +43,9 @@ const jobClient = (
 			get: async () => ({
 				organizeJobId: "job-1",
 				accountConfigId: "cfg-1",
-				anchorMessageId: "None",
+				filterId: "None",
 				matchOperator: "And",
 				literalClauses,
-				similarityThreshold: 0.75,
 				actionLabelId: "lbl-1",
 				actionMailboxId: "None",
 			}),
@@ -49,19 +62,10 @@ const jobClient = (
  */
 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;
+	}) as OrganizeMatchDeps;
 
 describe("processOrganizeJob (reader #463)", () => {
 	it("fails the job on a refused rule and acknowledges the record", async () => {
@@ -104,3 +108,297 @@ describe("processOrganizeJob (reader #463)", () => {
 		assert.equal(updates[1]?.errorMessage, "SQLITE_BUSY");
 	});
 });
+
+interface Move {
+	messageId: string;
+	destinationMailboxId: string;
+}
+
+const CONFIG = "cfg-1";
+const INBOX = "mbx-inbox";
+const ARCHIVE = "mbx-archive";
+
+const standingFilter = (over: Partial<FilterItem> = {}): FilterItem => ({
+	filterId: "flt-1",
+	accountConfigId: CONFIG,
+	name: "Invoices",
+	scope: "Standing",
+	state: "Active",
+	disabledReason: "None",
+	ruleChangedAt: 1,
+	actionChangedAt: 1,
+	matchOperator: "And",
+	literalClauses: [{ field: "From", value: "billing@example.com" }],
+	actionLabelId: "None",
+	actionMailboxId: "mbx-invoices",
+	createdAt: 0,
+	updatedAt: 0,
+	...over,
+});
+
+/**
+ * The thread rows live in the shipped SQLite schema, read through the real
+ * repository, so the inbox narrowing is the store's own query. One invoice
+ * sits in the inbox and one in the archive, both from the filter's sender
+ * and both saying "overdue" in their preview.
+ */
+const seedThreads = async (
+	threadMessage: DrizzleThreadMessageRepository,
+): Promise<{ inbox: string; archive: string }> => {
+	const seed = async (mailboxId: string, uid: number): Promise<string> => {
+		const messageId = randomUUID();
+		await threadMessage.create({
+			accountConfigId: CONFIG,
+			threadId: randomUUID(),
+			messageId,
+			mailboxId,
+			uid,
+			referenceOrder: 0,
+			internalDate: uid,
+			sentDate: uid,
+			subject: "Your invoice",
+			fromEmail: "billing@example.com",
+			fromName: "Billing",
+			snippet: "This invoice is overdue",
+			isRead: false,
+			isDeleted: false,
+			hasAttachment: false,
+			hasStars: false,
+		});
+		return messageId;
+	};
+	return { inbox: await seed(INBOX, 1), archive: await seed(ARCHIVE, 2) };
+};
+
+interface World {
+	client: RemitClient;
+	inbox: string;
+	archive: string;
+	updates: Update[];
+	filterUpdates: Array<{ filterId: string; patch: Record<string, unknown> }>;
+	moves: Move[];
+	labeled: string[];
+	close: () => void;
+}
+
+const world = async (filters: FilterItem[]): Promise<World> => {
+	const store = createShippedSqliteDb();
+	const threadMessage = new DrizzleThreadMessageRepository(
+		store.db as never,
+		new SearchIndex(store.db as never, store.db as never),
+	);
+	const { inbox, archive } = await seedThreads(threadMessage);
+	const updates: Update[] = [];
+	const filterUpdates: World["filterUpdates"] = [];
+	const labeled: string[] = [];
+	const mailboxOf: Record<string, string> = {
+		[inbox]: INBOX,
+		[archive]: ARCHIVE,
+	};
+	const client = {
+		threadMessage,
+		organizeJobRequest: {
+			get: async () => ({
+				organizeJobId: "job-1",
+				accountConfigId: CONFIG,
+				filterId: "flt-1",
+				matchOperator: "And",
+				literalClauses: [],
+				actionLabelId: "None",
+				actionMailboxId: "None",
+			}),
+			update: async (_id: string, patch: Update) => {
+				updates.push(patch);
+			},
+		},
+		filter: {
+			get: async (_cfg: string, filterId: string) => {
+				const found = filters.find((f) => f.filterId === filterId);
+				if (!found) throw new NotFoundError(`Filter not found: ${filterId}`);
+				return found;
+			},
+			refreshExpiry: async (filter: FilterItem) => filter,
+			listByAccountAndState: async (_cfg: string, state: string) =>
+				filters.filter((f) => f.state === state),
+			update: async (
+				_cfg: string,
+				filterId: string,
+				patch: Record<string, unknown>,
+			) => {
+				filterUpdates.push({ filterId, patch });
+				return {};
+			},
+		},
+		account: {
+			listMailSourcesByAccountConfig: async () => [{ accountId: "acct-1" }],
+			get: async (accountId: string) => ({
+				accountId,
+				email: accountId === "acct-1" ? "me@example.com" : "me-too@example.com",
+			}),
+		},
+		mailboxSpecialUse: {
+			findInboxMailbox: async () => ({ mailboxId: INBOX, fullPath: "INBOX" }),
+		},
+		message: {
+			get: async (messageId: string) => ({
+				messageId,
+				mailboxId: mailboxOf[messageId],
+			}),
+		},
+		mailbox: {
+			resolveAccountId: async (mailboxId: string) =>
+				mailboxId === "mbx-gone"
+					? null
+					: mailboxId === "mbx-sibling-travel"
+						? "acct-2"
+						: "acct-1",
+			get: async (_accountId: string, mailboxId: string) => ({
+				mailboxId,
+				fullPath: mailboxId === "mbx-sibling-travel" ? "Travel" : "Invoices",
+			}),
+		},
+		messageLabel: {
+			apply: async (input: { messageId: string }) => {
+				labeled.push(input.messageId);
+				return {};
+			},
+		},
+	} as unknown as RemitClient;
+	return {
+		client,
+		inbox,
+		archive,
+		updates,
+		filterUpdates,
+		moves: [],
+		labeled,
+		close: store.close,
+	};
+};
+
+const recordingMoves = (moves: Move[]) =>
+	({
+		moveMessage: async (
+			_cfg: string,
+			messageId: string,
+			destinationMailboxId: string,
+		) => {
+			moves.push({ messageId, destinationMailboxId });
+		},
+	}) as unknown as NonNullable<ProcessOrganizeJobDeps["moveService"]>;
+
+const runFilterJob = (w: World) =>
+	processOrganizeJob(event, noopLogger, {
+		client: w.client,
+		matchDeps: buildOrganizeMatchDeps(w.client),
+		moveService: recordingMoves(w.moves),
+	});
+
+describe("processOrganizeJob for a filter job (#1354)", () => {
+	let current: World | undefined;
+	afterEach(() => current?.close());
+
+	it("moves the pre-existing matching inbox message and leaves the archive alone", async () => {
+		current = await world([standingFilter()]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, [
+			{ messageId: current.inbox, destinationMailboxId: "mbx-invoices" },
+		]);
+		const done = current.updates.at(-1);
+		assert.equal(done?.state, "Complete");
+		assert.equal(done?.matchedCount, 1);
+		assert.equal(done?.appliedCount, 1);
+	});
+
+	it("matches a free-text rule from search on the stored preview", async () => {
+		current = await world([
+			standingFilter({
+				literalClauses: [{ field: "HasWords", value: "overdue" }],
+			}),
+		]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, [
+			{ messageId: current.inbox, destinationMailboxId: "mbx-invoices" },
+		]);
+		assert.equal(current.updates.at(-1)?.state, "Complete");
+	});
+
+	it("leaves the move to a newer filter that also matches, and still labels", async () => {
+		current = await world([
+			standingFilter({ actionLabelId: "lbl-bills" }),
+			standingFilter({
+				filterId: "flt-2",
+				name: "Receipts",
+				actionChangedAt: 2,
+				actionMailboxId: "mbx-receipts",
+			}),
+		]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.deepEqual(current.labeled, [current.inbox]);
+		assert.equal(current.updates.at(-1)?.state, "Complete");
+	});
+
+	it("skips another account's mail, as if the filter had not matched", async () => {
+		current = await world([
+			standingFilter({
+				actionLabelId: "lbl-trips",
+				actionMailboxId: "mbx-sibling-travel",
+			}),
+		]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.deepEqual(current.labeled, []);
+		assert.deepEqual(current.filterUpdates, []);
+		const done = current.updates.at(-1);
+		assert.equal(done?.state, "Complete");
+		assert.equal(done?.appliedCount, 0);
+		assert.equal(done?.failedCount, 0);
+	});
+
+	it("turns the filter off and fails the job when no account holds its folder", async () => {
+		current = await world([standingFilter({ actionMailboxId: "mbx-gone" })]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.deepEqual(current.filterUpdates, [
+			{
+				filterId: "flt-1",
+				patch: { state: "Disabled", disabledReason: "FolderMissing" },
+			},
+		]);
+		const done = current.updates.at(-1);
+		assert.equal(done?.state, "Failed");
+		assert.match(String(done?.errorMessage), /no longer exists/);
+	});
+
+	it("fails the job without a retry when the filter is turned off", async () => {
+		current = await world([
+			standingFilter({ state: "Disabled", disabledReason: "UserDisabled" }),
+		]);
+
+		await runFilterJob(current);
+
+		assert.deepEqual(current.moves, []);
+		assert.equal(current.updates.at(-1)?.state, "Failed");
+		assert.match(String(current.updates.at(-1)?.errorMessage), /turned off/);
+	});
+
+	it("fails the job without a retry when the filter was deleted", async () => {
+		current = await world([]);
+
+		await runFilterJob(current);
+
+		assert.equal(current.updates.at(-1)?.state, "Failed");
+		assert.match(String(current.updates.at(-1)?.errorMessage), /deleted/);
+	});
+});

package/src/handlers/organize-job.ts

@@ -1,30 +1,85 @@
 import { getClient, type RemitClient } from "@remit/backend/client";
 import {
+	type ApplyOrganizeDeps,
 	applyOrganize,
+	backApplyFilter,
 	buildOrganizeMatchDeps,
 	buildOrganizeMoveService,
+	isFilterJob,
 	matchOrganize,
 	ORGANIZE_MATCH_LIMIT,
 	type OrganizeMatchDeps,
+	type OrganizeRejection,
 	predicateFromJob,
 } from "@remit/backend/organize";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { OrganizeJobEvent } from "../events.js";
 
 export interface ProcessOrganizeJobDeps {
 	client?: RemitClient;
 	matchDeps?: OrganizeMatchDeps;
+	moveService?: ApplyOrganizeDeps["moveService"];
 }
 
+interface OrganizeOutcome {
+	rejected: OrganizeRejection | null;
+	matched: number;
+	applied: number;
+	failed: number;
+	failures: string[];
+}
+
+const rejectedOutcome = (rejected: OrganizeRejection): OrganizeOutcome => ({
+	rejected,
+	matched: 0,
+	applied: 0,
+	failed: 0,
+	failures: [],
+});
+
+/**
+ * The "all like these" pass: the predicate snapshotted on the row, over every
+ * folder, every requested move applied (reader #497).
+ */
+const runSnapshot = async (
+	client: RemitClient,
+	matchDeps: OrganizeMatchDeps,
+	moveService: ApplyOrganizeDeps["moveService"],
+	job: Awaited<ReturnType<RemitClient["organizeJobRequest"]["get"]>>,
+): Promise<OrganizeOutcome> => {
+	const predicate = predicateFromJob(job);
+	const match = await matchOrganize(
+		matchDeps,
+		job.accountConfigId,
+		predicate,
+		ORGANIZE_MATCH_LIMIT,
+	);
+	if (match.rejected) return rejectedOutcome(match.rejected);
+	const { applied, failed, failures } = await applyOrganize(
+		{ client, moveService },
+		job.accountConfigId,
+		match.messageIds,
+		predicate,
+	);
+	return {
+		rejected: null,
+		matched: match.messageIds.length,
+		applied,
+		failed,
+		failures,
+	};
+};
+
 /**
- * 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,
- * in one pass, then record the counts. Mirrors the export job's lifecycle —
+ * Run a back-apply job (RFC 034, #1278): an "all like these" pass matches the
+ * corpus against the job's snapshotted predicate; a filter job (#1354) runs the
+ * named standing filter over the inbox with index-time move precedence. Either
+ * applies the action to every match in one pass, then records the counts. Mirrors the export job's lifecycle —
  * Running, then Complete/Failed — on the same fanout seam.
  *
  * Reuses the shared matcher (so the applied set equals what preview returned)
  * and the idempotent apply plumbing; `appliedByFilterId` is never written and no
- * Filter/FilterAnchor row is ever created. Both back-apply actions run here: the
+ * Filter row is ever created. Both back-apply actions run here: the
  * 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.
@@ -53,52 +108,49 @@ export const processOrganizeJob = async (
 	);
 
 	try {
-		const predicate = predicateFromJob(job);
 		const matchDeps = deps.matchDeps ?? buildOrganizeMatchDeps(client);
-		const match = await matchOrganize(
-			matchDeps,
-			accountConfigId,
-			predicate,
-			ORGANIZE_MATCH_LIMIT,
-		);
+		const moveService = deps.moveService ?? buildOrganizeMoveService(client);
+		const outcome = isFilterJob(job)
+			? await backApplyFilter(
+					{ client, matchDeps, moveService },
+					accountConfigId,
+					job.filterId,
+				).then((result) =>
+					result.rejected ? rejectedOutcome(result.rejected) : result,
+				)
+			: await runSnapshot(client, matchDeps, moveService, job);
 
-		if (match.rejected) {
+		if (outcome.rejected) {
 			await client.organizeJobRequest.update(organizeJobId, {
 				state: "Failed",
 				matchedCount: 0,
 				appliedCount: 0,
 				failedCount: 0,
-				errorMessage: match.rejected.message,
+				errorMessage: outcome.rejected.message,
 			});
 			log.warn(
-				{ accountConfigId, organizeJobId, reason: match.rejected.reason },
+				{ accountConfigId, organizeJobId, reason: outcome.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, moveService: buildOrganizeMoveService(client) },
-			accountConfigId,
-			messageIds,
-			predicate,
-		);
-
+		const { matched, applied, failed, failures } = outcome;
 		await client.organizeJobRequest.update(organizeJobId, {
 			state: "Complete",
-			matchedCount: messageIds.length,
+			matchedCount: matched,
 			appliedCount: applied,
 			failedCount: failed,
+			errorMessage: failures[0] ?? "",
 		});
 		log.info(
 			{
 				accountConfigId,
 				organizeJobId,
-				matched: messageIds.length,
+				filterId: job.filterId,
+				matched,
 				applied,
 				failed,
-				semanticUnavailable,
 			},
 			"Organize back-apply complete",
 		);

package/src/handlers/sender-category-backapply.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { RemitClient } from "@remit/backend/client";
 import { NotFoundError } from "@remit/data-ports/errors";
-import { noopLogger } from "@remit/logger-lambda/noop-logger";
+import { noopLogger } from "@remit/logger";
 import type { SenderCategoryBackApplyEvent } from "../events.js";
 import { processSenderCategoryBackApply } from "./sender-category-backapply.js";
 

package/src/handlers/sender-category-backapply.ts

@@ -4,7 +4,7 @@ import {
 	SENDER_CATEGORY_BACKAPPLY_LIMIT,
 } from "@remit/backend/sender-category";
 import { NotFoundError } from "@remit/data-ports/errors";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import type { SenderCategoryBackApplyEvent } from "../events.js";
 
 export interface ProcessSenderCategoryBackApplyDeps {