@remit/backend 0.0.143 → 0.0.145

package/dist/src/handlers/account-overrides.d.ts

@@ -0,0 +1,53 @@
+import type { MutedFlag } from "@remit/api-openapi-types";
+import type { AccountSettingItem, IAccountSettingRepository } from "@remit/data-ports";
+export interface AccountOverrides {
+    displayName?: string;
+    muted?: MutedFlag;
+    composeLanguages?: string[];
+}
+export interface MailboxOverrides {
+    displayNameOverride?: string;
+    muted?: MutedFlag;
+}
+export declare const groupAccountOverrides: (settings: AccountSettingItem[]) => Map<string, AccountOverrides>;
+/**
+ * Resolve one account's display-name/mute overrides by reading just its two
+ * composite rows. Used by the account create/update handlers.
+ */
+export declare const loadAccountOverrides: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string) => Promise<AccountOverrides>;
+export declare const upsertAccountDisplayName: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string, displayName: string) => Promise<unknown>;
+/**
+ * Replace the account's compose-language list. An empty array deletes the row:
+ * the client falls back to the browser's own languages when the setting is
+ * absent, and an account that offers no language at all has nothing to pick
+ * from (RFC 032: absence is "unset").
+ */
+export declare const writeAccountComposeLanguages: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string, languages: string[]) => Promise<unknown>;
+/**
+ * Set or clear the account mute flag. A `MutedFlag` upserts the row; `null`
+ * deletes it (RFC 032: absence is "unset"). Mirrors the address-flag
+ * null→remove, object→set semantics.
+ */
+export declare const writeAccountMuted: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string, muted: MutedFlag | null) => Promise<unknown>;
+export declare const groupMailboxOverrides: (settings: AccountSettingItem[]) => Map<string, MailboxOverrides>;
+/**
+ * Load every mailbox's overrides for an account configuration in one query,
+ * grouped by mailboxId. listMailboxes uses this once to avoid an N+1 per mailbox.
+ */
+export declare const loadMailboxOverridesForConfig: (accountSetting: IAccountSettingRepository, accountConfigId: string) => Promise<Map<string, MailboxOverrides>>;
+/**
+ * Resolve one mailbox's overrides by reading just its two composite rows.
+ * Used by getMailbox and the rename/PATCH handler.
+ */
+export declare const loadMailboxOverrides: (accountSetting: IAccountSettingRepository, accountConfigId: string, mailboxId: string) => Promise<MailboxOverrides>;
+/**
+ * Apply a mailbox PATCH's override changes (displayNameOverride / muted) to
+ * AccountSetting rows. For each field: `null` deletes the row, a value upserts
+ * it, `undefined`/absent is a no-op — the same semantics the entity-backed
+ * version used. The canonical role a folder fills is written separately via
+ * `writeFolderRoleAppointment` (RFC 032 exclusive-folder-appointment, #976).
+ */
+export declare const applyMailboxOverrideChanges: (accountSetting: Pick<IAccountSettingRepository, "upsert" | "delete">, accountConfigId: string, mailboxId: string, changes: {
+    displayNameOverride?: string | null;
+    muted?: MutedFlag | null;
+}) => Promise<void>;

package/dist/src/handlers/account-overrides.js

