unikvs 0.0.2 → 0.0.4

package/dist/src/unikvs.js

@@ -0,0 +1,693 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UniKvs_con, _UniKvs_context, _UniKvs_destinations, _UniKvs_transformers;
+import { asyncmux, Asyncmux } from "asyncmux";
+import * as v from "valibot";
+import combineSignals from "./_combine-signals.js";
+import logger from "./_logger.js";
+import mergeContext from "./_merge-context.js";
+import toValueStream from "./_to-value-stream.js";
+import { parse } from "./_valibot.js";
+import { KeyNotFoundError, PluginOperationAggregateError, UniKvsIsNotOpenError, UniKvsIsOpenError, } from "./errors.js";
+import UniKvsConfig from "./unikvs-config.js";
+// -------------------------------------------------------------------------------------------------
+//
+// スキーマ
+//
+// -------------------------------------------------------------------------------------------------
+const ContextKeySchema = v.union([v.string(), v.symbol(), v.number()]);
+const ContextSourceSchema = v.union([
+    v.record(v.any(), v.unknown()),
+    v.array(v.tuple([ContextKeySchema, v.unknown()])),
+]);
+const OpenOptionsSchema = v.object({
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const OpenArgsSchema = v.tuple([v.optional(OpenOptionsSchema)]);
+const CloseOptionsSchema = v.object({
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const CloseArgsSchema = v.tuple([v.optional(CloseOptionsSchema)]);
+const SetOptionsSchema = v.object({
+    key: v.string(),
+    value: v.unknown(),
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const SetArgsSchema = v.union([
+    v.tuple([SetOptionsSchema]),
+    v.pipe(v.tuple([
+        SetOptionsSchema.entries.key,
+        SetOptionsSchema.entries.value,
+        v.optional(v.omit(SetOptionsSchema, ["key", "value"])),
+    ]), v.transform(([key, value, options]) => [{ ...options, key, value }])),
+]);
+const GetOptionsSchema = v.object({
+    key: v.string(),
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const GetArgsSchema = v.union([
+    v.tuple([GetOptionsSchema]),
+    v.pipe(v.tuple([GetOptionsSchema.entries.key, v.optional(v.omit(GetOptionsSchema, ["key"]))]), v.transform(([key, options]) => [{ ...options, key }])),
+]);
+const StreamOptionsSchema = v.object({
+    key: v.string(),
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const StreamArgsSchema = v.union([
+    v.tuple([StreamOptionsSchema]),
+    v.pipe(v.tuple([StreamOptionsSchema.entries.key, v.optional(v.omit(StreamOptionsSchema, ["key"]))]), v.transform(([key, options]) => [{ ...options, key }])),
+]);
+const HasOptionsSchema = v.object({
+    key: v.string(),
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const HasArgsSchema = v.union([
+    v.tuple([HasOptionsSchema]),
+    v.pipe(v.tuple([HasOptionsSchema.entries.key, v.optional(v.omit(HasOptionsSchema, ["key"]))]), v.transform(([key, options]) => [{ ...options, key }])),
+]);
+const DeleteOptionsSchema = v.object({
+    key: v.string(),
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const DeleteArgsSchema = v.union([
+    v.tuple([DeleteOptionsSchema]),
+    v.pipe(v.tuple([DeleteOptionsSchema.entries.key, v.optional(v.omit(DeleteOptionsSchema, ["key"]))]), v.transform(([key, options]) => [{ ...options, key }])),
+]);
+const ClearOptionsSchema = v.object({
+    signal: v.optional(v.instance(AbortSignal)),
+    context: v.optional(ContextSourceSchema),
+});
+const ClearArgsSchema = v.tuple([v.optional(ClearOptionsSchema)]);
+// -------------------------------------------------------------------------------------------------
+//
+// UniKvs
+//
+// -------------------------------------------------------------------------------------------------
+/**
+ * ストリームの読み取りロックを自動解放するための FinalizationRegistry です。
+ */
+const ioLockRegistry = typeof FinalizationRegistry !== "function"
+    ? null
+    : new FinalizationRegistry((lock) => {
+        try {
+            lock.unlock();
+        }
+        catch { }
+    });
+/**
+ * UniKvs メインクラスです。
+ *
+ * 複数のストレージとトランスフォーマーを統合して KVS 操作を提供します。
+ *
+ * @template TKeyValueMapping キーと値のマッピング定義です。
+ */
+export default class UniKvs {
+    /**
+     * UniKvs の設定ビルダーを作成します。
+     *
+     * @template TKeyValueMapping マッピング定義です。
+     * @returns 設定ビルダーのインスタンスです。
+     * @example
+     * ```typescript
+     * import { Compression } from "@unikvs/compression";
+     * import { FileSystem } from "@unikvs/fs.node";
+     * import { UniKvs, type Value } from "unikvs";
+     *
+     * const kvs = UniKvs.config<{
+     *   foo: Value<Uint8Array<ArrayBuffer>>;
+     * }>()
+     *   .appendTransformer(new Compression("gzip"))
+     *   .appendStorage(new FileSystem(".tmp"))
+     *   .create();
+     *
+     * await kvs.open();
+     *
+     * await kvs.set("foo", Uint8Array.from([0, 1, 2]));
+     *
+     * await kvs.close();
+     * ```
+     */
+    static config() {
+        return new UniKvsConfig(this);
+    }
+    /**
+     * インスタンスを初期化します。
+     *
+     * @internal UniKvs の設定ビルダー経由で使用します。
+     * @param context コンテキストです。
+     * @param destinations ストレージのリストです。
+     * @param transformers トランスフォーマーのリストです。
+     */
+    constructor(context, destinations, transformers) {
+        /**
+         * 現在の接続状態です。非接続時は null となります。
+         */
+        _UniKvs_con.set(this, void 0);
+        /**
+         * 基本となる実行コンテキスト情報です。
+         */
+        _UniKvs_context.set(this, void 0);
+        /**
+         * データの永続化先となるストレージのリストです。
+         */
+        _UniKvs_destinations.set(this, void 0);
+        /**
+         * データの変換を行うトランスフォーマーのリストです。
+         */
+        _UniKvs_transformers.set(this, void 0);
+        __classPrivateFieldSet(this, _UniKvs_con, null, "f");
+        __classPrivateFieldSet(this, _UniKvs_context, {
+            ...context,
+            "unikvs:instance": this,
+        }, "f");
+        __classPrivateFieldSet(this, _UniKvs_destinations, destinations, "f");
+        __classPrivateFieldSet(this, _UniKvs_transformers, transformers, "f");
+    }
+    /**
+     * UniKvs が利用可能であるかを確認します。
+     *
+     * @returns 利用可能である場合は true、そうでない場合は false を返します。
+     */
+    get isOpen() {
+        return !!__classPrivateFieldGet(this, _UniKvs_con, "f");
+    }
+    async open(...args) {
+        if (__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsOpenError();
+        }
+        __classPrivateFieldSet(this, _UniKvs_con, {
+            conAc: new AbortController(),
+            ioMux: new Asyncmux(),
+        }, "f");
+        try {
+            const [options = {}] = parse(OpenArgsSchema, args);
+            const { signal: signalOption, context: contextOption } = options;
+            const { conAc } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+            const signal = combineSignals([conAc.signal, signalOption]);
+            const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+            context["unikvs:action"] = "open";
+            const openFns = [];
+            const dispose = [];
+            const lock = await asyncmux(this, signal);
+            try {
+                // ロック待機中に接続状態が変更されていないか再確認します。
+                if (__classPrivateFieldGet(this, _UniKvs_con, "f").conAc !== conAc) {
+                    throw new UniKvsIsOpenError();
+                }
+                // 各ストレージのオープン処理をリストに追加します。
+                for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                    openFns.push([
+                        async () => {
+                            await storage.open(context, signal);
+                            dispose.push(async () => {
+                                try {
+                                    await storage.close(context, signal);
+                                }
+                                catch (ex) {
+                                    logger.error `Failed to close storage: ${ex}`;
+                                }
+                            });
+                        },
+                        "storage",
+                    ]);
+                }
+                // 各トランスフォーマーのオープン処理をリストに追加します。
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                    openFns.push([
+                        async () => {
+                            await transformer.open(context, signal);
+                            dispose.push(async () => {
+                                try {
+                                    await transformer.close(context, signal);
+                                }
+                                catch (ex) {
+                                    logger.error `Failed to close transformer: ${ex}`;
+                                }
+                            });
+                        },
+                        "transformer",
+                    ]);
+                }
+                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+                const errors = [];
+                await Promise.all(openFns.map(async ([f, plugin]) => {
+                    try {
+                        await f();
+                    }
+                    catch (reason) {
+                        errors.push({ plugin, reason });
+                    }
+                }));
+                if (errors.length > 0) {
+                    throw new PluginOperationAggregateError({ action: "open", errors });
+                }
+            }
+            catch (ex) {
+                __classPrivateFieldSet(this, _UniKvs_con, null, "f"); // unlock の前に null に戻します。
+                if (dispose.length > 0) {
+                    await Promise.all(dispose.map(async (f) => {
+                        await f();
+                    }));
+                }
+                throw ex;
+            }
+            finally {
+                lock.unlock();
+            }
+        }
+        catch (ex) {
+            __classPrivateFieldSet(this, _UniKvs_con, null, "f");
+            throw ex;
+        }
+    }
+    async close(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options = {}] = parse(CloseArgsSchema, args);
+        const { signal = AbortSignal.timeout(10e3), context: contextOption } = options;
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "close";
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        conAc.abort(new UniKvsIsNotOpenError()); // 実行中の他の操作をすべて中断させるために signal を発火させます。
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const lock = await ioMux.lock({ signal });
+            try {
+                const closeFns = [];
+                // ストレージのクローズ処理を登録します。
+                for (const plugin of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                    closeFns.push([
+                        async () => {
+                            await plugin.close(context, signal);
+                        },
+                        "storage",
+                    ]);
+                }
+                // トランスフォーマーのクローズ処理を登録します。
+                for (const plugin of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                    closeFns.push([
+                        async () => {
+                            await plugin.close(context, signal);
+                        },
+                        "transformer",
+                    ]);
+                }
+                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+                const errors = [];
+                await Promise.all(closeFns.map(async ([f, plugin]) => {
+                    try {
+                        await f();
+                    }
+                    catch (reason) {
+                        errors.push({ plugin, reason });
+                    }
+                }));
+                if (errors.length > 0) {
+                    throw new PluginOperationAggregateError({ action: "close", errors });
+                }
+            }
+            finally {
+                lock.unlock();
+            }
+        }
+        finally {
+            __classPrivateFieldSet(this, _UniKvs_con, null, "f");
+            lock.unlock();
+        }
+    }
+    async [(_UniKvs_con = new WeakMap(), _UniKvs_context = new WeakMap(), _UniKvs_destinations = new WeakMap(), _UniKvs_transformers = new WeakMap(), Symbol.asyncDispose)]() {
+        if (!this.isOpen) {
+            return;
+        }
+        await this.close({
+            signal: AbortSignal.timeout(10e3),
+        });
+    }
+    async set(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options] = parse(SetArgsSchema, args);
+        const { key, value, signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "set";
+        context["unikvs:key"] = key;
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const errors = [];
+            const errorStorageSet = new Set();
+            if (value instanceof ReadableStream) {
+                // 各トランスフォーマーを通してデータをエンコードストリームへ変換します。
+                let data = value;
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                    const e = await transformer.getEncodable(context, signal);
+                    data = data.pipeThrough(e);
+                }
+                const lock = await ioMux.lock({ key, signal });
+                try {
+                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage, i) => {
+                        try {
+                            // 複数のストレージがある場合は、tee メソッドを使用してストリームを分岐させます。
+                            let r = data;
+                            if (i !== __classPrivateFieldGet(this, _UniKvs_destinations, "f").length - 1) {
+                                [r, data] = data.tee();
+                            }
+                            const w = await storage.getWritable(context, signal, key);
+                            await r.pipeTo(w, { signal });
+                        }
+                        catch (reason) {
+                            errors.push({ reason });
+                            errorStorageSet.add(storage);
+                        }
+                    }));
+                }
+                finally {
+                    lock.unlock();
+                }
+            }
+            else {
+                // 登録されているトランスフォーマーを順番に適用してデータをエンコードします。
+                let data = value;
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f")) {
+                    data = await transformer.encode(context, signal, data);
+                }
+                const lock = await ioMux.lock({ key, signal });
+                try {
+                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                        try {
+                            await storage.write(context, signal, key, data);
+                        }
+                        catch (reason) {
+                            errors.push({ reason });
+                            errorStorageSet.add(storage);
+                        }
+                    }));
+                }
+                finally {
+                    lock.unlock();
+                }
+            }
+            // エラーが発生した場合は集約します。
+            if (errors.length > 0) {
+                const error = new PluginOperationAggregateError({
+                    plugin: "storage",
+                    action: "write",
+                    errors,
+                });
+                {
+                    const errors = [];
+                    await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                        if (errorStorageSet.has(storage)) {
+                            return;
+                        }
+                        try {
+                            await storage.onOtherWriteError(context, signal, key, error);
+                        }
+                        catch (ex) {
+                            errors.push(ex);
+                        }
+                    }));
+                    if (errors.length > 0) {
+                        logger.error(new AggregateError(errors, "Failed to handle error"));
+                    }
+                }
+                throw error;
+            }
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+    async get(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options] = parse(GetArgsSchema, args);
+        const { key, signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "get";
+        context["unikvs:key"] = key;
+        const lock = await asyncmux.readonly(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const NONE = {};
+            let data = NONE;
+            const lock = await ioMux.rLock({ key, signal });
+            try {
+                // 各ストレージを巡回し、最初に見つかったデータを取得します。
+                for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                    if (await storage.exists(context, signal, key)) {
+                        data = await storage.read(context, signal, key);
+                        break;
+                    }
+                }
+            }
+            finally {
+                lock.unlock();
+            }
+            if (data === NONE) {
+                throw new KeyNotFoundError({ key });
+            }
+            // トランスフォーマーを逆順に適用してデータをデコードします。
+            if (__classPrivateFieldGet(this, _UniKvs_transformers, "f").length > 0) {
+                for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f").toReversed()) {
+                    data = await transformer.decode(context, signal, data);
+                }
+            }
+            return data;
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+    async stream(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options] = parse(StreamArgsSchema, args);
+        const { key, signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "stream";
+        context["unikvs:key"] = key;
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const NONE = {};
+            let r = NONE;
+            const lock = await ioMux.rLock({ key, signal });
+            try {
+                // 各ストレージを巡回し、最初に見つかったデータを取得します。
+                for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                    if (await storage.exists(context, signal, key)) {
+                        r = await storage.getReadable(context, signal, key);
+                        break;
+                    }
+                }
+                if (r === NONE) {
+                    throw new KeyNotFoundError({ key });
+                }
+                // トランスフォーマーを逆順に適用し、デコード用トランスフォームを連結します。
+                if (__classPrivateFieldGet(this, _UniKvs_transformers, "f").length > 0) {
+                    for (const transformer of __classPrivateFieldGet(this, _UniKvs_transformers, "f").toReversed()) {
+                        const d = await transformer.getDecodable(context, signal);
+                        r = r.pipeThrough(d);
+                    }
+                }
+                if (!ioLockRegistry) {
+                    return toValueStream(r, async () => {
+                        try {
+                            await r.cancel();
+                        }
+                        catch { }
+                        try {
+                            lock.unlock();
+                        }
+                        catch { }
+                    });
+                }
+                const unregisterToken = {};
+                const valueStream = toValueStream(r, async () => {
+                    try {
+                        ioLockRegistry.unregister(unregisterToken);
+                    }
+                    catch { }
+                    try {
+                        await r.cancel();
+                    }
+                    catch { }
+                    try {
+                        lock.unlock();
+                    }
+                    catch { }
+                });
+                // valueStream が GC されるタイミングでストリームが終了していなければロックを自動解放します。
+                ioLockRegistry.register(valueStream, lock, unregisterToken);
+                return valueStream;
+            }
+            catch (ex) {
+                lock.unlock();
+                throw ex;
+            }
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+    async has(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options] = parse(HasArgsSchema, args);
+        const { key, signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "has";
+        context["unikvs:key"] = key;
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const lock = await ioMux.rLock({ key, signal });
+            try {
+                // いずれかのストレージに存在すれば true を返します。
+                for (const storage of __classPrivateFieldGet(this, _UniKvs_destinations, "f")) {
+                    if (await storage.exists(context, signal, key)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            finally {
+                lock.unlock();
+            }
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+    async delete(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options] = parse(DeleteArgsSchema, args);
+        const { key, signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "delete";
+        context["unikvs:key"] = key;
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const lock = await ioMux.lock({ key, signal });
+            try {
+                // すべてのストレージから対象データを削除します。
+                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+                const errors = [];
+                await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                    try {
+                        if (await storage.exists(context, signal, key)) {
+                            await storage.delete(context, signal, key);
+                        }
+                    }
+                    catch (reason) {
+                        errors.push({ reason });
+                    }
+                }));
+                if (errors.length > 0) {
+                    throw new PluginOperationAggregateError({ plugin: "storage", action: "delete", errors });
+                }
+            }
+            finally {
+                lock.unlock();
+            }
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+    async clear(...args) {
+        if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+            throw new UniKvsIsNotOpenError();
+        }
+        const [options = {}] = parse(ClearArgsSchema, args);
+        const { signal: signalOption, context: contextOption } = options;
+        const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
+        const signal = combineSignals([conAc.signal, signalOption]);
+        const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
+        context["unikvs:action"] = "clear";
+        const lock = await asyncmux(this, signal);
+        try {
+            // ロック待機中に接続状態が変更されていないか再確認します。
+            if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
+                throw new UniKvsIsNotOpenError();
+            }
+            const lock = await ioMux.lock({ signal });
+            try {
+                // すべてのストレージで一括削除を実行します。
+                // すべての処理を並列に実行し、エラーが発生した場合は集約します。
+                const errors = [];
+                await Promise.all(__classPrivateFieldGet(this, _UniKvs_destinations, "f").map(async (storage) => {
+                    try {
+                        await storage.clear(context, signal);
+                    }
+                    catch (reason) {
+                        errors.push({ reason });
+                    }
+                }));
+                if (errors.length > 0) {
+                    throw new PluginOperationAggregateError({ plugin: "storage", action: "clear", errors });
+                }
+            }
+            finally {
+                lock.unlock();
+            }
+        }
+        finally {
+            lock.unlock();
+        }
+    }
+}