@remit/backend 2.7.0 → 2.8.0

package/dist/src/handlers/classification-settings.d.ts

@@ -1,6 +1,6 @@
-import type { ClassificationConfigured, ClassificationNotConfigured, ClassificationPreset, ClassificationUsage, UpdateUserSettingsInput } from "@remit/api-openapi-types";
+import type { ClassificationConfigured, ClassificationNotConfigured, ClassificationPreset, ClassificationPresetId, ClassificationUsage, UpdateUserSettingsInput } from "@remit/api-openapi-types";
 import type { IAccountSettingRepository } from "@remit/data-ports";
-import { type SavedClassificationProvider, type StoredClassification } from "@remit/data-ports/classification-presets";
+import { type ClassificationResolverDeps, type ResolvedClassification, type ResolvedClassificationProvider } from "@remit/data-ports/classification-resolver";
 import { type ClassificationLabelDeps } from "@remit/mailbox-service";
 import { type SecretsService, type SerializedEncryptedPayload } from "@remit/secrets-service";
 import type { UserSettingsOutcome } from "./user-settings.js";
@@ -32,16 +32,25 @@ export interface ClassificationProviderSave {
     apiKey: ApiKeyChange;
 }
 type ClassificationInput = Pick<UpdateUserSettingsInput, "classificationPresetId" | "classificationModel" | "classificationBaseUrl" | "classificationApiKey" | "classificationEnabled" | "classificationDailyLimit">;
-export declare const decideClassificationProvider: (input: ClassificationInput, stored: StoredClassification) => Decision<ClassificationProviderSave>;
-export declare const publicClassification: (stored: StoredClassification, usage: ClassificationUsage[]) => ClassificationNotConfigured | ClassificationConfigured;
-export declare const readClassificationUsage: (accountSetting: Pick<IAccountSettingRepository, "getMany">, accountConfigId: string, accountIds: readonly string[], saved: Pick<SavedClassificationProvider, "presetId" | "dailyLimit">, now: number) => Promise<ClassificationUsage[]>;
+export type KnownClassification = Exclude<ResolvedClassification, {
+    state: "UnknownPreset";
+}>;
+export declare const readKnownClassification: (deps: ClassificationResolverDeps, accountConfigId: string) => Promise<KnownClassification>;
+export declare const decideClassificationProvider: (input: ClassificationInput, known: KnownClassification) => Decision<ClassificationProviderSave>;
+export declare const publicClassification: (resolved: ResolvedClassificationProvider | {
+    state: "NotConfigured";
+}, usage: ClassificationUsage[]) => ClassificationNotConfigured | ClassificationConfigured;
+export declare const readClassificationUsage: (accountSetting: Pick<IAccountSettingRepository, "getMany">, accountConfigId: string, accountIds: readonly string[], saved: {
+    presetId: ClassificationPresetId;
+    dailyLimit: number;
+}, now: number) => Promise<ClassificationUsage[]>;
 export declare const classificationPresetsResponse: () => ClassificationPreset[];
 interface ClassificationChange {
     provider: ClassificationProviderSave | undefined;
     enabled: boolean | undefined;
     dailyLimit: number | undefined;
 }
-export declare const decideClassificationChange: (input: ClassificationInput, stored: StoredClassification) => Decision<ClassificationChange>;
+export declare const decideClassificationChange: (input: ClassificationInput, known: KnownClassification) => Decision<ClassificationChange>;
 export declare const writeClassificationChange: (deps: ClassificationSettingsDeps, accountConfigId: string, change: ClassificationChange) => Promise<void>;
 export declare const clearClassification: (accountSetting: Pick<IAccountSettingRepository, "delete">, accountConfigId: string) => Promise<void>;
 export {};

package/dist/src/handlers/classification-settings.js

