Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

fix(web): persist plugin setting switches when they are toggled

tianma-if04771f204d97
diff --git a/apps/web/src/components/plugins/PluginSettingsSection.tsx b/apps/web/src/components/plugins/PluginSettingsSection.tsx
index b209bc57..5aba1184 100644
--- a/apps/web/src/components/plugins/PluginSettingsSection.tsx
+++ b/apps/web/src/components/plugins/PluginSettingsSection.tsx
@@ -1,8 +1,13 @@
-import { useEffect, useId, useState } from "react";
+import { useEffect, useId, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { ChevronRight } from "lucide-react";
import type { PluginManifest, PluginSettingField, PluginSettingValue } from "@edgeever/plugin-api";
import type { EdgeEverPluginHost } from "@/lib/plugins/plugin-host";
+import {
+ createPluginSettingWriteQueue,
+ pluginSettingLoadSignature,
+ revertBooleanSettingAfterFailedWrite,
+} from "./plugin-settings-commit";
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { Input } from "@/components/ui/input";
@@ -163,6 +168,10 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
const formId = useId();
const fields = manifest.settings?.fields ?? [];
const fieldGroups = groupPluginSettingFields(fields);
+ const fieldLoadSignature = pluginSettingLoadSignature(fields);
+ const fieldsRef = useRef(fields);
+ fieldsRef.current = fields;
+ const settingWrites = useRef(createPluginSettingWriteQueue()).current;
const [values, setValues] = useState<Record<string, PluginSettingValue | "">>({});
const [configuredSecrets, setConfiguredSecrets] = useState<Record<string, boolean>>({});
const [loading, setLoading] = useState(fields.length > 0);
@@ -174,11 +183,12 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
useEffect(() => {
let active = true;
- setLoading(fields.length > 0);
+ const currentFields = fieldsRef.current;
+ setLoading(currentFields.length > 0);
setMessage(null);
setError(null);
setLoadError(null);
- void Promise.all(fields.map(async (field) => {
+ void Promise.all(currentFields.map(async (field) => {
if (field.type === "secret") return { key: field.key, value: "" as const, configured: await host.hasSettingValue(manifest.id, field.key) };
return { key: field.key, value: await host.getSettingValue(manifest.id, field.key) ?? "", configured: false };
})).then((loaded) => {
@@ -192,7 +202,7 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
setLoading(false);
});
return () => { active = false; };
- }, [host, manifest.id, manifest.version, manifest.settings, loadAttempt]);
+ }, [host, manifest.id, manifest.version, fieldLoadSignature, loadAttempt]);
if (fields.length === 0) return null;
@@ -201,6 +211,20 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
setError(null);
};
+ const persistBooleanSetting = (key: string, value: boolean) => {
+ void settingWrites.enqueue(key, async () => {
+ try {
+ await host.setSettingValue(manifest.id, key, value);
+ } catch (writeError) {
+ setValues((current) => ({
+ ...current,
+ [key]: revertBooleanSettingAfterFailedWrite(current[key] ?? "", value),
+ }));
+ setError(writeError instanceof Error ? writeError.message : String(writeError));
+ }
+ });
+ };
+
const save = async () => {
setSaving(true);
setMessage(null);
@@ -223,6 +247,10 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
await host.removeSettingValue(manifest.id, field.key);
continue;
}
+ if (typeof value === "boolean") {
+ await settingWrites.enqueue(field.key, () => host.setSettingValue(manifest.id, field.key, value));
+ continue;
+ }
await host.setSettingValue(manifest.id, field.key, value);
if (field.type === "secret") {
setConfiguredSecrets((current) => ({ ...current, [field.key]: true }));
@@ -267,6 +295,9 @@ export const PluginSettingsSection = ({ host, manifest }: { host: EdgeEverPlugin
onChange={(nextValue) => {
clearFeedback();
setValues((current) => ({ ...current, [field.key]: nextValue }));
+ if (field.type === "boolean" && typeof nextValue === "boolean") {
+ persistBooleanSetting(field.key, nextValue);
+ }
}}
/>
);
diff --git a/apps/web/src/components/plugins/plugin-settings-commit.test.mjs b/apps/web/src/components/plugins/plugin-settings-commit.test.mjs
new file mode 100644
index 00000000..23f0220e
--- /dev/null
+++ b/apps/web/src/components/plugins/plugin-settings-commit.test.mjs
@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import {
+ createPluginSettingWriteQueue,
+ pluginSettingLoadSignature,
+ revertBooleanSettingAfterFailedWrite,
+} from "./plugin-settings-commit.ts";
+
+describe("plugin setting commits", () => {
+ test("stores an idle switch write before the click handler continues", () => {
+ const queue = createPluginSettingWriteQueue();
+ const stored = [];
+ queue.enqueue("digest.auto-enabled", () => {
+ stored.push(true);
+ return Promise.resolve();
+ });
+ expect(stored).toEqual([true]);
+ });
+
+ test("keeps an older switch write from landing after a newer one", async () => {
+ const queue = createPluginSettingWriteQueue();
+ const stored = [];
+ let releaseOlder = () => {};
+ const older = queue.enqueue("digest.auto-enabled", () => new Promise((resolve) => {
+ releaseOlder = () => {
+ stored.push(false);
+ resolve();
+ };
+ }));
+ const newer = queue.enqueue("digest.auto-enabled", async () => {
+ stored.push(true);
+ });
+
+ expect(stored).toEqual([]);
+ releaseOlder();
+ await older;
+ await newer;
+ expect(stored).toEqual([false, true]);
+ });
+
+ test("a failed write does not block the next switch position", async () => {
+ const queue = createPluginSettingWriteQueue();
+ const stored = [];
+ await expect(queue.enqueue("digest.auto-enabled", async () => {
+ throw new Error("storage unavailable");
+ })).rejects.toThrow("storage unavailable");
+ await queue.enqueue("digest.auto-enabled", async () => {
+ stored.push(true);
+ });
+ expect(stored).toEqual([true]);
+ });
+
+ test("a failed write only snaps the switch back when the user has not moved it", () => {
+ expect(revertBooleanSettingAfterFailedWrite(true, true)).toBe(false);
+ expect(revertBooleanSettingAfterFailedWrite(false, false)).toBe(true);
+ expect(revertBooleanSettingAfterFailedWrite(false, true)).toBe(false);
+ expect(revertBooleanSettingAfterFailedWrite(true, false)).toBe(true);
+ });
+
+ test("reloads stored values when fields change, not when the manifest object is copied", () => {
+ const fields = [
+ { key: "digest.auto-enabled", type: "boolean", default: false },
+ { key: "digest.generation-time", type: "select", default: "08:00" },
+ ];
+ expect(pluginSettingLoadSignature(fields)).toBe(pluginSettingLoadSignature(fields.map((field) => ({ ...field }))));
+ expect(pluginSettingLoadSignature(fields)).not.toBe(pluginSettingLoadSignature([
+ ...fields,
+ { key: "digest.window-hours", type: "number", default: 24 },
+ ]));
+ });
+});
diff --git a/apps/web/src/components/plugins/plugin-settings-commit.ts b/apps/web/src/components/plugins/plugin-settings-commit.ts
new file mode 100644
index 00000000..1dfe2989
--- /dev/null
+++ b/apps/web/src/components/plugins/plugin-settings-commit.ts
@@ -0,0 +1,35 @@
+import type { PluginSettingValue } from "@edgeever/plugin-api";
+
+export const pluginSettingLoadSignature = (fields: readonly { key: string; type: string; default?: unknown }[]) =>
+ fields.map((field) => `${field.key}\0${field.type}\0${JSON.stringify(field.default ?? null)}`).join("\n");
+
+export const revertBooleanSettingAfterFailedWrite = (
+ current: PluginSettingValue | "",
+ attempted: boolean,
+): PluginSettingValue | "" => (current === attempted ? !attempted : current);
+
+export const createPluginSettingWriteQueue = () => {
+ const tails = new Map<string, Promise<void>>();
+
+ return {
+ enqueue(key: string, write: () => Promise<void>): Promise<void> {
+ const previous = tails.get(key);
+ let run: Promise<void>;
+ if (previous) {
+ run = previous.then(write, write);
+ } else {
+ try {
+ run = Promise.resolve(write());
+ } catch (error) {
+ run = Promise.reject(error);
+ }
+ }
+ const tail = run.then(() => undefined, () => undefined);
+ tails.set(key, tail);
+ void tail.finally(() => {
+ if (tails.get(key) === tail) tails.delete(key);
+ });
+ return run;
+ },
+ };
+};