@remit/backend 2.7.1 → 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/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.1",
+	"version": "2.8.0",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",