@remit/backend 2.8.0 → 3.1.0

package/dist/src/api.js

@@ -33,6 +33,17 @@ class PrecompiledOpenAPIBackend extends OpenAPIBackend {
         }
         return initialized;
     }
+    ready() {
+        if (!this.initalized)
+            void this.init();
+        return this;
+    }
+    matchOperation(req) {
+        return this.ready().router.matchOperation(req);
+    }
+    validateRequest(req, operation) {
+        return this.ready().validator.validateRequest(req, operation);
+    }
 }
 const api = new PrecompiledOpenAPIBackend({
     definition: OpenAPISpec,
@@ -86,6 +97,5 @@ api.register("notImplemented", () => ({
     statusCode: 501,
     body: { code: defaultErrorCode(501), message: "Not implemented" },
 }));
-api.init();
 export { setLogger } from "@remit/logger";
 export { api };

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

@@ -1,8 +1,9 @@
-import type { ClassificationConfigured, ClassificationNotConfigured, ClassificationPreset, ClassificationPresetId, ClassificationUsage, UpdateUserSettingsInput } from "@remit/api-openapi-types";
-import type { IAccountSettingRepository } from "@remit/data-ports";
-import { type ClassificationResolverDeps, type ResolvedClassification, type ResolvedClassificationProvider } from "@remit/data-ports/classification-resolver";
+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,41 +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;
 };
-export interface ClassificationProviderSave {
-    preset: ClassificationPreset;
-    model: string;
-    baseUrl: string;
-    apiKey: ApiKeyChange;
+type PlannedWrite = SettingWrite | {
+    action: "Encrypt";
+    apiKey: string;
+};
+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 type KnownClassification = Exclude<ResolvedClassification, {
+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 decideClassificationProvider: (input: ClassificationInput, known: KnownClassification) => Decision<ClassificationProviderSave>;
-export declare const publicClassification: (resolved: ResolvedClassificationProvider | {
-    state: "NotConfigured";
-}, usage: ClassificationUsage[]) => ClassificationNotConfigured | ClassificationConfigured;
+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, 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,16 +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 { 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";
-export const readKnownClassification = async (deps, accountConfigId) => {
-    const resolved = await readResolvedClassification(deps, accountConfigId);
+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 },
@@ -25,29 +25,6 @@ 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 };
-    }
-    if (!isHttpUrl(requested)) {
-        return refuse("InvalidClassificationBaseUrl", "classificationBaseUrl must be an http or https URL");
-    }
-    return { ok: true, value: requested };
-};
-const apiKeyFor = (preset, requested, keptKey) => {
-    if (!preset.needsKey)
-        return { ok: true, value: { action: "Delete" } };
-    if (requested !== "") {
-        return { ok: true, value: { action: "Replace", apiKey: requested } };
-    }
-    if (keptKey) {
-        return { ok: true, value: { action: "Keep", ciphertext: keptKey } };
-    }
-    return refuse("ClassificationApiKeyRequired", `classificationApiKey is required for ${preset.label}`);
-};
 const presetIdOf = (known) => {
     if (known.state === "NotConfigured")
         return undefined;
@@ -55,46 +32,160 @@ const presetIdOf = (known) => {
         return known.presetId;
     return known.presetId.value;
 };
-export const decideClassificationProvider = (input, known) => {
-    const presetId = input.classificationPresetId ?? presetIdOf(known);
+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");
+        return refuse("ClassificationNotConfigured", "classificationPresetId is required: no classification provider is saved or inherited");
+    }
+    const baseUrl = input.classificationBaseUrl?.trim();
+    if (baseUrl !== undefined && baseUrl !== "" && !isHttpUrl(baseUrl)) {
+        return refuse("InvalidClassificationBaseUrl", "classificationBaseUrl must be an http or https URL");
+    }
+    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 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 (input.classificationDailyLimit !== undefined) {
+        writes.push({
+            action: "Upsert",
+            name: AccountSettingName.ClassificationDailyLimit,
+            value: { kind: "Number", value: input.classificationDailyLimit },
+        });
+    }
+    return { ok: true, value: writes };
+};
+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 = 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?.apiKey.source === ClassificationSource.Saved
-        ? kept.apiKey.ciphertext
-        : undefined);
-    if (!apiKey.ok)
-        return apiKey;
-    const model = (input.classificationModel ?? kept?.model.value ?? "").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 = (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 === ClassificationSource.Saved,
+        apiKeySaved: resolved.apiKey.source !== ValueSource.Default,
         enabled: resolved.enabled.value,
         dailyLimit: resolved.dailyLimit.value,
-        savedAt: resolved.classifiesAfter,
+        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,
     };
 };
@@ -136,80 +227,23 @@ export const readClassificationUsage = async (accountSetting, accountConfigId, a
     });
 };
 export const classificationPresetsResponse = () => Object.values(CLASSIFICATION_PRESETS);
-export const decideClassificationChange = (input, known) => {
-    let provider;
-    if (savesClassificationProvider(input)) {
-        const decided = decideClassificationProvider(input, known);
-        if (!decided.ok)
-            return decided;
-        provider = decided.value;
-    }
-    const configured = provider !== undefined || known.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,5 +1,5 @@
 import type { ClassificationTestFailed, ClassificationTestInput, ClassificationTestPassed } from "@remit/api-openapi-types";
-import type { ClassificationResolverDeps } from "@remit/data-ports/classification-resolver";
+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";

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

@@ -1,7 +1,9 @@
-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, readKnownClassification, } 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 = {
@@ -24,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("");
 };
@@ -53,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 readKnownClassification(deps, 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.js

@@ -1,5 +1,6 @@
 import { invitationSenderInEffect, sendingAccountFor, } from "@remit/calendar-service";
 import { parseAccountSettingValue } from "@remit/data-ports/account-settings";
+import { readClassificationInput } from "@remit/data-ports/classification-resolver";
 import { AccountSettingName } from "@remit/domain-enums";
 import { logger } from "@remit/logger";
 import { badRequest } from "./calendar.js";
@@ -17,9 +18,6 @@ export const readUserSettings = async (deps, accountConfigId) => {
     const accounts = await deps.accounts.listAllByAccountConfig(accountConfigId);
     const inEffect = invitationSenderInEffect(accounts, chosen);
     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,
@@ -34,7 +32,7 @@ export const readUserSettings = async (deps, accountConfigId) => {
     };
 };
 export const updateUserSettingsFor = async (deps, accountConfigId, input) => {
-    const classification = decideClassificationChange(input, await readKnownClassification(deps, accountConfigId));
+    const classification = decideClassificationChange(await readClassificationInput(deps, accountConfigId), input);
     if (!classification.ok)
         return classification;
     const sender = input.defaultInvitationSenderAccountId;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/backend",
-	"version": "2.8.0",
+	"version": "3.1.0",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",
@@ -71,6 +71,10 @@
 			"types": "./dist/src/config/msoauth.d.ts",
 			"default": "./dist/src/config/msoauth.js"
 		},
+		"./classification-default": {
+			"types": "./dist/src/config/classification-default.d.ts",
+			"default": "./dist/src/config/classification-default.js"
+		},
 		"./content-handler": {
 			"types": "./dist/dev-server/content-handler.d.ts",
 			"default": "./dist/dev-server/content-handler.js"