@remit/backend 0.0.137 → 0.0.139

package/src/handlers/filter.test.ts

@@ -1,11 +1,13 @@
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { afterEach, describe, it, mock } from "node:test";
+import type { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type {
 	CreateFilterInput,
 	UpdateFilterInput as UpdateFilterRequestBody,
 } from "@remit/api-openapi-types";
 import type {
 	CreateFilterAnchorInput,
+	CreateOrganizeJobRequestInput,
 	CreateFilterInput as FilterAnchorTxCreateInput,
 	FilterItem,
 } from "@remit/data-ports";
@@ -16,9 +18,19 @@ import {
 	FilterState,
 } from "@remit/domain-enums";
 import type { AnchorPayload } from "@remit/search-service";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import { deriveAccountConfigId } from "../auth.js";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "../service/data-client.js";
+import { sqsClient } from "../service/sqs.js";
 import {
 	createFilterWithAnchor,
 	type FilterCrudDeps,
+	FilterOperations,
 	pickFilterUpdate,
 	rejectAnchorMutation,
 	resolveFilterScopeExpiry,
@@ -516,3 +528,117 @@ describe("createFilterWithAnchor (#351)", () => {
 		);
 	});
 });
+
+describe("createFilter queues the new filter's pass over the inbox (#1354)", () => {
+	const SUB = "cognito-sub-1354";
+	const ACCOUNT_CONFIG_ID = deriveAccountConfigId(SUB);
+	const ACCOUNT_ID = "acc-1354";
+
+	const created: FilterItem = {
+		filterId: "flt-new",
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		name: "Invoices",
+		scope: FilterScope.Standing,
+		state: FilterState.Active,
+		disabledReason: "None",
+		hasAnchor: false,
+		ruleChangedAt: 1,
+		actionChangedAt: 1,
+		matchOperator: FilterMatchOperator.And,
+		literalClauses: [{ field: "From", value: "billing@example.com" }],
+		actionLabelId: "None",
+		actionMailboxId: "mbx-invoices",
+		createdAt: 0,
+		updatedAt: 0,
+	};
+
+	afterEach(() => {
+		mock.restoreAll();
+		_resetForTest();
+	});
+
+	const world = (filter: FilterItem) => {
+		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+			"http://localhost:9324/queue/account-fanout-test";
+		const jobs: CreateOrganizeJobRequestInput[] = [];
+		const enqueued: SendMessageCommand[] = [];
+		mock.method(sqsClient, "send", async (command: SendMessageCommand) => {
+			enqueued.push(command);
+			return {};
+		});
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			mailbox: {
+				get: async () => ({
+					mailboxId: "mbx-invoices",
+					accountId: ACCOUNT_ID,
+					fullPath: "Invoices",
+					syncStatus: "synced",
+				}),
+			},
+			filterAnchorTransaction: { createWithAnchor: async () => filter },
+			organizeJobRequest: {
+				create: async (input: CreateOrganizeJobRequestInput) => {
+					jobs.push(input);
+					return { ...input, organizeJobId: "job-new", state: "Pending" };
+				},
+			},
+		} as unknown as RemitClient);
+		return { jobs, enqueued };
+	};
+
+	const createFilter = (body: Partial<CreateFilterInput>) =>
+		(
+			FilterOperations.FilterOperations_createFilter as (
+				context: Context,
+				event: APIGatewayProxyEvent,
+			) => Promise<Record<string, unknown>>
+		)(
+			{
+				request: {
+					params: { accountId: ACCOUNT_ID },
+					requestBody: {
+						name: created.name,
+						scope: created.scope,
+						matchOperator: created.matchOperator,
+						literalClauses: created.literalClauses,
+						actionLabelId: created.actionLabelId,
+						actionMailboxId: created.actionMailboxId,
+						...body,
+					},
+				},
+			} as unknown as Context,
+			{
+				requestContext: { authorizer: { claims: { sub: SUB } } },
+			} as unknown as APIGatewayProxyEvent,
+		);
+
+	it("queues an organize job for the created filter and returns its id", async () => {
+		const { jobs, enqueued } = world(created);
+
+		const response = await createFilter({});
+
+		assert.equal(jobs.length, 1);
+		assert.equal(jobs[0]?.filterId, "flt-new");
+		assert.equal(enqueued.length, 1);
+		assert.match(String(enqueued[0]?.input.MessageBody), /job-new/);
+		assert.equal(response.organizeJobId, "job-new");
+		assert.equal(response.filterId, "flt-new");
+	});
+
+	it("names only the filter: the predicate columns stay at their sentinels", async () => {
+		const { jobs } = world(created);
+
+		await createFilter({});
+
+		assert.equal(jobs[0]?.anchorMessageId, "None");
+		assert.deepEqual(jobs[0]?.literalClauses, []);
+		assert.equal(jobs[0]?.actionLabelId, "None");
+		assert.equal(jobs[0]?.actionMailboxId, "None");
+	});
+});

