@remit/web-client 0.0.76 → 0.0.77

package/src/components/settings/settings-filter.stories.tsx

@@ -1,5 +1,5 @@
 import type { RemitImapFilterResponse } from "@remit/api-http-client/types.gen.ts";
-import { BottomSheet, type FolderOption } from "@remit/ui";
+import { BottomSheet, type FolderOption, type LabelOption } from "@remit/ui";
 import type { Meta, StoryObj } from "@storybook/react-vite";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import type { ReactNode } from "react";
@@ -24,6 +24,11 @@ const FOLDERS: FolderOption[] = [
 	{ id: "mbx-travel", label: "Travel" },
 ];
 
+const LABELS: LabelOption[] = [
+	{ id: "lbl-receipts", name: "Receipts", color: "Blue" },
+	{ id: "lbl-travel", name: "Travel", color: "Green" },
+];
+
 const makeFilter = (
 	overrides: Partial<RemitImapFilterResponse> = {},
 ): RemitImapFilterResponse => ({
@@ -104,6 +109,7 @@ export const EditStandingRule: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter()}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -119,6 +125,7 @@ export const EditAnchoredRule: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter({ hasAnchor: true, name: "GitHub" })}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -138,6 +145,7 @@ export const EditUntilADate: Story = {
 					expiresAt: "2027-09-01T23:59:59+00:00",
 				})}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -157,6 +165,7 @@ export const DegradedAnchor: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter({ hasAnchor: true, name: "Newsletters" })}
 				folders={FOLDERS}
+				labels={LABELS}
 				semanticUnavailable
 				onClose={() => undefined}
 			/>

package/src/hooks/useApplyLabel.ts