@@ -0,0 +1,233 @@
+import { baseSettingName, composeSettingName, SETTING_NAME_SEPARATOR, } from "@remit/data-ports/account-settings";
+/**
+ * RFC 032 Tier 1: the per-account display name and mute flag, and the
+ * per-mailbox display-name override and mute flag, live in AccountSetting
+ * rows — not on the Account/Mailbox entities. They are stored as composite-named
+ * rows keyed by the target id (`AccountDisplayName#<accountId>`,
+ * `MailboxMuted#<mailboxId>`, …), so one `listByAccountConfig` query yields every
+ * target's overrides; readers group them by the `#<targetId>` suffix. This mirrors
+ * the signature helper (`account-signature.ts`). The per-folder role override
+ * this module used to carry is superseded by the per-account role map — see
+ * `folder-role-appointments.ts` (RFC 032 exclusive-folder-appointment, #976).
+ */
+const ACCOUNT_OVERRIDE_NAMES = {
+    displayName: "AccountDisplayName",
+    muted: "AccountMuted",
+    composeLanguages: "AccountComposeLanguages",
+};
+const MAILBOX_OVERRIDE_NAMES = {
+    displayName: "MailboxDisplayName",
+    muted: "MailboxMuted",
+};
+const stringValueOf = (item) => {
+    const { value } = item;
+    if (value.kind === "String")
+        return value.value;
+    return undefined;
+};
+const mutedValueOf = (item) => {
+    const { value } = item;
+    if (value.kind === "MutedFlag")
+        return value.value;
+    return undefined;
+};
+const stringListValueOf = (item) => {
+    const { value } = item;
+    if (value.kind === "StringList")
+        return value.value;
+    return undefined;
+};
+const targetIdOf = (name) => {
+    const idx = name.indexOf(SETTING_NAME_SEPARATOR);
+    if (idx === -1)
+        return undefined;
+    return name.slice(idx + SETTING_NAME_SEPARATOR.length) || undefined;
+};
+// ============================================
+// Account overrides (displayName + muted)
+// ============================================
+export const groupAccountOverrides = (settings) => {
+    const byAccount = new Map();
+    for (const setting of settings) {
+        const accountId = targetIdOf(setting.name);
+        if (!accountId)
+            continue;
+        const base = baseSettingName(setting.name);
+        if (base === ACCOUNT_OVERRIDE_NAMES.displayName) {
+            const displayName = stringValueOf(setting);
+            if (displayName === undefined)
+                continue;
+            const current = byAccount.get(accountId) ?? {};
+            current.displayName = displayName;
+            byAccount.set(accountId, current);
+            continue;
+        }
+        if (base === ACCOUNT_OVERRIDE_NAMES.muted) {
+            const muted = mutedValueOf(setting);
+            if (muted === undefined)
+                continue;
+            const current = byAccount.get(accountId) ?? {};
+            current.muted = muted;
+            byAccount.set(accountId, current);
+            continue;
+        }
+        if (base === ACCOUNT_OVERRIDE_NAMES.composeLanguages) {
+            const composeLanguages = stringListValueOf(setting);
+            if (composeLanguages === undefined)
+                continue;
+            const current = byAccount.get(accountId) ?? {};
+            current.composeLanguages = composeLanguages;
+            byAccount.set(accountId, current);
+        }
+    }
+    return byAccount;
+};
+/**
+ * Resolve one account's display-name/mute overrides by reading just its two
+ * composite rows. Used by the account create/update handlers.
+ */
+export const loadAccountOverrides = async (accountSetting, accountConfigId, accountId) => {
+    const [displayName, muted, composeLanguages] = await Promise.all([
+        accountSetting.get(accountConfigId, composeSettingName(ACCOUNT_OVERRIDE_NAMES.displayName, accountId)),
+        accountSetting.get(accountConfigId, composeSettingName(ACCOUNT_OVERRIDE_NAMES.muted, accountId)),
+        accountSetting.get(accountConfigId, composeSettingName(ACCOUNT_OVERRIDE_NAMES.composeLanguages, accountId)),
+    ]);
+    const overrides = {};
+    const displayNameValue = displayName ? stringValueOf(displayName) : undefined;
+    const mutedValue = muted ? mutedValueOf(muted) : undefined;
+    const languagesValue = composeLanguages
+        ? stringListValueOf(composeLanguages)
+        : undefined;
+    if (displayNameValue !== undefined)
+        overrides.displayName = displayNameValue;
+    if (mutedValue !== undefined)
+        overrides.muted = mutedValue;
+    if (languagesValue !== undefined)
+        overrides.composeLanguages = languagesValue;
+    return overrides;
+};
+export const upsertAccountDisplayName = (accountSetting, accountConfigId, accountId, displayName) => accountSetting.upsert({
+    accountConfigId,
+    name: composeSettingName(ACCOUNT_OVERRIDE_NAMES.displayName, accountId),
+    value: { kind: "String", value: displayName },
+});
+/**
+ * Replace the account's compose-language list. An empty array deletes the row:
+ * the client falls back to the browser's own languages when the setting is
+ * absent, and an account that offers no language at all has nothing to pick
+ * from (RFC 032: absence is "unset").
+ */
+export const writeAccountComposeLanguages = (accountSetting, accountConfigId, accountId, languages) => {
+    const name = composeSettingName(ACCOUNT_OVERRIDE_NAMES.composeLanguages, accountId);
+    if (languages.length === 0) {
+        return accountSetting.delete(accountConfigId, name);
+    }
+    return accountSetting.upsert({
+        accountConfigId,
+        name,
+        value: { kind: "StringList", value: languages },
+    });
+};
+/**
+ * Set or clear the account mute flag. A `MutedFlag` upserts the row; `null`
+ * deletes it (RFC 032: absence is "unset"). Mirrors the address-flag
+ * null→remove, object→set semantics.
+ */
+export const writeAccountMuted = (accountSetting, accountConfigId, accountId, muted) => {
+    const name = composeSettingName(ACCOUNT_OVERRIDE_NAMES.muted, accountId);
+    if (muted === null) {
+        return accountSetting.delete(accountConfigId, name);
+    }
+    return accountSetting.upsert({
+        accountConfigId,
+        name,
+        value: { kind: "MutedFlag", value: muted },
+    });
+};
+// ============================================
+// Mailbox overrides (displayNameOverride + muted)
+// ============================================
+export const groupMailboxOverrides = (settings) => {
+    const byMailbox = new Map();
+    for (const setting of settings) {
+        const mailboxId = targetIdOf(setting.name);
+        if (!mailboxId)
+            continue;
+        const base = baseSettingName(setting.name);
+        if (base === MAILBOX_OVERRIDE_NAMES.displayName) {
+            const displayName = stringValueOf(setting);
+            if (displayName === undefined)
+                continue;
+            const current = byMailbox.get(mailboxId) ?? {};
+            current.displayNameOverride = displayName;
+            byMailbox.set(mailboxId, current);
+            continue;
+        }
+        if (base === MAILBOX_OVERRIDE_NAMES.muted) {
+            const muted = mutedValueOf(setting);
+            if (muted === undefined)
+                continue;
+            const current = byMailbox.get(mailboxId) ?? {};
+            current.muted = muted;
+            byMailbox.set(mailboxId, current);
+        }
+    }
+    return byMailbox;
+};
+/**
+ * Load every mailbox's overrides for an account configuration in one query,
+ * grouped by mailboxId. listMailboxes uses this once to avoid an N+1 per mailbox.
+ */
+export const loadMailboxOverridesForConfig = async (accountSetting, accountConfigId) => {
+    const settings = await accountSetting.listByAccountConfig(accountConfigId);
+    return groupMailboxOverrides(settings);
+};
+/**
+ * Resolve one mailbox's overrides by reading just its two composite rows.
+ * Used by getMailbox and the rename/PATCH handler.
+ */
+export const loadMailboxOverrides = async (accountSetting, accountConfigId, mailboxId) => {
+    const [displayName, muted] = await Promise.all([
+        accountSetting.get(accountConfigId, composeSettingName(MAILBOX_OVERRIDE_NAMES.displayName, mailboxId)),
+        accountSetting.get(accountConfigId, composeSettingName(MAILBOX_OVERRIDE_NAMES.muted, mailboxId)),
+    ]);
+    const overrides = {};
+    const displayNameValue = displayName ? stringValueOf(displayName) : undefined;
+    const mutedValue = muted ? mutedValueOf(muted) : undefined;
+    if (displayNameValue !== undefined)
+        overrides.displayNameOverride = displayNameValue;
+    if (mutedValue !== undefined)
+        overrides.muted = mutedValue;
+    return overrides;
+};
+/**
+ * Apply a mailbox PATCH's override changes (displayNameOverride / muted) to
+ * AccountSetting rows. For each field: `null` deletes the row, a value upserts
+ * it, `undefined`/absent is a no-op — the same semantics the entity-backed
+ * version used. The canonical role a folder fills is written separately via
+ * `writeFolderRoleAppointment` (RFC 032 exclusive-folder-appointment, #976).
+ */
+export const applyMailboxOverrideChanges = async (accountSetting, accountConfigId, mailboxId, changes) => {
+    const writes = [];
+    if (changes.displayNameOverride !== undefined) {
+        const name = composeSettingName(MAILBOX_OVERRIDE_NAMES.displayName, mailboxId);
+        writes.push(changes.displayNameOverride === null
+            ? accountSetting.delete(accountConfigId, name)
+            : accountSetting.upsert({
+                accountConfigId,
+                name,
+                value: { kind: "String", value: changes.displayNameOverride },
+            }));
+    }
+    if (changes.muted !== undefined) {
+        const name = composeSettingName(MAILBOX_OVERRIDE_NAMES.muted, mailboxId);
+        writes.push(changes.muted === null
+            ? accountSetting.delete(accountConfigId, name)
+            : accountSetting.upsert({
+                accountConfigId,
+                name,
+                value: { kind: "MutedFlag", value: changes.muted },
+            }));
+    }
+    await Promise.all(writes);
+};