@@ -1,8 +1,16 @@
 import { parseAccountSettingValue } from "@remit/data-ports/account-settings";
 import { CLASSIFICATION_PRESETS, CLASSIFICATION_SETTING_NAMES, classificationUsageName, utcDateOf, } from "@remit/data-ports/classification-presets";
+import { ClassificationSource, readResolvedClassification, } from "@remit/data-ports/classification-resolver";
 import { AccountSettingName } from "@remit/domain-enums";
 import { ensureClassificationLabels, } from "@remit/mailbox-service";
 import { serializeEncryptedPayload, } from "@remit/secrets-service";
+export const readKnownClassification = async (deps, accountConfigId) => {
+    const resolved = await readResolvedClassification(deps, accountConfigId);
+    if (resolved.state === "UnknownPreset") {
+        throw new Error(`Stored classification preset is unknown: ${resolved.presetId}`);
+    }
+    return resolved;
+};
 const refuse = (code, message) => ({
     ok: false,
     error: { code, message },
@@ -40,21 +48,31 @@ const apiKeyFor = (preset, requested, keptKey) => {
     }
     return refuse("ClassificationApiKeyRequired", `classificationApiKey is required for ${preset.label}`);
 };
-export const decideClassificationProvider = (input, stored) => {
-    const saved = stored.state === "Configured" ? stored : undefined;
-    const presetId = input.classificationPresetId ?? saved?.presetId;
+const presetIdOf = (known) => {
+    if (known.state === "NotConfigured")
+        return undefined;
+    if (known.state === "Unrunnable")
+        return known.presetId;
+    return known.presetId.value;
+};
+export const decideClassificationProvider = (input, known) => {
+    const presetId = input.classificationPresetId ?? presetIdOf(known);
     if (presetId === undefined) {
         return refuse("ClassificationNotConfigured", "classificationPresetId is required: no classification provider is saved");
     }
     const preset = CLASSIFICATION_PRESETS[presetId];
-    const kept = saved?.presetId === presetId ? saved : undefined;
-    const baseUrl = baseUrlFor(preset, (input.classificationBaseUrl ?? kept?.baseUrl ?? "").trim());
+    const kept = known.state === "Configured" && known.presetId.value === presetId
+        ? known
+        : undefined;
+    const baseUrl = baseUrlFor(preset, (input.classificationBaseUrl ?? kept?.baseUrl.value ?? "").trim());
     if (!baseUrl.ok)
         return baseUrl;
-    const apiKey = apiKeyFor(preset, (input.classificationApiKey ?? "").trim(), kept?.apiKeyCiphertext);
+    const apiKey = apiKeyFor(preset, (input.classificationApiKey ?? "").trim(), kept?.apiKey.source === ClassificationSource.Saved
+        ? kept.apiKey.ciphertext
+        : undefined);
     if (!apiKey.ok)
         return apiKey;
-    const model = (input.classificationModel ?? kept?.model ?? "").trim();
+    const model = (input.classificationModel ?? kept?.model.value ?? "").trim();
     return {
         ok: true,
         value: {
@@ -65,11 +83,20 @@ export const decideClassificationProvider = (input, stored) => {
         },
     };
 };
-export const publicClassification = (stored, usage) => {
-    if (stored.state === "NotConfigured")
-        return stored;
-    const { apiKeyCiphertext: _ciphertext, ...configured } = stored;
-    return { ...configured, usage };
+export const publicClassification = (resolved, usage) => {
+    if (resolved.state === "NotConfigured")
+        return resolved;
+    return {
+        state: "Configured",
+        presetId: resolved.presetId.value,
+        model: resolved.model.value,
+        baseUrl: resolved.baseUrl.value,
+        apiKeySaved: resolved.apiKey.source === ClassificationSource.Saved,
+        enabled: resolved.enabled.value,
+        dailyLimit: resolved.dailyLimit.value,
+        savedAt: resolved.classifiesAfter,
+        usage,
+    };
 };
 const CLASSIFICATION_INPUT_TOKENS_PER_CALL = 1_500;
 const nextUtcMidnight = (epochMs) => {
@@ -109,15 +136,15 @@ export const readClassificationUsage = async (accountSetting, accountConfigId, a
     });
 };
 export const classificationPresetsResponse = () => Object.values(CLASSIFICATION_PRESETS);
-export const decideClassificationChange = (input, stored) => {
+export const decideClassificationChange = (input, known) => {
     let provider;
     if (savesClassificationProvider(input)) {
-        const decided = decideClassificationProvider(input, stored);
+        const decided = decideClassificationProvider(input, known);
         if (!decided.ok)
             return decided;
         provider = decided.value;
     }
-    const configured = provider !== undefined || stored.state === "Configured";
+    const configured = provider !== undefined || known.state === "Configured";
     if (input.classificationEnabled === true && !configured) {
         return refuse("ClassificationNotConfigured", "classificationEnabled needs a saved classification provider");
     }

package/dist/src/handlers/classification-test.d.ts

@@ -1,10 +1,9 @@
 import type { ClassificationTestFailed, ClassificationTestInput, ClassificationTestPassed } from "@remit/api-openapi-types";
-import type { IAccountSettingRepository } from "@remit/data-ports";
+import type { ClassificationResolverDeps } from "@remit/data-ports/classification-resolver";
 import { type ClassifierLogger } from "@remit/mailbox-service/classifier";
 import { type SecretsService } from "@remit/secrets-service";
 import type { UserSettingsOutcome } from "./user-settings.js";
-export interface ClassificationTestDeps {
-    accountSetting: Pick<IAccountSettingRepository, "getMany">;
+export interface ClassificationTestDeps extends ClassificationResolverDeps {
     secrets: Pick<SecretsService, "decrypt">;
     logger: ClassifierLogger;
 }

package/dist/src/handlers/classification-test.js

@@ -1,8 +1,7 @@
-import { readStoredClassification } from "@remit/data-ports/classification-presets";
 import { ClassificationFailureKind as FailureKind, ClassificationField as Field, } from "@remit/domain-enums";
 import { CLASSIFIER_LABELS, CLASSIFIER_SAMPLE_MESSAGE, classifyWithProvider, } from "@remit/mailbox-service/classifier";
 import { deserializeEncryptedPayload, } from "@remit/secrets-service";
-import { decideClassificationProvider, } from "./classification-settings.js";
+import { decideClassificationProvider, readKnownClassification, } from "./classification-settings.js";
 const REACH_FIX = "Check the endpoint runs and the Remit server can reach it";
 const DEFAULT_MODEL_FIX = "Use the preset's default model";
 const FAILURE_HELP = {
@@ -59,7 +58,7 @@ export const testClassificationProvider = async (deps, accountConfigId, input) =
         classificationModel: input.model,
         classificationBaseUrl: input.baseUrl,
         classificationApiKey: input.apiKey,
-    }, await readStoredClassification(deps.accountSetting, accountConfigId));
+    }, await readKnownClassification(deps, accountConfigId));
     if (!decided.ok)
         return decided;
     const save = decided.value;

package/dist/src/handlers/thread.d.ts

@@ -52,6 +52,8 @@ type ThreadSearch = {
     starred?: boolean;
     attachments?: boolean;
     category?: MessageCategory[];
+    senderTrust?: SenderTrust[];
+    dkimMismatch?: boolean;
 };
 /**
  * Minimal client surface `executeThreadSearch` needs. Declared structurally
@@ -84,21 +86,12 @@ export type ThreadSearchParams = {
     limit?: number;
 };
 /**
- * Run a per-mailbox thread search: select the index/window read, optionally
- * count, and resolve off-row criteria by enriching+filtering the window. The
- * `results` toggle omits `items` (count-only) and `count` adds the match count.
+ * Run a per-mailbox thread search: select the index/window read and optionally
+ * count. The `results` toggle omits `items` (count-only) and `count` adds the
+ * match count.
  *
  * `count` names the whole match, never the page: a page size bounds the rows a
  * response carries and has no bearing on how many messages match (#509).
- *
- * An off-row criterion is the one shape that has no such number. `senderTrust`
- * and `dkimMismatch` are resolved by enriching a window, so counting them means
- * enriching every candidate row in the mailbox. `count` is therefore absent
- * (#305) — a page's post-filter length labelled `count` is a page length
- * presented as a total, which is the defect the field exists to avoid. Absence
- * is the same answer the response already gives for a count nobody asked for,
- * so no caller needs a second shape to read it. A count-only request under an
- * off-row criterion therefore reads nothing at all.
  */
 export declare const executeThreadSearch: (client: ThreadSearchClient, accountConfigId: string, mailboxId: string, params: ThreadSearchParams) => Promise<ThreadSearchResponse>;
 /**

package/dist/src/handlers/thread.js

@@ -1,7 +1,6 @@
 import { NotFoundError } from "@remit/data-ports/errors";
 import { isValidMessageId } from "@remit/data-ports/id";
 import { enrichThreadRows, } from "../derive/enrichThreadRows.js";
-import { filterByOffRowCriteria, hasOffRowCriteria, } from "../derive/filterThreadCriteria.js";
 const DEFAULT_THREADS_PAGE_SIZE = 50;
 // Project to fields used by ListThreadsResponse — keep in sync with handler mapping.
 // Includes ThreadMessage table key fields (accountConfigId, threadMessageId) and
@@ -63,21 +62,12 @@ const toArray = (value) => {
     return Array.isArray(value) ? value : [value];
 };
 /**
- * Run a per-mailbox thread search: select the index/window read, optionally
- * count, and resolve off-row criteria by enriching+filtering the window. The
- * `results` toggle omits `items` (count-only) and `count` adds the match count.
+ * Run a per-mailbox thread search: select the index/window read and optionally
+ * count. The `results` toggle omits `items` (count-only) and `count` adds the
+ * match count.
  *
  * `count` names the whole match, never the page: a page size bounds the rows a
  * response carries and has no bearing on how many messages match (#509).
- *
- * An off-row criterion is the one shape that has no such number. `senderTrust`
- * and `dkimMismatch` are resolved by enriching a window, so counting them means
- * enriching every candidate row in the mailbox. `count` is therefore absent
- * (#305) — a page's post-filter length labelled `count` is a page length
- * presented as a total, which is the defect the field exists to avoid. Absence
- * is the same answer the response already gives for a count nobody asked for,
- * so no caller needs a second shape to read it. A count-only request under an
- * off-row criterion therefore reads nothing at all.
  */
 export const executeThreadSearch = async (client, accountConfigId, mailboxId, params) => {
     const search = {
@@ -88,8 +78,6 @@ export const executeThreadSearch = async (client, accountConfigId, mailboxId, pa
         starred: params.starred,
         attachments: params.attachments,
         category: params.category,
-    };
-    const offRow = {
         senderTrust: params.senderTrust,
         dkimMismatch: params.dkimMismatch,
     };
@@ -100,16 +88,6 @@ export const executeThreadSearch = async (client, accountConfigId, mailboxId, pa
         order: params.order,
         limit: params.limit,
     });
-    if (hasOffRowCriteria(offRow)) {
-        if (!wantResults)
-            return {};
-        const window = await client.threadMessage.searchByMailboxWindow(accountConfigId, mailboxId, search, options);
-        const enriched = await enrichThreadRows(window.items, client, accountConfigId);
-        return {
-            items: filterByOffRowCriteria(enriched, offRow),
-            continuationToken: window.continuationToken,
-        };
-    }
     const response = {};
     if (wantResults) {
         const window = await client.threadMessage.searchByMailboxWindow(accountConfigId, mailboxId, search, options);

package/dist/src/handlers/user-settings.d.ts

@@ -1,10 +1,13 @@
 import type { UpdateUserSettingsInput, UserSettingsResponse } from "@remit/api-openapi-types";
-import type { IAccountRepository, IAccountSettingRepository } from "@remit/data-ports";
+import type { IAccountConfigRepository, IAccountRepository, IAccountSettingRepository } from "@remit/data-ports";
+import type { ClassificationDeploymentDefault } from "@remit/data-ports/classification-presets";
 import type { ClassificationLabelDeps } from "@remit/mailbox-service";
 import type { SecretsService } from "@remit/secrets-service";
 import type { OperationHandler, UserSettingsOperationIds } from "../types.js";
 export interface UserSettingsDeps {
     accountSetting: Pick<IAccountSettingRepository, "get" | "getMany" | "upsert" | "delete">;
+    accountConfig: Pick<IAccountConfigRepository, "get">;
+    classificationDefault: ClassificationDeploymentDefault;
     accounts: Pick<IAccountRepository, "listAllByAccountConfig">;
     secrets: Pick<SecretsService, "encrypt">;
     label: ClassificationLabelDeps;

package/dist/src/handlers/user-settings.js

@@ -1,10 +1,9 @@
 import { invitationSenderInEffect, sendingAccountFor, } from "@remit/calendar-service";
 import { parseAccountSettingValue } from "@remit/data-ports/account-settings";
-import { readStoredClassification } from "@remit/data-ports/classification-presets";
 import { AccountSettingName } from "@remit/domain-enums";
 import { logger } from "@remit/logger";
 import { badRequest } from "./calendar.js";
-import { classificationPresetsResponse, clearClassification, decideClassificationChange, publicClassification, readClassificationUsage, writeClassificationChange, } from "./classification-settings.js";
+import { classificationPresetsResponse, clearClassification, decideClassificationChange, publicClassification, readClassificationUsage, readKnownClassification, writeClassificationChange, } from "./classification-settings.js";
 import { testClassificationProvider } from "./classification-test.js";
 /** The account the reader chose to send invitations from, if they chose one. */
 export const chosenInvitationSender = async (accountSetting, accountConfigId) => {
@@ -17,19 +16,25 @@ export const readUserSettings = async (deps, accountConfigId) => {
     const chosen = await chosenInvitationSender(deps.accountSetting, accountConfigId);
     const accounts = await deps.accounts.listAllByAccountConfig(accountConfigId);
     const inEffect = invitationSenderInEffect(accounts, chosen);
-    const stored = await readStoredClassification(deps.accountSetting, accountConfigId);
-    const usage = stored.state === "Configured"
-        ? await readClassificationUsage(deps.accountSetting, accountConfigId, accounts.map((account) => account.accountId), stored, Date.now())
+    const resolved = await readKnownClassification(deps, accountConfigId);
+    if (resolved.state === "Unrunnable") {
+        throw new Error(`Classification provider ${resolved.presetId} cannot run: ${resolved.reason}`);
+    }
+    const usage = resolved.state === "Configured"
+        ? await readClassificationUsage(deps.accountSetting, accountConfigId, accounts.map((account) => account.accountId), {
+            presetId: resolved.presetId.value,
+            dailyLimit: resolved.dailyLimit.value,
+        }, Date.now())
         : [];
     return {
         ...(inEffect && { defaultInvitationSenderAccountId: inEffect.accountId }),
         defaultInvitationSenderChosen: inEffect !== undefined && inEffect.accountId === chosen,
         classificationPresets: classificationPresetsResponse(),
-        classification: publicClassification(stored, usage),
+        classification: publicClassification(resolved, usage),
     };
 };
 export const updateUserSettingsFor = async (deps, accountConfigId, input) => {
-    const classification = decideClassificationChange(input, await readStoredClassification(deps.accountSetting, accountConfigId));
+    const classification = decideClassificationChange(input, await readKnownClassification(deps, accountConfigId));
     if (!classification.ok)
         return classification;
     const sender = input.defaultInvitationSenderAccountId;
@@ -54,6 +59,8 @@ export const updateUserSettingsFor = async (deps, accountConfigId, input) => {
 };
 const depsOf = (ctx) => ({
     accountSetting: ctx.client.accountSetting,
+    accountConfig: ctx.client.accountConfig,
+    classificationDefault: ctx.client.classificationDefault,
     accounts: ctx.client.account,
     secrets: ctx.client.secrets,
     label: ctx.client.label,
@@ -79,6 +86,8 @@ export const UserSettingsOperations = {
     UserSettingsOperations_testClassificationProvider: async (context, ctx) => {
         const tested = await testClassificationProvider({
             accountSetting: ctx.client.accountSetting,
+            accountConfig: ctx.client.accountConfig,
+            classificationDefault: ctx.client.classificationDefault,
             secrets: ctx.client.secrets,
             logger,
         }, ctx.identity.accountConfigId, context.request.requestBody);

package/dist/src/service/create-remit-client.js

@@ -161,6 +161,8 @@ export const composeReadPathServices = (core, queues, sync) => ({
         accountService: core.account,
     }, {
         accountSetting: core.accountSetting,
+        accountConfig: core.accountConfig,
+        classificationDefault: core.classificationDefault,
         secrets: core.secrets,
         labelService: core.label,
         messageLabelService: core.messageLabel,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/backend",
-	"version": "2.7.0",
+	"version": "2.8.0",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",

package/dist/src/derive/filterThreadCriteria.d.ts

@@ -1,23 +0,0 @@
-import type { SenderTrust, ThreadMessageResponse } from "@remit/api-openapi-types";
-/**
- * Off-row search criteria — fields that live on the underlying Message/Address,
- * not on the ThreadMessage row. They are resolved by enriching the windowed
- * rows (see enrichThreadRows) and filtering in app code, because no index or
- * FilterExpression can serve them.
- *
- * `senderTrust` derives from AddressItem.flags and `dkimMismatch` from
- * MessageItem.authenticity. `category` is not one of these: it is denormalized
- * onto the ThreadMessage row and filtered in SQL, inside the window.
- */
-export interface OffRowCriteria {
-    senderTrust?: SenderTrust[];
-    dkimMismatch?: boolean;
-}
-export declare const hasOffRowCriteria: (criteria: OffRowCriteria) => boolean;
-/**
- * Filter enriched rows by the off-row criteria. Each active criterion is an
- * any-of set (AND across criteria, OR within a set). A row with no
- * `authenticity` signal never matches a `dkimMismatch` filter (absence means no
- * signal, not a verdict).
- */
-export declare const filterByOffRowCriteria: (rows: ThreadMessageResponse[], criteria: OffRowCriteria) => ThreadMessageResponse[];

package/dist/src/derive/filterThreadCriteria.js

@@ -1,24 +0,0 @@
-export const hasOffRowCriteria = (criteria) => Boolean(criteria.senderTrust?.length) || criteria.dkimMismatch !== undefined;
-/**
- * Filter enriched rows by the off-row criteria. Each active criterion is an
- * any-of set (AND across criteria, OR within a set). A row with no
- * `authenticity` signal never matches a `dkimMismatch` filter (absence means no
- * signal, not a verdict).
- */
-export const filterByOffRowCriteria = (rows, criteria) => {
-    if (!hasOffRowCriteria(criteria))
-        return rows;
-    const trustSet = criteria.senderTrust?.length
-        ? new Set(criteria.senderTrust)
-        : undefined;
-    const { dkimMismatch } = criteria;
-    return rows.filter((row) => {
-        if (trustSet && !trustSet.has(row.senderTrust))
-            return false;
-        if (dkimMismatch !== undefined &&
-            row.authenticity?.dkimMismatch !== dkimMismatch) {
-            return false;
-        }
-        return true;
-    });
-};