@@ -0,0 +1,68 @@
+import { messageBulkOperationsUpdateMessageLabelsMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type {
+	RemitImapLabelAction,
+	RemitImapThreadMessageResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
+import { formatErrorDetail } from "@/components/ui/error-banners";
+import { resolveMailboxesForMessages } from "@/hooks/useMarkAsRead";
+import {
+	invalidateThreadListQueries,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
+
+/**
+ * Apply or remove a label on a "just these" selection (issue #26, RFC 034
+ * recap). No optimistic patch: a label is metadata on the row, not something
+ * that removes it from the current view, so settling on the server response
+ * and invalidating is enough — unlike a move or delete, which the row leaves
+ * immediately.
+ */
+export const useApplyLabel = (options: {
+	mailboxId: string;
+	accountId?: string;
+	/** The threads the selection may span, for resolving which mailbox lists to invalidate. */
+	messages?: RemitImapThreadMessageResponse[];
+}) => {
+	const { mailboxId, messages } = options;
+	const queryClient = useQueryClient();
+	const { pushError } = useErrorBanners();
+
+	const { mutate, isPending } = useMutation({
+		...messageBulkOperationsUpdateMessageLabelsMutation(),
+		onError: (error, variables) => {
+			pushError({
+				title:
+					variables.body.action === "Remove"
+						? "Couldn't remove label"
+						: "Couldn't apply label",
+				detail: formatErrorDetail(error),
+				error,
+			});
+		},
+		onSettled: (_data, _error, variables) => {
+			invalidateThreadListQueries(
+				queryClient,
+				threadListCacheKeys(
+					resolveMailboxesForMessages(
+						variables.body.messageIds ?? [],
+						messages ?? [],
+						mailboxId,
+					),
+				),
+			);
+		},
+	});
+
+	const applyLabel = useCallback(
+		(messageIds: string[], labelId: string, action: RemitImapLabelAction) => {
+			if (messageIds.length === 0) return;
+			mutate({ body: { messageIds, labelId, action } });
+		},
+		[mutate],
+	);
+
+	return { applyLabel, isPending };
+};

package/src/hooks/useLabels.ts

@@ -0,0 +1,124 @@
+import {
+	labelDetailOperationsDeleteLabelMutation,
+	labelDetailOperationsUpdateLabelMutation,
+	labelOperationsCreateLabelMutation,
+	labelOperationsListLabelsOptions,
+	labelOperationsListLabelsQueryKey,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type {
+	RemitImapLabelColor,
+	RemitImapUpdateLabelInput,
+} from "@remit/api-http-client/types.gen.ts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+/**
+ * The query key the label list reads and every mutation invalidates on
+ * success — the same contract `buildFilterListKey` pins for filters, so the
+ * settings list and the rule editor's label picker never go stale after a
+ * label is created, renamed, recolored, or deleted (issue #26).
+ */
+export const buildLabelListKey = (accountId: string) =>
+	labelOperationsListLabelsQueryKey({ path: { accountId } });
+
+/** List the account's labels. */
+export const useLabelList = (accountId: string | undefined) => {
+	const query = useQuery({
+		...labelOperationsListLabelsOptions({
+			path: { accountId: accountId ?? "" },
+		}),
+		enabled: !!accountId,
+	});
+
+	return {
+		labels: query.data?.items ?? [],
+		isPending: query.isPending,
+		isError: query.isError,
+		error: query.error,
+		refetch: query.refetch,
+	};
+};
+
+export const useCreateLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelOperationsCreateLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutateAsync } = mutation;
+
+	const createLabel = useCallback(
+		(name: string, color: RemitImapLabelColor = "Default") => {
+			if (!accountId) return Promise.reject(new Error("No account"));
+			return mutateAsync({ path: { accountId }, body: { name, color } });
+		},
+		[accountId, mutateAsync],
+	);
+
+	return {
+		createLabel,
+		isPending: mutation.isPending,
+		isError: mutation.isError,
+		error: mutation.error,
+		reset: mutation.reset,
+	};
+};
+
+export const useUpdateLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelDetailOperationsUpdateLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutate } = mutation;
+
+	const updateLabel = useCallback(
+		(labelId: string, input: RemitImapUpdateLabelInput) => {
+			if (!accountId) return;
+			mutate({ path: { accountId, labelId }, body: input });
+		},
+		[accountId, mutate],
+	);
+
+	return {
+		updateLabel,
+		isPending: mutation.isPending,
+		updatingLabelId: mutation.isPending
+			? mutation.variables?.path.labelId
+			: undefined,
+	};
+};
+
+export const useDeleteLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelDetailOperationsDeleteLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutate } = mutation;
+
+	const deleteLabel = useCallback(
+		(labelId: string) => {
+			if (!accountId) return;
+			mutate({ path: { accountId, labelId } });
+		},
+		[accountId, mutate],
+	);
+
+	return {
+		deleteLabel,
+		isPending: mutation.isPending,
+		deletingLabelId: mutation.isPending
+			? mutation.variables?.path.labelId
+			: undefined,
+	};
+};

package/src/hooks/useRuleEditorState.ts

@@ -28,6 +28,7 @@ export interface RuleEditorState {
 		onRemoveWiden: () => void;
 		onChangeMatchOperator: (matchOperator: MatchOperator) => void;
 		onChangeMove: (mailboxId: string) => void;
+		onChangeLabel: (labelId: string) => void;
 		onChangeScope: (scope: RuleScope) => void;
 		onChangeName: (name: string) => void;
 		onChangeUntil: (until: string) => void;
@@ -141,6 +142,12 @@ export const useRuleEditorState = ({
 			moveMailboxId: mailboxId || undefined,
 		}));
 
+	const changeLabel = (labelId: string) =>
+		setRuleState((current) => ({
+			...current,
+			labelId: labelId || undefined,
+		}));
+
 	const changeScope = (scope: RuleScope) =>
 		setRuleState((current) => ({ ...current, scope }));
 