package/dist/src/handlers/account-signature.d.ts

@@ -0,0 +1,28 @@
+import type { AccountSettingItem, IAccountSettingRepository } from "@remit/data-ports";
+export interface AccountSignature {
+    plainText?: string;
+    html?: string;
+}
+/**
+ * Build a per-account signature lookup from the whole settings set of one
+ * account configuration. Signatures are stored as composite-named rows
+ * (`AccountSignaturePlainText#<accountId>` / `AccountSignatureHtml#<accountId>`),
+ * so one `listByAccountConfig` query yields every account's signature; this
+ * groups them by the `#<accountId>` suffix.
+ */
+export declare const groupSignaturesByAccount: (settings: AccountSettingItem[]) => Map<string, AccountSignature>;
+/**
+ * Resolve the signature for a single account by reading just its two composite
+ * rows. Used by the account create/update handlers, which act on one account.
+ */
+export declare const loadSignatureForAccount: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string) => Promise<AccountSignature>;
+/**
+ * Idempotent upsert of an account's signature fields. Only writes the parts the
+ * caller supplied — an empty string is a valid stored value (it clears the
+ * displayed signature without removing the row), matching the prior PATCH
+ * semantics where setting `""` stored `""`.
+ */
+export declare const upsertAccountSignature: (accountSetting: IAccountSettingRepository, accountConfigId: string, accountId: string, signature: {
+    plainText?: string;
+    html?: string;
+}) => Promise<void>;