package/src/handlers/filter.ts

@@ -1,5 +1,6 @@
 import type {
 	CreateFilterInput,
+	CreateFilterResponse,
 	FilterResponse,
 	UpdateFilterInput as UpdateFilterRequestBody,
 } from "@remit/api-openapi-types";
@@ -19,9 +20,10 @@ import {
 } from "@remit/domain-enums";
 import type { AnchorPayload } from "@remit/search-service";
 import type { APIGatewayProxyEvent } from "aws-lambda";
-import { getAccountConfigIdFromEvent } from "../auth.js";
+import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
 import { getClient } from "../service/data-client.js";
 import { buildFilterAnchor } from "../service/filter.js";
+import { queueOrganizeJob } from "../service/organize-queue.js";
 import type {
 	FilterDetailOperationIds,
 	FilterOperationIds,
@@ -340,6 +342,16 @@ export const createFilterWithAnchor = async (
 	);
 };
 
+const requireUserId = (event: APIGatewayProxyEvent): string => {
+	const userId = getSubFromEvent(event);
+	if (!userId) {
+		throw new Error(
+			"Missing Cognito `sub`: cannot attribute an organize job to a user",
+		);
+	}
+	return userId;
+};
+
 /**
  * A filter's `actionMailboxId` is a durable reference, so its target has to be
  * a folder the mail server has settled (D12, first row) — 422 otherwise. The
@@ -393,11 +405,15 @@ export const FilterOperations: Record<
 		};
 	},
 
-	FilterOperations_createFilter: async (context, ...args: unknown[]) => {
+	FilterOperations_createFilter: async (
+		context,
+		...args: unknown[]
+	): Promise<CreateFilterResponse> => {
 		const event = args[0] as APIGatewayProxyEvent;
 		const accountConfigId = getAccountConfigIdFromEvent(event);
 		const { accountId } = context.request.params as { accountId: string };
 		const input = context.request.requestBody as CreateFilterInput;
+		const userId = requireUserId(event);
 
 		const client = await getClient();
 		const account = await client.account.get(accountId);
@@ -412,7 +428,14 @@ export const FilterOperations: Record<
 			accountConfigId,
 			input,
 		);
-		return toFilterResponse(filter);
+		// The new filter's first pass over the inbox. The worker reads the filter
+		// when it runs and refuses one that has nothing to run (#1354).
+		const job = await queueOrganizeJob(client, {
+			accountConfigId,
+			userId,
+			filterId: filter.filterId,
+		});
+		return { ...toFilterResponse(filter), organizeJobId: job.organizeJobId };
 	},
 };
 

package/src/handlers/mailbox-settled-target.test.ts

@@ -9,7 +9,7 @@
  * only removed by the user, so a `mailboxId` that names nothing never exists.
  */
 import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
+import { afterEach, describe, it, mock } from "node:test";
 import type { MailboxItem } from "@remit/data-ports";
 import { CanonicalMailboxRole, MailboxSyncStatus } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
@@ -20,6 +20,7 @@ import {
 	type RemitClient,
 	setClient,
 } from "../service/data-client.js";
+import { sqsClient } from "../service/sqs.js";
 import { FilterDetailOperations, FilterOperations } from "./filter.js";
 import { FolderRoleOperations } from "./folder-role.js";
 import { MessageBulkOperations } from "./message.js";
@@ -55,6 +56,9 @@ const world = (syncStatus: MailboxItem["syncStatus"]): Writes => {
 		copies: [],
 	};
 	const row = target(syncStatus);
