@remit/backend 2.7.1 → 3.0.0

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

@@ -1,8 +1,9 @@
-import type { ClassificationConfigured, ClassificationNotConfigured, ClassificationPreset, 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 { ClassificationConfigured, ClassificationNotConfigured, ClassificationPreset, ClassificationPresetId, ClassificationUnrunnable, ClassificationUsage, UpdateUserSettingsInput } from "@remit/api-openapi-types";
+import type { IAccountSettingRepository, UpsertAccountSettingInput } from "@remit/data-ports";
+import { CLASSIFICATION_SETTING_NAMES } from "@remit/data-ports/classification-presets";
+import { type ClassificationResolverDeps, type ClassificationResolverInput, type ResolvedClassification, type SavedClassificationApiKey } from "@remit/data-ports/classification-resolver";
 import { type ClassificationLabelDeps } from "@remit/mailbox-service";
-import { type SecretsService, type SerializedEncryptedPayload } from "@remit/secrets-service";
+import { type SecretsService } from "@remit/secrets-service";
 import type { UserSettingsOutcome } from "./user-settings.js";
 export type ClassificationSettingsDeps = {
     accountSetting: Pick<IAccountSettingRepository, "getMany" | "upsert" | "delete">;
@@ -16,32 +17,37 @@ type Decision<T> = {
     ok: true;
     value: T;
 } | Refusal;
-type ApiKeyChange = {
-    action: "Keep";
-    ciphertext: SerializedEncryptedPayload;
-} | {
-    action: "Replace";
-    apiKey: string;
+type ClassificationSettingName = (typeof CLASSIFICATION_SETTING_NAMES)[number];
+type SettingWrite = {
+    action: "Upsert";
+    name: ClassificationSettingName;
+    value: UpsertAccountSettingInput["value"];
 } | {
     action: "Delete";
+    name: ClassificationSettingName;
+};
+type PlannedWrite = SettingWrite | {
+    action: "Encrypt";
+    apiKey: string;
 };
-export interface ClassificationProviderSave {
-    preset: ClassificationPreset;
-    model: string;
-    baseUrl: string;
-    apiKey: ApiKeyChange;
+export type PlannedApiKey = Partial<SavedClassificationApiKey>;
+export interface ClassificationChange {
+    writes: PlannedWrite[];
+    resolved: KnownClassification<PlannedApiKey>;
+    ensuresLabels: boolean;
 }
-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 ClassificationInput = Pick<UpdateUserSettingsInput, "classificationPresetId" | "classificationModel" | "classificationBaseUrl" | "classificationApiKey" | "classificationEnabled" | "classificationDailyLimit">;
+export type KnownClassification<Saved = SavedClassificationApiKey> = Exclude<ResolvedClassification<Saved>, {
+    state: "UnknownPreset";
+}>;
+export declare const readKnownClassification: (deps: ClassificationResolverDeps, accountConfigId: string) => Promise<KnownClassification>;
+export declare const decideClassificationChange: (current: ClassificationResolverInput, input: ClassificationInput) => Decision<ClassificationChange>;
+export declare const publicClassification: <Saved>(resolved: KnownClassification<Saved>, usage: ClassificationUsage[]) => ClassificationNotConfigured | ClassificationUnrunnable | 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 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 { AccountSettingName } from "@remit/domain-enums";
+import { readResolvedClassification, resolveClassification, resolveClassificationWith, savedClassificationApiKey, } from "@remit/data-ports/classification-resolver";
+import { AccountSettingName, ClassificationValueSource as ValueSource, } from "@remit/domain-enums";
 import { ensureClassificationLabels, } from "@remit/mailbox-service";
 import { serializeEncryptedPayload, } from "@remit/secrets-service";
+const knownOf = (resolved) => {
+    if (resolved.state === "UnknownPreset") {
+        throw new Error(`Stored classification preset is unknown: ${resolved.presetId}`);
+    }
+    return resolved;
+};
+export const readKnownClassification = async (deps, accountConfigId) => knownOf(await readResolvedClassification(deps, accountConfigId));
 const refuse = (code, message) => ({
     ok: false,
     error: { code, message },
@@ -17,59 +25,169 @@ const savesClassificationProvider = (input) => input.classificationPresetId !==
     input.classificationModel !== undefined ||
     input.classificationBaseUrl !== undefined ||
     input.classificationApiKey !== undefined;
-const baseUrlFor = (preset, requested) => {
-    if (requested === "") {
-        if (preset.defaultBaseUrl === undefined) {
-            return refuse("InvalidClassificationBaseUrl", `classificationBaseUrl is required for ${preset.label}`);
-        }
-        return { ok: true, value: preset.defaultBaseUrl };
+const presetIdOf = (known) => {
+    if (known.state === "NotConfigured")
+        return undefined;
+    if (known.state === "Unrunnable")
+        return known.presetId;
+    return known.presetId.value;
+};
+const textWrite = (name, requested, switched) => {
+    const value = requested?.trim();
+    if (value === undefined)
+        return switched ? [{ action: "Delete", name }] : [];
+    if (value === "")
+        return [{ action: "Delete", name }];
+    return [{ action: "Upsert", name, value: { kind: "String", value } }];
+};
+const apiKeyWrite = (preset, requested, switched) => {
+    const name = AccountSettingName.ClassificationApiKey;
+    if (!preset.needsKey)
+        return [{ action: "Delete", name }];
+    if (requested !== "")
+        return [{ action: "Encrypt", apiKey: requested }];
+    return switched ? [{ action: "Delete", name }] : [];
+};
+const planProviderWrites = (input, known) => {
+    const current = presetIdOf(known);
+    const presetId = input.classificationPresetId ?? current;
+    if (presetId === undefined) {
+        return refuse("ClassificationNotConfigured", "classificationPresetId is required: no classification provider is saved or inherited");
     }
-    if (!isHttpUrl(requested)) {
+    const baseUrl = input.classificationBaseUrl?.trim();
+    if (baseUrl !== undefined && baseUrl !== "" && !isHttpUrl(baseUrl)) {
         return refuse("InvalidClassificationBaseUrl", "classificationBaseUrl must be an http or https URL");
     }
-    return { ok: true, value: requested };
+    const switched = presetId !== current;
+    return {
+        ok: true,
+        value: [
+            ...apiKeyWrite(CLASSIFICATION_PRESETS[presetId], (input.classificationApiKey ?? "").trim(), switched),
+            ...textWrite(AccountSettingName.ClassificationModel, input.classificationModel, switched),
+            ...textWrite(AccountSettingName.ClassificationBaseUrl, baseUrl, switched),
+            {
+                action: "Upsert",
+                name: AccountSettingName.ClassificationPresetId,
+                value: { kind: "String", value: presetId },
+            },
+        ],
+    };
 };
-const apiKeyFor = (preset, requested, keptKey) => {
-    if (!preset.needsKey)
-        return { ok: true, value: { action: "Delete" } };
-    if (requested !== "") {
-        return { ok: true, value: { action: "Replace", apiKey: requested } };
+const planWrites = (input, known) => {
+    const provider = savesClassificationProvider(input)
+        ? planProviderWrites(input, known)
+        : { ok: true, value: [] };
+    if (!provider.ok)
+        return provider;
+    const writes = [...provider.value];
+    if (input.classificationEnabled !== undefined) {
+        writes.push({
+            action: "Upsert",
+            name: AccountSettingName.ClassificationEnabled,
+            value: { kind: "Boolean", value: input.classificationEnabled },
+        });
     }
-    if (keptKey) {
-        return { ok: true, value: { action: "Keep", ciphertext: keptKey } };
+    if (input.classificationDailyLimit !== undefined) {
+        writes.push({
+            action: "Upsert",
+            name: AccountSettingName.ClassificationDailyLimit,
+            value: { kind: "Number", value: input.classificationDailyLimit },
+        });
     }
-    return refuse("ClassificationApiKeyRequired", `classificationApiKey is required for ${preset.label}`);
+    return { ok: true, value: writes };
 };
-export const decideClassificationProvider = (input, stored) => {
-    const saved = stored.state === "Configured" ? stored : undefined;
-    const presetId = input.classificationPresetId ?? saved?.presetId;
-    if (presetId === undefined) {
-        return refuse("ClassificationNotConfigured", "classificationPresetId is required: no classification provider is saved");
+const sealWrite = async (secrets, write) => {
+    if (write.action !== "Encrypt")
+        return write;
+    const ciphertext = serializeEncryptedPayload(await secrets.encrypt(write.apiKey));
+    return {
+        action: "Upsert",
+        name: AccountSettingName.ClassificationApiKey,
+        value: { kind: "Map", value: { ...ciphertext } },
+    };
+};
+const applyWrites = (rows, writes, now) => writes.reduce((applied, write) => {
+    if (write.action === "Encrypt")
+        return applied;
+    const kept = applied.filter((row) => row.name !== write.name);
+    if (write.action === "Delete")
+        return kept;
+    return [...kept, { name: write.name, value: write.value, updatedAt: now }];
+}, Array.from(rows));
+const plannedApiKeyOf = (rows, writes) => writes.some((write) => write.action === "Encrypt")
+    ? {}
+    : savedClassificationApiKey(rows);
+const refuseUnrunnable = (resolved) => {
+    const { label } = CLASSIFICATION_PRESETS[resolved.presetId];
+    if (resolved.reason === "NoBaseUrl") {
+        return refuse("InvalidClassificationBaseUrl", `classificationBaseUrl is required for ${label}`);
+    }
+    return refuse("ClassificationApiKeyRequired", `classificationApiKey is required for ${label}: no key is saved, and the deployment's key only applies to its own preset and base URL`);
+};
+export const decideClassificationChange = (current, input) => {
+    const planned = planWrites(input, knownOf(resolveClassification(current)));
+    if (!planned.ok)
+        return planned;
+    const writes = planned.value;
+    const rows = applyWrites(current.rows, writes, Date.now());
+    const resolved = knownOf(resolveClassificationWith({ ...current, rows }, plannedApiKeyOf(rows, writes)));
+    if (resolved.state === "NotConfigured") {
+        if (input.classificationEnabled === true) {
+            return refuse("ClassificationNotConfigured", "classificationEnabled needs a saved or inherited classification provider");
+        }
+        if (input.classificationDailyLimit !== undefined) {
+            return refuse("ClassificationNotConfigured", "classificationDailyLimit needs a saved or inherited classification provider");
+        }
+        return {
+            ok: true,
+            value: {
+                writes: [],
+                resolved,
+                ensuresLabels: false,
+            },
+        };
+    }
+    if (resolved.state === "Unrunnable" &&
+        (savesClassificationProvider(input) || input.classificationEnabled === true)) {
+        return refuseUnrunnable(resolved);
     }
-    const preset = CLASSIFICATION_PRESETS[presetId];
-    const kept = saved?.presetId === presetId ? saved : undefined;
-    const baseUrl = baseUrlFor(preset, (input.classificationBaseUrl ?? kept?.baseUrl ?? "").trim());
-    if (!baseUrl.ok)
-        return baseUrl;
-    const apiKey = apiKeyFor(preset, (input.classificationApiKey ?? "").trim(), kept?.apiKeyCiphertext);
-    if (!apiKey.ok)
-        return apiKey;
-    const model = (input.classificationModel ?? kept?.model ?? "").trim();
     return {
         ok: true,
         value: {
-            preset,
-            model: model === "" ? preset.defaultModel : model,
-            baseUrl: baseUrl.value,
-            apiKey: apiKey.value,
+            writes,
+            resolved,
+            ensuresLabels: input.classificationEnabled === true,
         },
     };
 };
-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;
+    if (resolved.state === "Unrunnable") {
+        return {
+            state: "Unrunnable",
+            presetId: resolved.presetId,
+            reason: resolved.reason,
+        };
+    }
+    return {
+        state: "Configured",
+        presetId: resolved.presetId.value,
+        model: resolved.model.value,
+        baseUrl: resolved.baseUrl.value,
+        apiKeySaved: resolved.apiKey.source !== ValueSource.Default,
+        enabled: resolved.enabled.value,
+        dailyLimit: resolved.dailyLimit.value,
+        sources: {
+            presetId: resolved.presetId.source,
+            model: resolved.model.source,
+            baseUrl: resolved.baseUrl.source,
+            apiKey: resolved.apiKey.source,
+            enabled: resolved.enabled.source,
+            dailyLimit: resolved.dailyLimit.source,
+        },
+        usage,
+    };
 };
 const CLASSIFICATION_INPUT_TOKENS_PER_CALL = 1_500;
 const nextUtcMidnight = (epochMs) => {
@@ -109,80 +227,23 @@ export const readClassificationUsage = async (accountSetting, accountConfigId, a
     });
 };
 export const classificationPresetsResponse = () => Object.values(CLASSIFICATION_PRESETS);
-export const decideClassificationChange = (input, stored) => {
-    let provider;
-    if (savesClassificationProvider(input)) {
-        const decided = decideClassificationProvider(input, stored);
-        if (!decided.ok)
-            return decided;
-        provider = decided.value;
-    }
-    const configured = provider !== undefined || stored.state === "Configured";
-    if (input.classificationEnabled === true && !configured) {
-        return refuse("ClassificationNotConfigured", "classificationEnabled needs a saved classification provider");
-    }
-    if (input.classificationDailyLimit !== undefined && !configured) {
-        return refuse("ClassificationNotConfigured", "classificationDailyLimit needs a saved classification provider");
-    }
-    return {
-        ok: true,
-        value: {
-            provider,
-            enabled: configured ? input.classificationEnabled : undefined,
-            dailyLimit: input.classificationDailyLimit,
-        },
-    };
-};
-const writeProvider = async (deps, accountConfigId, save) => {
-    const { accountSetting } = deps;
-    if (save.apiKey.action === "Delete") {
-        await accountSetting.delete(accountConfigId, AccountSettingName.ClassificationApiKey);
-    }
-    if (save.apiKey.action === "Replace") {
-        const ciphertext = serializeEncryptedPayload(await deps.secrets.encrypt(save.apiKey.apiKey));
-        await accountSetting.upsert({
-            accountConfigId,
-            name: AccountSettingName.ClassificationApiKey,
-            value: { kind: "Map", value: { ...ciphertext } },
-        });
-    }
-    await accountSetting.upsert({
-        accountConfigId,
-        name: AccountSettingName.ClassificationModel,
-        value: { kind: "String", value: save.model },
-    });
-    await accountSetting.upsert({
-        accountConfigId,
-        name: AccountSettingName.ClassificationBaseUrl,
-        value: { kind: "String", value: save.baseUrl },
-    });
-    await accountSetting.upsert({
-        accountConfigId,
-        name: AccountSettingName.ClassificationPresetId,
-        value: { kind: "String", value: save.preset.presetId },
-    });
-};
 export const writeClassificationChange = async (deps, accountConfigId, change) => {
-    if (change.provider) {
-        await writeProvider(deps, accountConfigId, change.provider);
-    }
-    if (change.enabled !== undefined) {
-        await deps.accountSetting.upsert({
-            accountConfigId,
-            name: AccountSettingName.ClassificationEnabled,
-            value: { kind: "Boolean", value: change.enabled },
-        });
+    for (const planned of change.writes) {
+        const write = await sealWrite(deps.secrets, planned);
+        if (write.action === "Delete") {
+            await deps.accountSetting.delete(accountConfigId, write.name);
+        }
+        else {
+            await deps.accountSetting.upsert({
+                accountConfigId,
+                name: write.name,
+                value: write.value,
+            });
+        }
     }
-    if (change.enabled === true) {
+    if (change.ensuresLabels) {
         await ensureClassificationLabels(deps.label, accountConfigId);
     }
-    if (change.dailyLimit !== undefined) {
-        await deps.accountSetting.upsert({
-            accountConfigId,
-            name: AccountSettingName.ClassificationDailyLimit,
-            value: { kind: "Number", value: change.dailyLimit },
-        });
-    }
 };
 export const clearClassification = async (accountSetting, accountConfigId) => {
     for (const name of CLASSIFICATION_SETTING_NAMES) {

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,9 @@
-import { readStoredClassification } from "@remit/data-ports/classification-presets";
-import { ClassificationFailureKind as FailureKind, ClassificationField as Field, } from "@remit/domain-enums";
+import { CLASSIFICATION_PRESETS } from "@remit/data-ports/classification-presets";
+import { readClassificationInput, } from "@remit/data-ports/classification-resolver";
+import { ClassificationFailureKind as FailureKind, ClassificationField as Field, ClassificationValueSource as ValueSource, } 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 { decideClassificationChange, } 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 = {
@@ -25,12 +26,17 @@ const FAILURE_HELP = {
     [FailureKind.TimedOut]: { field: Field.BaseUrl, fix: REACH_FIX },
     [FailureKind.Unparseable]: { field: Field.Model, fix: DEFAULT_MODEL_FIX },
 };
-const apiKeyOf = (deps, save) => {
-    if (save.apiKey.action === "Replace") {
-        return Promise.resolve(save.apiKey.apiKey);
+const apiKeyOf = (deps, entered, apiKey) => {
+    if (entered !== "")
+        return Promise.resolve(entered);
+    if (apiKey.source === ValueSource.Saved) {
+        if (apiKey.ciphertext === undefined) {
+            throw new Error("A saved classification key resolved without ciphertext");
+        }
+        return deps.secrets.decrypt(deserializeEncryptedPayload(apiKey.ciphertext));
     }
-    if (save.apiKey.action === "Keep") {
-        return deps.secrets.decrypt(deserializeEncryptedPayload(save.apiKey.ciphertext));
+    if (apiKey.source === ValueSource.Deployment) {
+        return Promise.resolve(apiKey.apiKey);
     }
     return Promise.resolve("");
 };
@@ -54,21 +60,24 @@ const answerOf = (result) => {
     };
 };
 export const testClassificationProvider = async (deps, accountConfigId, input) => {
-    const decided = decideClassificationProvider({
+    const decided = decideClassificationChange(await readClassificationInput(deps, accountConfigId), {
         classificationPresetId: input.presetId,
         classificationModel: input.model,
         classificationBaseUrl: input.baseUrl,
         classificationApiKey: input.apiKey,
-    }, await readStoredClassification(deps.accountSetting, accountConfigId));
+    });
     if (!decided.ok)
         return decided;
-    const save = decided.value;
+    const { resolved } = decided.value;
+    if (resolved.state !== "Configured") {
+        throw new Error(`A tested classification form resolved to ${resolved.state}`);
+    }
     const result = await classifyWithProvider({
         provider: {
-            adapterShape: save.preset.adapterShape,
-            baseUrl: save.baseUrl,
-            model: save.model,
-            apiKey: await apiKeyOf(deps, save),
+            adapterShape: CLASSIFICATION_PRESETS[resolved.presetId.value].adapterShape,
+            baseUrl: resolved.baseUrl.value,
+            model: resolved.model.value,
+            apiKey: await apiKeyOf(deps, input.apiKey.trim(), resolved.apiKey),
         },
         labels: CLASSIFIER_LABELS,
         message: CLASSIFIER_SAMPLE_MESSAGE,

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,10 @@
 import { invitationSenderInEffect, sendingAccountFor, } from "@remit/calendar-service";
 import { parseAccountSettingValue } from "@remit/data-ports/account-settings";
-import { readStoredClassification } from "@remit/data-ports/classification-presets";
+import { readClassificationInput } from "@remit/data-ports/classification-resolver";
 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 +17,22 @@ 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);
+    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(await readClassificationInput(deps, accountConfigId), input);
     if (!classification.ok)
         return classification;
     const sender = input.defaultInvitationSenderAccountId;
@@ -54,6 +57,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 +84,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": "3.0.0",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",