@remit/account-worker 0.0.1

package/src/handlers/account-finalize.ts

@@ -0,0 +1,311 @@
+import { inspect } from "node:util";
+import { createLogger, type Logger, withTelemetry } from "@remit/logger-lambda";
+import type { SQSEvent, SQSHandler } from "aws-lambda";
+import {
+	type CascadeEntity,
+	type CascadeServices,
+	collectMessageChildEntities,
+	enumerateCascadeEntities,
+} from "../cascade.js";
+import { cascadeServices as defaultCascadeServices } from "../config.js";
+import {
+	type DeletionCapabilities,
+	getDeletionCapabilities,
+} from "../deletion-capabilities.js";
+import type {
+	AccountDataPurgeFinalizeEvent,
+	AccountDeleteFinalizeEvent,
+	AccountFinalizeEvent,
+} from "../events.js";
+
+export interface ProcessFinalizeDeps {
+	capabilities?: DeletionCapabilities;
+	cascadeServices?: CascadeServices;
+}
+
+const resolveDeps = async (
+	deps: ProcessFinalizeDeps,
+): Promise<{
+	capabilities: DeletionCapabilities;
+	services: CascadeServices;
+}> => ({
+	capabilities: deps.capabilities ?? (await getDeletionCapabilities()),
+	services: deps.cascadeServices ?? defaultCascadeServices,
+});
+
+/**
+ * GDPR hard-delete: every row tied to the deleted AccountConfig is removed and
+ * every stored object under `accounts/{accountConfigId}/` is purged. The
+ * AccountConfig row itself is the LAST delete so that a mid-cascade replay still
+ * sees the cascade-in-progress flag (`deletedAt` set, `isActive=false`, written
+ * API-side) and re-runs cleanly. After a successful run nothing tied to the
+ * AccountConfig persists.
+ *
+ * Step order (non-negotiable per #320):
+ *   1. Content invalidation — runs FIRST so cached body parts cannot leak after
+ *      the underlying objects are gone (a no-op where no CDN fronts content).
+ *   2. Relational/DDB cascade delete in dependency order (children → parents).
+ *   3. Storage prefix cleanup `accounts/{accountConfigId}/`.
+ *   4. AccountConfig delete.
+ *
+ * Idempotency: every step is replay-safe. The cascade on a missing key is a
+ * no-op, storage prefix delete on missing keys is a no-op, and invalidation is
+ * always idempotent. No explicit "already deleted" pre-checks — they make
+ * replays racier, not safer. Errors propagate so SQS retries the message;
+ * eventually the DLQ alarm fires and an operator inspects the failure.
+ */
+export const processAccountFinalize = async (
+	event: AccountDeleteFinalizeEvent,
+	log: Logger,
+	deps: ProcessFinalizeDeps = {},
+): Promise<void> => {
+	const { accountConfigId } = event;
+	const { capabilities, services } = await resolveDeps(deps);
+
+	// Validate every deploy-time precondition BEFORE the first destructive step,
+	// so a missing var fails loud instead of deleting rows in the cascade and
+	// only then erroring at the storage step.
+	await capabilities.assertReady(log);
+
+	// Step 1: content invalidation — first, so cached body parts cannot leak
+	// after the underlying objects are gone.
+	log.info(
+		{ accountConfigId },
+		"Invalidating cached content for erased account",
+	);
+	await capabilities.invalidateContent(accountConfigId, log);
+
+	// Step 2: cascade delete (children → parents). The AccountConfig row is
+	// excluded from the cascade plan and removed last, after storage.
+	//
+	// SQS is at-least-once: a successful cascade can be redelivered. After a
+	// clean run the AccountConfig row is gone, so `describe()` throws
+	// `NotFoundError` — that's the success signal, not a failure. Treat it as
+	// "cascade already complete" and return cleanly. Any other error propagates
+	// so SQS retries → DLQ.
+	let entities: CascadeEntity[];
+	try {
+		const enumeration = await enumerateCascadeEntities(
+			accountConfigId,
+			services,
+			log,
+		);
+		entities = enumeration.entities;
+	} catch (error) {
+		if ((error as { name?: string })?.name === "NotFoundError") {
+			log.info(
+				{ accountConfigId },
+				"Cascade already complete (AccountConfig not found on replay) — no-op",
+			);
+			return;
+		}
+		throw error;
+	}
+	const cascadeEntities = entities.filter(
+		(e) => e.entityType !== "AccountConfig",
+	);
+	await capabilities.cascadeDelete(cascadeEntities, log);
+
+	// Step 3: storage prefix cleanup. Runs AFTER the cascade so a mid-cascade
+	// replay always re-runs the (idempotent) storage step.
+	await capabilities.deleteStoragePrefix(`accounts/${accountConfigId}/`, log);
+
+	// Step 4: AccountConfig delete — the last write. The presence of an
+	// AccountConfig row with `deletedAt` set is the cascade-in-progress flag;
+	// removing the row is the only signal the cascade fully finished.
+	await services.accountConfigService.delete(accountConfigId);
+	log.info({ accountConfigId }, "AccountConfig deleted; cascade complete");
+};
+
+/**
+ * Destructive phase of the per-account purge. Consumes the FIFO stream the
+ * fanout producer emits (#1069), one message group per account so the messages
+ * arrive strictly in order: every `subtrees` batch, then exactly one
+ * `container` leftover. There is NO self-re-enqueue — the producer enqueues all
+ * the work; this worker only ever consumes.
+ *
+ * Idempotency: the cascade on a missing key is a no-op, so a redelivered batch
+ * (or container) no-ops on already-gone rows. Search-index cleanup is not driven
+ * from here: on DynamoDB the fanout step enqueues a REMOVE per message id up
+ * front; on the relational backends the cascade emits a `message.removed` outbox
+ * row the search-index worker relays.
+ */
+export const processAccountDataPurgeFinalize = async (
+	event: AccountDataPurgeFinalizeEvent,
+	log: Logger,
+	deps: ProcessFinalizeDeps = {},
+): Promise<void> => {
+	if (event.kind === "subtrees") {
+		await processPurgeSubtrees(event, log, deps);
+		return;
+	}
+	await processPurgeContainer(event, log, deps);
+};
+
+/**
+ * Delete a batch of message subtrees. For each `{ threadMessageId, messageId }`
+ * the manifest row is deleted UNCONDITIONALLY — there are ghost ThreadMessages
+ * whose Message is already gone — and the Message + its 9 child entities are
+ * deleted only when `describe()` resolves. A `describe()` 404 means the subtree
+ * is already gone: skip the children, still drop the manifest row.
+ */
+const processPurgeSubtrees = async (
+	event: Extract<AccountDataPurgeFinalizeEvent, { kind: "subtrees" }>,
+	log: Logger,
+	deps: ProcessFinalizeDeps,
+): Promise<void> => {
+	const { accountId, accountConfigId, items } = event;
+	const { capabilities, services } = await resolveDeps(deps);
+
+	const entities: CascadeEntity[] = [];
+	for (const { threadMessageId, messageId } of items) {
+		entities.push({
+			entityType: "ThreadMessage",
+			key: { accountConfigId, threadMessageId },
+		});
+		try {
+			const messageData = await services.messageService.describe(messageId);
+			entities.push({ entityType: "Message", key: { messageId } });
+			collectMessageChildEntities(entities, messageData);
+		} catch (error) {
+			if ((error as { name?: string })?.name === "NotFoundError") {
+				log.info(
+					{ accountConfigId, accountId, messageId },
+					"Message subtree already gone — deleting manifest row only",
+				);
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	await capabilities.cascadeDelete(entities, log);
+	log.info(
+		{ accountConfigId, accountId, count: items.length },
+		"Per-account purge subtree batch deleted",
+	);
+};
+
+/**
+ * The container leftover — processed last in the FIFO group, after every subtree
+ * delete. Deletes the account-keyed container rows (mailboxes, outbox, locks),
+ * the storage prefix `accounts/{cfg}/{acct}/`, and invalidates the account's
+ * cached content. Ordering is invalidate-before-storage, storage-after-cascade.
+ * The tenant-shared Address rows, the AccountConfig, sibling accounts, and the
+ * soft-deleted account row (the purge-in-progress marker) are all kept.
+ */
+const processPurgeContainer = async (
+	event: Extract<AccountDataPurgeFinalizeEvent, { kind: "container" }>,
+	log: Logger,
+	deps: ProcessFinalizeDeps,
+): Promise<void> => {
+	const { accountId, accountConfigId } = event;
+	const { capabilities, services } = await resolveDeps(deps);
+
+	// The account row is kept as the purge-in-progress marker. Its absence means
+	// the container leftover already ran — no-op on redelivery.
+	let accountDescription: Awaited<
+		ReturnType<CascadeServices["accountService"]["describe"]>
+	>;
+	try {
+		accountDescription = await services.accountService.describe(accountId);
+	} catch (error) {
+		if ((error as { name?: string })?.name === "NotFoundError") {
+			log.info(
+				{ accountConfigId, accountId },
+				"Per-account purge already complete (account row gone) — no-op",
+			);
+			return;
+		}
+		throw error;
+	}
+
+	// Validate every deploy-time precondition BEFORE the first destructive step.
+	// Runs after the account-existence guard so a redelivery whose account row is
+	// already gone still returns cleanly without needing the config present.
+	await capabilities.assertReady(log);
+
+	// Step 1: content invalidation — first, so cached body parts cannot leak
+	// after the underlying objects are gone.
+	log.info(
+		{ accountConfigId, accountId },
+		"Invalidating cached content for purged account",
+	);
+	await capabilities.invalidateContent(`${accountConfigId}/${accountId}`, log);
+
+	// Step 2: container rows — mailboxes, outbox, locks. Address is
+	// tenant-shared and never deleted on a per-account purge.
+	const entities: CascadeEntity[] = [];
+	for (const mailbox of accountDescription.mailbox) {
+		entities.push({
+			entityType: "Mailbox",
+			key: { mailboxId: mailbox.mailboxId },
+		});
+	}
+	const outboxMessages =
+		await services.outboxMessageService.listByAccount(accountId);
+	for (const outbox of outboxMessages.items) {
+		entities.push({
+			entityType: "OutboxMessage",
+			key: { outboxMessageId: outbox.outboxMessageId },
+		});
+	}
+	const locks = await services.mailboxLockService.listByAccount(accountId);
+	for (const lock of locks) {
+		entities.push({
+			entityType: "MailboxLock",
+			key: { mailboxId: lock.mailboxId, eventName: lock.eventName },
+		});
+	}
+	await capabilities.cascadeDelete(entities, log);
+
+	// Step 3: storage prefix cleanup scoped to this account only.
+	await capabilities.deleteStoragePrefix(
+		`accounts/${accountConfigId}/${accountId}/`,
+		log,
+	);
+
+	log.info({ accountConfigId, accountId }, "Per-account data purge complete");
+};
+
+// ---------- SQS handler ----------
+
+const log = createLogger();
+
+export const handler: SQSHandler = withTelemetry(async (event: SQSEvent) => {
+	const batchItemFailures: { itemIdentifier: string }[] = [];
+
+	for (const record of event.Records) {
+		const finalizeEvent: AccountFinalizeEvent = JSON.parse(record.body);
+		log.info(
+			{
+				eventType: finalizeEvent.type,
+				accountConfigId: finalizeEvent.accountConfigId,
+			},
+			"Processing account finalize event",
+		);
+
+		const work =
+			finalizeEvent.type === "FinalizeAccountDataPurge"
+				? processAccountDataPurgeFinalize(finalizeEvent, log)
+				: processAccountFinalize(finalizeEvent, log);
+
+		const failed = await work
+			.then(() => false)
+			.catch((error) => {
+				log.error(
+					{ error: inspect(error), messageId: record.messageId },
+					"Account finalize event processing failed",
+				);
+				return true;
+			});
+
+		if (failed) {
+			batchItemFailures.push({ itemIdentifier: record.messageId });
+		}
+	}
+
+	return { batchItemFailures };
+});
+
+export const finalizeHandler: SQSHandler = handler;

package/src/handlers/account-purge.ts

@@ -0,0 +1,226 @@
+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 type { CascadeServices } from "../cascade.js";
+import {
+	cascadeServices as defaultCascadeServices,
+	dataBackend as defaultDataBackend,
+	sqsClient as defaultSqsClient,
+	getAccountPurgeDeleteQueueUrl,
+	getSearchIndexQueueUrl,
+} from "../config.js";
+import type {
+	AccountDataPurgeEvent,
+	AccountDataPurgeFinalizeEvent,
+	AccountDataPurgeSubtreeItem,
+} from "../events.js";
+
+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
+ * worker's per-item `describe()` + batched delete for 100 subtrees fits well
+ * inside its timeout.
+ */
+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
+ * order: every `subtrees` batch first, then exactly one `container` leftover
+ * last. The FIFO ordering is the barrier — the container delete (mailboxes,
+ * S3, CloudFront) cannot run until all subtree deletes have. The queue's
+ * content-based deduplication makes a fanout replay idempotent within the dedup
+ * window; beyond it, the worker's deletes are no-ops on already-gone rows.
+ */
+const enqueuePurgeFinalize = async (
+	sqs: SQSClient,
+	queueUrl: string,
+	accountId: string,
+	accountConfigId: string,
+	items: AccountDataPurgeSubtreeItem[],
+): Promise<void> => {
+	const send = (event: AccountDataPurgeFinalizeEvent): Promise<unknown> =>
+		sqs.send(
+			new SendMessageCommand({
+				QueueUrl: queueUrl,
+				MessageBody: JSON.stringify(event),
+				MessageGroupId: accountConfigId,
+			}),
+		);
+
+	for (let i = 0; i < items.length; i += SUBTREE_BATCH_SIZE) {
+		await send({
+			type: "FinalizeAccountDataPurge",
+			kind: "subtrees",
+			accountId,
+			accountConfigId,
+			items: items.slice(i, i + SUBTREE_BATCH_SIZE),
+		});
+	}
+
+	await send({
+		type: "FinalizeAccountDataPurge",
+		kind: "container",
+		accountId,
+		accountConfigId,
+	});
+};
+
+/**
+ * Fanout step of the per-account purge. Reads the account's ThreadMessage
+ * 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
+ * leftover, single message group). No self-loop, no recursion: the producer
+ * enqueues all the work and the worker only ever consumes (#1069).
+ *
+ * Runs in the fanout worker. Scoped entirely to `accountId`; the AccountConfig,
+ * 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
+ * an empty manifest and enqueues only a container leftover that no-ops.
+ */
+export const processAccountDataPurge = async (
+	event: AccountDataPurgeEvent,
+	log: Logger,
+	deps: ProcessPurgeFanoutDeps = {},
+): Promise<void> => {
+	const { accountId, accountConfigId } = event;
+	const services = deps.services ?? defaultCascadeServices;
+	const sqs = deps.sqs ?? defaultSqsClient;
+	const accountPurgeDeleteQueueUrl =
+		deps.accountPurgeDeleteQueueUrl ?? getAccountPurgeDeleteQueueUrl();
+	const searchIndexQueueUrl =
+		deps.searchIndexQueueUrl ?? getSearchIndexQueueUrl();
+	const dataBackend = deps.dataBackend ?? defaultDataBackend;
+
+	let mailboxIds: Set<string>;
+	try {
+		const account = await services.accountService.describe(accountId);
+		mailboxIds = new Set(account.mailbox.map((m) => m.mailboxId));
+	} catch (error) {
+		if ((error as { name?: string })?.name === "NotFoundError") {
+			log.info(
+				{ accountConfigId, accountId },
+				"Account purge fanout: account already gone — no-op",
+			);
+			return;
+		}
+		throw error;
+	}
+
+	const manifest =
+		await services.threadMessageService.listAllByAccount(accountConfigId);
+	const items: AccountDataPurgeSubtreeItem[] = manifest
+		.filter((tm) => mailboxIds.has(tm.mailboxId))
+		.map((tm) => ({
+			threadMessageId: tm.threadMessageId,
+			messageId: tm.messageId,
+		}));
+
+	const messageIds = [...new Set(items.map((i) => i.messageId))];
+
+	// On Postgres the destructive delete emits a `message.removed` outbox row per
+	// message, which the pg-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 !== "postgres") {
+		await enqueueVectorDeletes(sqs, searchIndexQueueUrl, accountId, messageIds);
+		log.info(
+			{ accountConfigId, accountId, count: messageIds.length },
+			"Enqueued search-index deletes for purged account",
+		);
+	}
+
+	await enqueuePurgeFinalize(
+		sqs,
+		accountPurgeDeleteQueueUrl,
+		accountId,
+		accountConfigId,
+		items,
+	);
+	log.info(
+		{
+			accountConfigId,
+			accountId,
+			subtreeCount: items.length,
+			batchCount: Math.ceil(items.length / SUBTREE_BATCH_SIZE),
+		},
+		"Enqueued per-account purge subtree batches + container leftover",
+	);
+};

package/src/handlers/organize-job.ts

@@ -0,0 +1,78 @@
+import { getClient } from "@remit/backend/client";
+import {
+	applyOrganize,
+	buildOrganizeMatchDeps,
+	buildOrganizeMoveService,
+	matchOrganize,
+	ORGANIZE_MATCH_LIMIT,
+	predicateFromJob,
+} from "@remit/backend/organize";
+import type { Logger } from "@remit/logger-lambda";
+import type { OrganizeJobEvent } from "../events.js";
+
+/**
+ * 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 —
+ * 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
+ * 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.
+ */
+export const processOrganizeJob = async (
+	event: OrganizeJobEvent,
+	log: Logger,
+): Promise<void> => {
+	const { accountConfigId, organizeJobId } = event;
+	const client = await getClient();
+
+	const job = await client.organizeJobRequest.get(organizeJobId);
+	await client.organizeJobRequest.update(organizeJobId, { state: "Running" });
+	log.info(
+		{ accountConfigId, organizeJobId },
+		"Organize back-apply processing started",
+	);
+
+	try {
+		const predicate = predicateFromJob(job);
+		const messageIds = await matchOrganize(
+			buildOrganizeMatchDeps(client),
+			accountConfigId,
+			predicate,
+			ORGANIZE_MATCH_LIMIT,
+		);
+		const { applied, failed } = await applyOrganize(
+			{ client, moveService: buildOrganizeMoveService(client) },
+			accountConfigId,
+			messageIds,
+			predicate,
+		);
+
+		await client.organizeJobRequest.update(organizeJobId, {
+			state: "Complete",
+			matchedCount: messageIds.length,
+			appliedCount: applied,
+			failedCount: failed,
+		});
+		log.info(
+			{
+				accountConfigId,
+				organizeJobId,
+				matched: messageIds.length,
+				applied,
+				failed,
+			},
+			"Organize back-apply complete",
+		);
+	} catch (error) {
+		await client.organizeJobRequest.update(organizeJobId, {
+			state: "Failed",
+			errorMessage: error instanceof Error ? error.message : String(error),
+		});
+		throw error;
+	}
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+export type {
+	AccountDataPurgeEvent,
+	AccountDataPurgeFinalizeEvent,
+	AccountDeleteEvent,
+	AccountDeleteFinalizeEvent,
+	AccountExportEvent,
+	AccountFanoutEvent,
+	AccountFinalizeEvent,
+} from "./events.js";
+export { handler as fanoutHandler } from "./handlers/account-fanout.js";
+export { finalizeHandler } from "./handlers/account-finalize.js";

package/src/poller.ts

@@ -0,0 +1,39 @@
+import { createLogger } from "@remit/logger-lambda";
+import { runQueuePoller } from "@remit/sqs-client/poller";
+import { env } from "expect-env";
+import { fanoutHandler, finalizeHandler } from "./index.js";
+
+/**
+ * Production queue poller. No e2e shim exists for account-worker today —
+ * the deletion cascade is not exercised on the Postgres/compose stack in
+ * CI (see AGENTS.md worker roster notes). This is the standalone
+ * production entrypoint for the dedicated image.
+ *
+ * The fanout worker's Cognito sign-out and the finalize worker's CloudFront
+ * invalidation are AWS-only calls with no portable counterpart yet — on a
+ * non-AWS deployment those specific steps of the deletion cascade will
+ * error if account deletion is exercised. That is a pre-existing gap in
+ * the application code, not something this packaging change fixes.
+ */
+const log = createLogger();
+
+await runQueuePoller({
+	log,
+	targets: [
+		{
+			queueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+			handler: fanoutHandler,
+			functionName: "account-fanout-worker",
+		},
+		{
+			queueUrl: env.SQS_QUEUE_URL_ACCOUNT_FINALIZE,
+			handler: finalizeHandler,
+			functionName: "account-finalize-worker",
+		},
+		{
+			queueUrl: env.SQS_QUEUE_URL_ACCOUNT_PURGE_DELETE,
+			handler: finalizeHandler,
+			functionName: "account-purge-worker",
+		},
+	],
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "../../tsconfig.json",
+	"compilerOptions": {
+		"outDir": "dist",
+		"rootDir": "src"
+	},
+	"include": ["src/**/*.ts"]
+}