@@ -166,6 +173,7 @@ export const useRuleEditorState = ({
 			onRemoveWiden: removeWiden,
 			onChangeMatchOperator: changeMatchOperator,
 			onChangeMove: changeMove,
+			onChangeLabel: changeLabel,
 			onChangeScope: changeScope,
 			onChangeName: changeName,
 			onChangeUntil: changeUntil,

package/src/lib/organize/filter-edit-model.test.ts

@@ -58,6 +58,16 @@ describe("filterToRule", () => {
 		assert.equal(rule.moveMailboxId, undefined);
 	});
 
+	it("loads a label action (issue #26)", () => {
+		const rule = filterToRule(filter({ actionLabelId: "lbl-1" }));
+		assert.equal(rule.labelId, "lbl-1");
+	});
+
+	it("maps the None label sentinel to no action", () => {
+		const rule = filterToRule(filter({ actionLabelId: "None" }));
+		assert.equal(rule.labelId, undefined);
+	});
+
 	it("loads a Temporary filter as an until-a-date rule", () => {
 		const rule = filterToRule(
 			filter({ scope: "Temporary", expiresAt: "2027-03-04T23:59:59+00:00" }),
@@ -131,6 +141,13 @@ describe("ruleChangesPredicateOrAction", () => {
 			true,
 		);
 	});
+
+	it("is true when the label target changes (issue #26)", () => {
+		assert.equal(
+			ruleChangesPredicateOrAction({ ...base, labelId: "lbl-new" }, base),
+			true,
+		);
+	});
 });
 
 describe("ruleChangesScopeOrExpiry (reader #266)", () => {
@@ -212,6 +229,27 @@ describe("buildUpdateFilterInput", () => {
 		assert.equal(body.actionMailboxId, "None");
 	});
 
+	it("sends a chosen label target (issue #26)", () => {
+		const changed: FilterRule = {
+			...original,
+			labelId: "lbl-receipts",
+			matchOperator: "any",
+		};
+		const body = buildUpdateFilterInput(changed, original);
+		assert.equal(body.actionLabelId, "lbl-receipts");
+	});
+
+	it("drops a cleared label target to the None sentinel", () => {
+		const withLabel = { ...original, labelId: "lbl-receipts" };
+		const changed = {
+			...withLabel,
+			labelId: undefined,
+			matchOperator: "any" as const,
+		};
+		const body = buildUpdateFilterInput(changed, withLabel);
+		assert.equal(body.actionLabelId, "None");
+	});
+
 	it("is empty when nothing changed", () => {
 		assert.deepEqual(buildUpdateFilterInput(original, original), {});
 	});

package/src/lib/organize/filter-edit-model.ts

@@ -14,8 +14,9 @@ import { NO_ACTION } from "./organize-model";
  * cannot evaluate it (D4) — the rule then matches by its literal clauses only.
  *
  * The scope maps `Standing` → "standing" and `Temporary` → "until"; a persisted
- * filter is never the one-time "once" scope. `moveMailboxId` drops the `"None"`
- * sentinel to `undefined` so an empty folder select reads as "no move action".
+ * filter is never the one-time "once" scope. `moveMailboxId` and `labelId` both
+ * drop the `"None"` sentinel to `undefined` so an empty select reads as "no
+ * action" (issue #26).
  */
 export const filterToRule = (
 	filter: RemitImapFilterResponse,
@@ -34,6 +35,8 @@ export const filterToRule = (
 			: undefined,
 		moveMailboxId:
 			filter.actionMailboxId !== NO_ACTION ? filter.actionMailboxId : undefined,
+		labelId:
+			filter.actionLabelId !== NO_ACTION ? filter.actionLabelId : undefined,
 		scope: filter.scope === "Temporary" ? "until" : "standing",
 		until:
 			filter.scope === "Temporary"
@@ -65,15 +68,16 @@ const predicateActionKey = (rule: FilterRule): string =>
 		clauses: rule.clauses.map((clause) => [clause.field, clause.value]),
 		operator: rule.matchOperator,
 		move: rule.moveMailboxId ?? null,
+		label: rule.labelId ?? null,
 		widen: rule.widen ? (rule.widen.inactive ? "inactive" : "active") : "none",
 	});
 
 /**
  * Whether the edited rule changes the predicate or the action versus the one it
- * was loaded from — the clauses, the match operator, the move target, or the
- * widen's presence. A change here is what bumps `ruleChangedAt` and offers the
- * re-back-apply (RFC 034 Decision 3.2); the name is deliberately excluded, so a
- * cosmetic rename is not a rule change.
+ * was loaded from — the clauses, the match operator, the move target, the
+ * label target, or the widen's presence. A change here is what bumps
+ * `ruleChangedAt` and offers the re-back-apply (RFC 034 Decision 3.2); the name
+ * is deliberately excluded, so a cosmetic rename is not a rule change.
  */
 export const ruleChangesPredicateOrAction = (
 	rule: FilterRule,
@@ -104,10 +108,10 @@ export const ruleChangesScopeOrExpiry = (
  * The PATCH body for an edited filter. A cosmetic rename sends `{ name }` only,
  * so the server's `changesRuleAssertion` guard leaves `ruleChangedAt`
  * untouched (RFC 034 Decision 3.2). A predicate or action change sends the
- * operator, clauses, and move target; a scope or expiry change sends `scope`
- * and, for the `until` scope, `expiresAt` (reader #266) — either bumps
- * `ruleChangedAt`. The label action and the anchor are never in the editor's
- * gift, so they never enter the patch; the partial update preserves them.
+ * operator, clauses, move target, and label target; a scope or expiry change
+ * sends `scope` and, for the `until` scope, `expiresAt` (reader #266) —
+ * either bumps `ruleChangedAt`. The anchor is never in the editor's gift, so
+ * it never enters the patch; the partial update preserves it.
  */
 export const buildUpdateFilterInput = (
 	rule: FilterRule,
@@ -123,6 +127,7 @@ export const buildUpdateFilterInput = (
 			value: clause.value,
 		}));
 		body.actionMailboxId = rule.moveMailboxId ?? NO_ACTION;
+		body.actionLabelId = rule.labelId ?? NO_ACTION;
 	}
 	if (ruleChangesScopeOrExpiry(rule, original)) {
 		body.scope = rule.scope === "until" ? "Temporary" : "Standing";

package/src/lib/organize/label-delete-copy.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { deleteLabelConfirmCopy } from "./label-delete-copy";
+
+describe("deleteLabelConfirmCopy", () => {
+	it("names the label with no blast-radius note when no filter uses it", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 0);
+		assert.equal(copy.title, 'Delete the "Receipts" label?');
+		assert.equal(copy.description, undefined);
+	});
+
+	it("names exactly one filter in the singular", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 1);
+		assert.match(copy.description ?? "", /1 filter that applies it/);
+	});
+
+	it("names several filters in the plural", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 3);
+		assert.match(copy.description ?? "", /3 filters that apply it/);
+	});
+});

package/src/lib/organize/label-delete-copy.ts

@@ -0,0 +1,22 @@
+/**
+ * The delete-confirmation copy for a label (issue #26). Deleting a label
+ * cascades in both directions server-side — every filter whose action applies
+ * it is deleted outright, never left dangling — so the confirmation names the
+ * filter count up front rather than surprising the user after the fact. The
+ * API itself never blocks the delete; the confirmation is the only gate.
+ */
+export const deleteLabelConfirmCopy = (
+	labelName: string,
+	filterCount: number,
+): { title: string; description?: string } => {
+	if (filterCount === 0) {
+		return { title: `Delete the "${labelName}" label?` };
+	}
+	const filterNoun = filterCount === 1 ? "filter" : "filters";
+	return {
+		title: `Delete the "${labelName}" label?`,
+		description: `This also deletes ${filterCount} ${filterNoun} that ${
+			filterCount === 1 ? "applies" : "apply"
+		} it — they can't be recovered.`,
+	};
+};

package/src/lib/organize/organize-model.test.ts

@@ -15,13 +15,15 @@ const baseDraft = (overrides: Partial<OrganizeDraft> = {}): OrganizeDraft => ({
 });
 
 describe("hasCommittableAction", () => {
-	it("is false when no move target is chosen — labeling has no backend yet, so a keep-in-place draft has nothing to commit", () => {
+	it("is false when neither a move nor a label is chosen — a keep-in-place draft has nothing to commit", () => {
 		assert.equal(hasCommittableAction(baseDraft()), false);
 	});
 
-	it("is false for the None sentinel", () => {
+	it("is false for the None sentinel on both actions", () => {
 		assert.equal(
-			hasCommittableAction(baseDraft({ moveMailboxId: NO_ACTION })),
+			hasCommittableAction(
+				baseDraft({ moveMailboxId: NO_ACTION, labelId: NO_ACTION }),
+			),
 			false,
 		);
 	});
@@ -32,10 +34,23 @@ describe("hasCommittableAction", () => {
 			true,
 		);
 	});
+
+	it("is true once a real label is chosen, with no move target (issue #26)", () => {
+		assert.equal(hasCommittableAction(baseDraft({ labelId: "lbl-1" })), true);
+	});
+
+	it("is true when both a move and a label are chosen", () => {
+		assert.equal(
+			hasCommittableAction(
+				baseDraft({ moveMailboxId: "mbx-1", labelId: "lbl-1" }),
+			),
+			true,
+		);
+	});
 });
 
 describe("buildOrganizeInput", () => {
-	it("carries the anchor and defaults the action to None when no move is set", () => {
+	it("carries the anchor and defaults both actions to None when neither is set", () => {
 		const input = buildOrganizeInput(baseDraft({ anchorMessageId: "msg-1" }));
 		assert.equal(input.anchorMessageId, "msg-1");
 		assert.equal(input.actionMailboxId, NO_ACTION);
@@ -53,12 +68,16 @@ describe("buildOrganizeInput", () => {
 		assert.equal("anchorMessageId" in input, false);
 	});
 
-	it("labels the label action None even when a move target is set — label writes have no endpoint", () => {
+	it("carries the move and label actions independently (issue #26)", () => {
 		const input = buildOrganizeInput(
-			baseDraft({ anchorMessageId: "msg-1", moveMailboxId: "mbx-9" }),
+			baseDraft({
+				anchorMessageId: "msg-1",
+				moveMailboxId: "mbx-9",
+				labelId: "lbl-9",
+			}),
 		);
 		assert.equal(input.actionMailboxId, "mbx-9");
-		assert.equal(input.actionLabelId, NO_ACTION);
+		assert.equal(input.actionLabelId, "lbl-9");
 	});
 });
 
@@ -101,4 +120,13 @@ describe("buildCreateFilterInput", () => {
 		);
 		assert.equal("ttl" in input, false);
 	});
+
+	it("carries a label action (issue #26)", () => {
+		const input = buildCreateFilterInput(
+			baseDraft({ labelId: "lbl-1" }),
+			"standing",
+			"Receipts",
+		);
+		assert.equal(input.actionLabelId, "lbl-1");
+	});
 });

package/src/lib/organize/organize-model.ts

@@ -27,9 +27,10 @@ export const NO_ACTION = "None";
 
 /**
  * The user's in-progress organize decision, independent of which scope they
- * land on. The anchor and predicate drive the match set; `moveMailboxId` is the
- * one committable action today (labeling has no backend yet — see
- * `labelPlaceholder`).
+ * land on. The anchor and predicate drive the match set; `moveMailboxId` and
+ * `labelId` are the two committable actions (issue #26) — independent of each
+ * other, since a move is exclusive and a label is additive (RFC 034 Decision
+ * 3.1).
  */
 export interface OrganizeDraft {
 	/** Semantic anchor — "mail like this one". The first selected message. */
@@ -43,6 +44,11 @@ export interface OrganizeDraft {
 	 * Decision 3.1). Absent means "keep where they are": no move action.
 	 */
 	moveMailboxId?: string;
+	/**
+	 * Label applied to the match set — the additive action (RFC 034 Decision
+	 * 3.1, issue #26). Absent applies no label.
+	 */
+	labelId?: string;
 	/**
 	 * ISO 8601 date-time with zone offset. Present only for the `temporary`
 	 * scope; a plain picked date (RFC 034 non-goal: no event-based expiry).
@@ -51,14 +57,13 @@ export interface OrganizeDraft {
 }
 
 /**
- * Whether the draft carries a committable action. Labeling is not wired yet
- * (no Label API — RFC 030's `Label`/`MessageLabel` entities exist in TypeSpec
- * but have no CRUD endpoint), so a move target is the only real action. A draft
- * with no move target has nothing to commit; the caller disables the CTA and
- * says why (ux.md).
+ * Whether the draft carries a committable action — a move destination and/or
+ * a label (issue #26), either satisfies this. A draft with neither has
+ * nothing to commit; the caller disables the CTA and says why (ux.md).
  */
 export const hasCommittableAction = (draft: OrganizeDraft): boolean =>
-	draft.moveMailboxId !== undefined && draft.moveMailboxId !== NO_ACTION;
+	(draft.moveMailboxId !== undefined && draft.moveMailboxId !== NO_ACTION) ||
+	(draft.labelId !== undefined && draft.labelId !== NO_ACTION);
 
 /**
  * Whether the draft's predicate can be back-applied over the existing corpus. A
@@ -75,7 +80,7 @@ export const canBackApplyDraft = (draft: OrganizeDraft): boolean =>
  * Build the read-only preview / back-apply matcher input. The action fields do
  * not affect which messages match — the preview returns exactly the set a job
  * with the same predicate would apply to — so a widen preview can pass this
- * before the user has chosen a folder.
+ * before the user has chosen a folder or a label.
  */
 export const buildOrganizeInput = (
 	draft: OrganizeDraft,
@@ -83,7 +88,7 @@ export const buildOrganizeInput = (
 	...(draft.anchorMessageId ? { anchorMessageId: draft.anchorMessageId } : {}),
 	matchOperator: draft.matchOperator,
 	literalClauses: draft.literalClauses,
-	actionLabelId: NO_ACTION,
+	actionLabelId: draft.labelId ?? NO_ACTION,
 	actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
 });
 
@@ -107,7 +112,7 @@ export const buildCreateFilterInput = (
 			: {}),
 		matchOperator: draft.matchOperator,
 		literalClauses: draft.literalClauses,
-		actionLabelId: NO_ACTION,
+		actionLabelId: draft.labelId ?? NO_ACTION,
 		actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
 		...(draft.anchorMessageId
 			? { anchorMessageId: draft.anchorMessageId }

package/src/lib/organize/rule-model.test.ts

@@ -247,6 +247,11 @@ describe("the previewed set equals the applied set", () => {
 			"mbx-archive",
 		);
 	});
+
+	it("carries the label target into the draft (issue #26)", () => {
+		const labeled = { ...semanticRule, labelId: "lbl-receipts" };
+		assert.equal(ruleToDraft(labeled, "msg-1").labelId, "lbl-receipts");
+	});
 });
 
 describe("derivePreview", () => {

package/src/lib/organize/rule-model.ts

@@ -164,6 +164,7 @@ export const ruleToDraft = (
 		matchOperator: predicate.matchOperator,
 		literalClauses: predicate.literalClauses,
 		moveMailboxId: rule.moveMailboxId,
+		labelId: rule.labelId,
 		expiresAt:
 			rule.scope === "until"
 				? pickedDateToExpiresAt(rule.until ?? "")