+	process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+		"http://localhost:9324/queue/account-fanout-test";
+	mock.method(sqsClient, "send", async () => ({}));
 
 	setClient({
 		account: {
@@ -85,6 +89,13 @@ const world = (syncStatus: MailboxItem["syncStatus"]): Writes => {
 				return { filterId: "flt-1" };
 			},
 		},
+		organizeJobRequest: {
+			create: async (input: Record<string, unknown>) => ({
+				...input,
+				organizeJobId: "job-1",
+				state: "Pending",
+			}),
+		},
 		accountSetting: {
 			get: async () => null,
 			upsert: async (item: unknown) => {
@@ -168,6 +179,7 @@ const SITES = [
 
 describe("a write that binds to a folder requires a settled folder", () => {
 	afterEach(() => {
+		mock.restoreAll();
 		_resetForTest();
 	});
 

package/src/handlers/organize.test.ts

@@ -4,11 +4,12 @@ import type { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type { OrganizeInput } from "@remit/api-openapi-types";
 import type {
 	CreateOrganizeJobRequestInput,
+	FilterItem,
 	IAccountRepository,
 	IOrganizeJobRequestRepository,
 	OrganizeJobRequestItem,
 } from "@remit/data-ports";
-import { BadRequestError } from "@remit/data-ports/errors";
+import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { FilterMatchOperator } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
 import type { Context } from "openapi-backend";
@@ -186,3 +187,91 @@ describe("createOrganizeJob rejected-rule refusal (reader #995)", () => {
 		);
 	});
 });
+
+describe("createOrganizeJob by filterId — Run now (#1354)", () => {
+	afterEach(() => {
+		mock.restoreAll();
+		_resetForTest();
+	});
+
+	const standing = (state: FilterItem["state"]): FilterItem => ({
+		filterId: "flt-1",
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		name: "Invoices",
+		scope: "Standing",
+		state,
+		disabledReason: state === "Active" ? "None" : "UserDisabled",
+		hasAnchor: false,
+		ruleChangedAt: 1,
+		actionChangedAt: 1,
+		matchOperator: FilterMatchOperator.And,
+		literalClauses: [{ field: "From", value: "billing@example.com" }],
+		actionLabelId: "None",
+		actionMailboxId: "mbx-invoices",
+		createdAt: 0,
+		updatedAt: 0,
+	});
+
+	const withFilter = (filter: FilterItem): void => {
+		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+			"http://localhost:9324/queue/account-fanout-test";
+		enqueued.length = 0;
+		createdRows.length = 0;
+		mock.method(sqsClient, "send", async (command: SendMessageCommand) => {
+			enqueued.push(command);
+			return {};
+		});
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			filter: {
+				get: async () => filter,
+			},
+			organizeJobRequest: {
+				create: async (row: CreateOrganizeJobRequestInput) => {
+					createdRows.push(row);
+					return { ...row, organizeJobId: "job-run", state: "Pending" };
+				},
+			},
+		} as unknown as RemitClient);
+	};
+
+	it("queues a job that names only the filter", async () => {
+		withFilter(standing("Active"));
+
+		const response = await postOrganize(input({ filterId: "flt-1" }));
+
+		assert.equal(response.statusCode, 202);
+		assert.equal(createdRows[0]?.filterId, "flt-1");
+		assert.equal(createdRows[0]?.actionMailboxId, "None");
+		assert.deepEqual(createdRows[0]?.literalClauses, []);
+		assert.equal(enqueued.length, 1);
+	});
+
+	it("answers an unknown filter with a 404 and queues nothing", async () => {
+		withFilter(standing("Active"));
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			filter: {
+				get: async () => {
+					throw new NotFoundError("Filter not found: flt-gone");
+				},
+			},
+		} as unknown as RemitClient);
+
+		const response = await postOrganize(input({ filterId: "flt-gone" }));
+
+		assert.equal(response.statusCode, 404);
+		assert.deepEqual(createdRows, []);
+		assert.deepEqual(enqueued, []);
+	});
+});

package/src/handlers/organize.ts

@@ -1,4 +1,3 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type {
 	CreateOrganizeJobResponse,
 	OrganizeInput,
@@ -6,9 +5,7 @@ import type {
 	OrganizePreviewResponse,
 } from "@remit/api-openapi-types";
 import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
-import { logger } from "@remit/logger-lambda";
 import type { APIGatewayProxyEvent } from "aws-lambda";
-import { env } from "expect-env";
 import type { Context } from "openapi-backend";
 import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
 import { getClient, type RemitClient } from "../service/data-client.js";
@@ -19,7 +16,10 @@ import {
 	type OrganizePredicate,
 	organizePredicateRejection,
 } from "../service/organize.js";
-import { sqsClient } from "../service/sqs.js";
+import {
+	type OrganizeJobRequest,
+	queueOrganizeJob,
+} from "../service/organize-queue.js";
 import type {
 	OperationHandler,
 	OrganizeJobDetailOperationIds,
@@ -29,13 +29,6 @@ import { assertAccountOwnership } from "./account-ownership.js";
 
 const NONE = "None";
 
-/**
- * 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;
-
 /**
  * Normalize the request body into the flattened predicate the job row and the
  * matcher share. `anchorMessageId` collapses to the `"None"` sentinel when
@@ -70,6 +63,7 @@ const toOrganizeJobResponse = (
 	accountConfigId: job.accountConfigId,
 	userId: job.userId,
 	state: job.state,
+	filterId: job.filterId,
 	anchorMessageId: job.anchorMessageId,
 	matchOperator: job.matchOperator,
 	literalClauses: job.literalClauses,
@@ -84,6 +78,27 @@ const toOrganizeJobResponse = (
 	updatedAt: job.updatedAt,
 });
 
+/**
+ * What a create asks the worker to run. A saved filter is named and read when
+ * the job runs, so Run now and a filter's create share one path (#1354); an
+ * "all like these" predicate the matcher can never honour is answered here,
+ * not with a 202 the worker has to fail later (reader #463).
+ */
+const requestedJob = async (
+	client: RemitClient,
+	owner: { accountConfigId: string; userId: string },
+	input: OrganizeInput,
+): Promise<OrganizeJobRequest> => {
+	if (input.filterId) {
+		await client.filter.get(owner.accountConfigId, input.filterId);
+		return { ...owner, filterId: input.filterId };
+	}
+	const predicate = predicateFromInput(input);
+	const rejection = organizePredicateRejection(predicate);
+	if (rejection) throw new BadRequestError(rejection.message);
+	return { ...owner, predicate };
+};
+
 export const OrganizeOperations: Record<
 	OrganizeOperationIds,
 	OperationHandler<OrganizeOperationIds>
@@ -107,42 +122,9 @@ export const OrganizeOperations: Record<
 		const client = await getClient();
 		await assertAccount(client, accountId, accountConfigId, "act");
 
-		const predicate = predicateFromInput(input);
-
-		// A rule the matcher can never honour is answered here, not with a 202
-		// the worker has to fail later (reader #463).
-		const rejection = organizePredicateRejection(predicate);
-		if (rejection) throw new BadRequestError(rejection.message);
-
-		const ttl = Math.floor(Date.now() / 1000) + ORGANIZE_JOB_TTL_SECONDS;
-
-		const job = await client.organizeJobRequest.create({
-			accountConfigId,
-			userId,
-			anchorMessageId: predicate.anchorMessageId,
-			matchOperator: predicate.matchOperator,
-			literalClauses: predicate.literalClauses,
-			similarityThreshold: predicate.similarityThreshold,
-			actionLabelId: predicate.actionLabelId,
-			actionMailboxId: predicate.actionMailboxId,
-			ttl,
-		});
-
-		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 },
-			"Organize back-apply job initiated",
+		const job = await queueOrganizeJob(
+			client,
+			await requestedJob(client, { accountConfigId, userId }, input),
 		);
 
 		return {
@@ -164,6 +146,11 @@ export const OrganizeOperations: Record<
 		const client = await getClient();
 		await assertAccount(client, accountId, accountConfigId, "read");
 
+		if (input.filterId) {
+			throw new BadRequestError(
+				"Preview takes a rule, not a saved filter. Run the filter to apply it.",
+			);
+		}
 		const result = await matchOrganize(
 			buildOrganizeMatchDeps(client),
 			accountConfigId,

package/src/service/organize-queue.ts

@@ -0,0 +1,98 @@
+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;
+};

package/src/service/organize.test.ts

@@ -289,6 +289,7 @@ const matchDeps = (
 		},
 		listAccountFilterMessages: async () => ({ items: corpus }),
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => filterAnchorRows,
 			put: async () => {
 				throw new Error("matchDeps must not repair an anchor");
@@ -330,6 +331,7 @@ const vectorlessDeps = (
 		},
 		listAccountFilterMessages: async () => ({ items: corpus }),
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => [],
 			put: async () => {
 				throw moduleNotFound();
@@ -471,6 +473,7 @@ describe("matchOrganize honors the persisted FilterAnchor (reader #350)", () =>
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [persistedAnchor],
 				put: async () => {
 					throw new Error("a current anchor must not be rewritten");
@@ -757,6 +760,7 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [drifted],
 				put: async () => {
 					throw new Error("an unrepairable anchor must not be rewritten");
@@ -798,6 +802,7 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [],
 				put: async () => {
 					throw new Error("unreachable");
@@ -1120,6 +1125,7 @@ describe("back-apply repairs a drifted anchor the way index-time matching does (
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => anchors,
 				put: async (input: CreateFilterAnchorInput) => {
 					anchorPuts.push(input);
@@ -1319,6 +1325,7 @@ const storeBackedDeps = (
 			};
 		},
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => [],
 			put: async () => {
 				throw new Error("unreachable");