package/dist/src/handlers/account-signature.js

@@ -0,0 +1,85 @@
+import { baseSettingName, composeSettingName, SETTING_NAME_SEPARATOR, } from "@remit/data-ports/account-settings";
+const SIGNATURE_NAMES = {
+    plainText: "AccountSignaturePlainText",
+    html: "AccountSignatureHtml",
+};
+const stringValueOf = (item) => {
+    const { value } = item;
+    if (value.kind === "String")
+        return value.value;
+    return undefined;
+};
+const accountIdOf = (name) => {
+    const idx = name.indexOf(SETTING_NAME_SEPARATOR);
+    if (idx === -1)
+        return undefined;
+    return name.slice(idx + SETTING_NAME_SEPARATOR.length) || undefined;
+};
+/**
+ * Build a per-account signature lookup from the whole settings set of one
+ * account configuration. Signatures are stored as composite-named rows
+ * (`AccountSignaturePlainText#<accountId>` / `AccountSignatureHtml#<accountId>`),
+ * so one `listByAccountConfig` query yields every account's signature; this
+ * groups them by the `#<accountId>` suffix.
+ */
+export const groupSignaturesByAccount = (settings) => {
+    const byAccount = new Map();
+    for (const setting of settings) {
+        const accountId = accountIdOf(setting.name);
+        if (!accountId)
+            continue;
+        const base = baseSettingName(setting.name);
+        const text = stringValueOf(setting);
+        if (text === undefined)
+            continue;
+        const current = byAccount.get(accountId) ?? {};
+        if (base === SIGNATURE_NAMES.plainText)
+            current.plainText = text;
+        if (base === SIGNATURE_NAMES.html)
+            current.html = text;
+        byAccount.set(accountId, current);
+    }
+    return byAccount;
+};
+/**
+ * Resolve the signature for a single account by reading just its two composite
+ * rows. Used by the account create/update handlers, which act on one account.
+ */
+export const loadSignatureForAccount = async (accountSetting, accountConfigId, accountId) => {
+    const [plain, html] = await Promise.all([
+        accountSetting.get(accountConfigId, composeSettingName(SIGNATURE_NAMES.plainText, accountId)),
+        accountSetting.get(accountConfigId, composeSettingName(SIGNATURE_NAMES.html, accountId)),
+    ]);
+    const signature = {};
+    const plainText = plain ? stringValueOf(plain) : undefined;
+    const htmlText = html ? stringValueOf(html) : undefined;
+    if (plainText !== undefined)
+        signature.plainText = plainText;
+    if (htmlText !== undefined)
+        signature.html = htmlText;
+    return signature;
+};
+/**
+ * Idempotent upsert of an account's signature fields. Only writes the parts the
+ * caller supplied — an empty string is a valid stored value (it clears the
+ * displayed signature without removing the row), matching the prior PATCH
+ * semantics where setting `""` stored `""`.
+ */
+export const upsertAccountSignature = async (accountSetting, accountConfigId, accountId, signature) => {
+    const writes = [];
+    if (signature.plainText !== undefined) {
+        writes.push(accountSetting.upsert({
+            accountConfigId,
+            name: composeSettingName(SIGNATURE_NAMES.plainText, accountId),
+            value: { kind: "String", value: signature.plainText },
+        }));
+    }
+    if (signature.html !== undefined) {
+        writes.push(accountSetting.upsert({
+            accountConfigId,
+            name: composeSettingName(SIGNATURE_NAMES.html, accountId),
+            value: { kind: "String", value: signature.html },
+        }));
+    }
+    await Promise.all(writes);
+};

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

@@ -0,0 +1,7 @@
+import type { RemitClient } from "../service/data-client.js";
+import type { AccountDetailOperationIds, AccountOperationIds, OperationHandler } from "../types.js";
+import { assertNotOAuthCreate, assertPasswordProvided, toAccountResponse } from "./account-guards.js";
+export { assertNotOAuthCreate, assertPasswordProvided, toAccountResponse };
+export declare const triggerAccountSyncSafe: (client: RemitClient<"sync">, accountId: string) => Promise<void>;
+export declare const AccountOperations: Record<AccountOperationIds, OperationHandler<AccountOperationIds, "sync" | "accountFanout">>;
+export declare const AccountDetailOperations: Record<AccountDetailOperationIds, OperationHandler<AccountDetailOperationIds, "sync" | "accountFanout">>;