unikvs 0.0.4 → 0.0.5

package/dist/src/unikvs.js

@@ -11,12 +11,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 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 * as v from "./_valibot.js";
 import { KeyNotFoundError, PluginOperationAggregateError, UniKvsIsNotOpenError, UniKvsIsOpenError, } from "./errors.js";
 import UniKvsConfig from "./unikvs-config.js";
 // -------------------------------------------------------------------------------------------------
@@ -106,7 +105,7 @@ const ioLockRegistry = typeof FinalizationRegistry !== "function"
     ? null
     : new FinalizationRegistry((lock) => {
         try {
-            lock.unlock();
+            lock.release();
         }
         catch { }
     });
@@ -196,7 +195,7 @@ export default class UniKvs {
             ioMux: new Asyncmux(),
         }, "f");
         try {
-            const [options = {}] = parse(OpenArgsSchema, args);
+            const [options = {}] = v.parseInput(OpenArgsSchema, args);
             const { signal: signalOption, context: contextOption } = options;
             const { conAc } = __classPrivateFieldGet(this, _UniKvs_con, "f");
             const signal = combineSignals([conAc.signal, signalOption]);
@@ -268,7 +267,7 @@ export default class UniKvs {
                 throw ex;
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
         }
         catch (ex) {
@@ -280,7 +279,7 @@ export default class UniKvs {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options = {}] = parse(CloseArgsSchema, args);
+        const [options = {}] = v.parseInput(CloseArgsSchema, args);
         const { signal = AbortSignal.timeout(10e3), context: contextOption } = options;
         const context = mergeContext(__classPrivateFieldGet(this, _UniKvs_context, "f"), contextOption);
         context["unikvs:action"] = "close";
@@ -328,12 +327,12 @@ export default class UniKvs {
                 }
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
         }
         finally {
             __classPrivateFieldSet(this, _UniKvs_con, null, "f");
-            lock.unlock();
+            lock.release();
         }
     }
     async [(_UniKvs_con = new WeakMap(), _UniKvs_context = new WeakMap(), _UniKvs_destinations = new WeakMap(), _UniKvs_transformers = new WeakMap(), Symbol.asyncDispose)]() {
@@ -348,7 +347,7 @@ export default class UniKvs {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options] = parse(SetArgsSchema, args);
+        const [options] = v.parseInput(SetArgsSchema, args);
         const { key, value, signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -389,7 +388,7 @@ export default class UniKvs {
                     }));
                 }
                 finally {
-                    lock.unlock();
+                    lock.release();
                 }
             }
             else {
@@ -411,7 +410,7 @@ export default class UniKvs {
                     }));
                 }
                 finally {
-                    lock.unlock();
+                    lock.release();
                 }
             }
             // エラーが発生した場合は集約します。
@@ -442,14 +441,14 @@ export default class UniKvs {
             }
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
     async get(...args) {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options] = parse(GetArgsSchema, args);
+        const [options] = v.parseInput(GetArgsSchema, args);
         const { key, signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -475,7 +474,7 @@ export default class UniKvs {
                 }
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
             if (data === NONE) {
                 throw new KeyNotFoundError({ key });
@@ -489,14 +488,14 @@ export default class UniKvs {
             return data;
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
     async stream(...args) {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options] = parse(StreamArgsSchema, args);
+        const [options] = v.parseInput(StreamArgsSchema, args);
         const { key, signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -537,7 +536,7 @@ export default class UniKvs {
                         }
                         catch { }
                         try {
-                            lock.unlock();
+                            lock.release();
                         }
                         catch { }
                     });
@@ -553,7 +552,7 @@ export default class UniKvs {
                     }
                     catch { }
                     try {
-                        lock.unlock();
+                        lock.release();
                     }
                     catch { }
                 });
@@ -562,19 +561,19 @@ export default class UniKvs {
                 return valueStream;
             }
             catch (ex) {
-                lock.unlock();
+                lock.release();
                 throw ex;
             }
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
     async has(...args) {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options] = parse(HasArgsSchema, args);
+        const [options] = v.parseInput(HasArgsSchema, args);
         const { key, signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -598,18 +597,18 @@ export default class UniKvs {
                 return false;
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
     async delete(...args) {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options] = parse(DeleteArgsSchema, args);
+        const [options] = v.parseInput(DeleteArgsSchema, args);
         const { key, signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -642,18 +641,18 @@ export default class UniKvs {
                 }
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
     async clear(...args) {
         if (!__classPrivateFieldGet(this, _UniKvs_con, "f")) {
             throw new UniKvsIsNotOpenError();
         }
-        const [options = {}] = parse(ClearArgsSchema, args);
+        const [options = {}] = v.parseInput(ClearArgsSchema, args);
         const { signal: signalOption, context: contextOption } = options;
         const { conAc, ioMux } = __classPrivateFieldGet(this, _UniKvs_con, "f");
         const signal = combineSignals([conAc.signal, signalOption]);
@@ -683,11 +682,11 @@ export default class UniKvs {
                 }
             }
             finally {
-                lock.unlock();
+                lock.release();
             }
         }
         finally {
-            lock.unlock();
+            lock.release();
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unikvs",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
   "homepage": "https://github.com/tai-kun/unikvs",
   "license": "MIT",
@@ -24,33 +24,34 @@
       "default": "./dist/src/index.js"
     }
   },
-  "scripts": {
-    "build": "tsc --project ./.config/tsconfig.build.json"
-  },
   "dependencies": {
-    "@unikvs/core": "0.0.4",
-    "asyncmux": "^0.0.5",
+    "@unikvs/core": "0.0.5",
+    "asyncmux": "^0.0.8",
     "call-fn-once": "^0.0.4",
     "try-capture-stack-trace": "^0.0.3"
   },
   "devDependencies": {
-    "@tsconfig/node22": "^22.0.5",
+    "@tsconfig/node24": "^24.0.4",
     "@tsconfig/strictest": "^2.0.8",
-    "@types/node": "^22.19.17",
-    "@unikvs/checksum": "0.0.4",
-    "@unikvs/compression": "0.0.4",
-    "@unikvs/fs.node": "0.0.4",
-    "@unikvs/memory": "0.0.4",
-    "@unikvs/opfs": "0.0.4",
-    "@unikvs/utils": "0.0.4",
-    "@vitest/browser": "^4.1.4",
-    "@vitest/browser-playwright": "^4.1.4",
+    "@types/node": "^24.12.2",
+    "@unikvs/checksum": "0.0.5",
+    "@unikvs/compression": "0.0.5",
+    "@unikvs/fs.node": "0.0.5",
+    "@unikvs/memory": "0.0.5",
+    "@unikvs/opfs": "0.0.5",
+    "@unikvs/utils": "0.0.5",
+    "@vitest/browser": "^4.1.5",
+    "@vitest/browser-playwright": "^4.1.5",
     "npm-check-updates": "^20.0.2",
     "playwright": "^1.59.1",
-    "vitest": "^4.1.4"
+    "vite": "^8.0.10",
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
     "@logtape/logtape": "^2.0.0",
     "valibot": "^1.0.0"
+  },
+  "scripts": {
+    "build": "tsc --project ./.config/tsconfig.build.json"
   }
-}
+}

package/src/_storage.ts

@@ -1,5 +1,6 @@
-import type { Context, IReadableStream, IStorage, IWritableStream, Key } from "@unikvs/core";
+import type { Context, IReadableStream, IStorage, IWritableStream } from "@unikvs/core";
 
+import * as v from "./_valibot.js";
 import {
   type PluginOperationAggregateError,
   ReadableStreamNotSupportedError,
@@ -7,7 +8,7 @@ import {
   WritableStreamNotSupportedError,
 } from "./errors.js";
 
-export class UniKvsStorage {
+export default class UniKvsStorage {
   private readonly io: IStorage;
 
   public constructor(io: IStorage) {
@@ -37,7 +38,7 @@ export class UniKvsStorage {
   public async onOtherWriteError(
     context: Context,
     signal: AbortSignal,
-    key: Key,
+    key: IStorage.Key,
     error: PluginOperationAggregateError,
   ): Promise<void> {
     if (!this.io.isOpen) {
@@ -56,7 +57,12 @@ export class UniKvsStorage {
     });
   }
 
-  public async write(context: Context, signal: AbortSignal, key: Key, data: any): Promise<void> {
+  public async write(
+    context: Context,
+    signal: AbortSignal,
+    key: IStorage.Key,
+    data: unknown,
+  ): Promise<void> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
     }
@@ -64,23 +70,28 @@ export class UniKvsStorage {
     await this.io.write({ key, data, signal, context });
   }
 
-  public async read(context: Context, signal: AbortSignal, key: Key): Promise<any> {
+  public async read(context: Context, signal: AbortSignal, key: IStorage.Key): Promise<unknown> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
     }
 
-    return await this.io.read({ key, signal, context });
+    const output = await this.io.read({ key, signal, context });
+
+    return output;
   }
 
-  public async exists(context: Context, signal: AbortSignal, key: Key): Promise<boolean> {
+  public async exists(context: Context, signal: AbortSignal, key: IStorage.Key): Promise<boolean> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
     }
 
-    return await this.io.exists({ key, signal, context });
+    const output = await this.io.exists({ key, signal, context });
+    const parsed = Boolean(output);
+
+    return parsed;
   }
 
-  public async delete(context: Context, signal: AbortSignal, key: Key): Promise<void> {
+  public async delete(context: Context, signal: AbortSignal, key: IStorage.Key): Promise<void> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
     }
@@ -99,7 +110,7 @@ export class UniKvsStorage {
   public async getWritable(
     context: Context,
     signal: AbortSignal,
-    key: Key,
+    key: IStorage.Key,
   ): Promise<IWritableStream> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
@@ -109,13 +120,16 @@ export class UniKvsStorage {
       throw new WritableStreamNotSupportedError({ name: this.io.name });
     }
 
-    return await this.io.getWritable({ key, signal, context });
+    const output = await this.io.getWritable({ key, signal, context });
+    const parsed = v.parseOutput(v.instance(WritableStream), output);
+
+    return parsed;
   }
 
   public async getReadable(
     context: Context,
     signal: AbortSignal,
-    key: Key,
+    key: IStorage.Key,
   ): Promise<IReadableStream> {
     if (!this.io.isOpen) {
       throw new StorageIsNotOpenError({ name: this.io.name });
@@ -125,6 +139,9 @@ export class UniKvsStorage {
       throw new ReadableStreamNotSupportedError({ name: this.io.name });
     }
 
-    return await this.io.getReadable({ key, signal, context });
+    const output = await this.io.getReadable({ key, signal, context });
+    const parsed = v.parseOutput(v.instance(ReadableStream), output);
+
+    return parsed;
   }
 }

package/src/_transformer.ts

@@ -33,20 +33,24 @@ export default class UniKvsTransformer {
     }
   }
 
-  public async encode(context: Context, signal: AbortSignal, data: any): Promise<void> {
+  public async encode(context: Context, signal: AbortSignal, data: any): Promise<unknown> {
     if (!this.tf.isOpen) {
       throw new TransformerIsNotOpenError({ name: this.tf.name });
     }
 
-    return await this.tf.encode({ data, signal, context });
+    const output = await this.tf.encode({ data, signal, context });
+
+    return output;
   }
 
-  public async decode(context: Context, signal: AbortSignal, data: any): Promise<any> {
+  public async decode(context: Context, signal: AbortSignal, data: any): Promise<unknown> {
     if (!this.tf.isOpen) {
       throw new TransformerIsNotOpenError({ name: this.tf.name });
     }
 
-    return await this.tf.decode({ data, signal, context });
+    const output = await this.tf.decode({ data, signal, context });
+
+    return output;
   }
 
   public async getEncodable(context: Context, signal: AbortSignal): Promise<IEncodable> {
@@ -58,7 +62,10 @@ export default class UniKvsTransformer {
       throw new EncodableStreamNotSupportedError({ name: this.tf.name });
     }
 
-    return await this.tf.getEncodable({ signal, context });
+    const output = await this.tf.getEncodable({ signal, context });
+    const parsed = output; // TODO(tai-kun): 要検証
+
+    return parsed;
   }
 
   public async getDecodable(context: Context, signal: AbortSignal): Promise<IDecodable> {
@@ -70,6 +77,9 @@ export default class UniKvsTransformer {
       throw new DecodableStreamNotSupportedError({ name: this.tf.name });
     }
 
-    return await this.tf.getDecodable({ signal, context });
+    const output = await this.tf.getDecodable({ signal, context });
+    const parsed = output; // TODO(tai-kun): 要検証
+
+    return parsed;
   }
 }

package/src/_valibot.ts

@@ -1,23 +1,63 @@
+import type { ErrorOptions } from "@unikvs/core";
 import { tryCaptureStackTrace } from "try-capture-stack-trace";
 import { type InferOutput, safeParse } from "valibot";
 
-import { InvalidInputError, type Issue } from "./errors.js";
+import {
+  InvalidInputError,
+  InvalidOutputError,
+  type InvalidInputErrorArgs,
+  type InvalidOutputErrorArgs,
+} from "./errors.js";
+
+export {
+  any,
+  omit,
+  pipe,
+  array,
+  tuple,
+  union,
+  number,
+  object,
+  record,
+  string,
+  symbol,
+  unknown,
+  instance,
+  minValue,
+  optional,
+  transform,
+  safeInteger,
+} from "valibot";
 
 type BaseSchema = typeof safeParse extends (schema: infer S, ...args: any) => any ? S : never;
 
-export type ParseErrorConstructorArgs = {
-  readonly value: unknown;
-  readonly issues: readonly [Issue, ...Issue[]];
-};
+export interface ParseInputErrorConstructor {
+  new (args: InvalidInputErrorArgs, options?: ErrorOptions): Error;
+}
+
+export function parseInput<const TSchema extends BaseSchema>(
+  schema: TSchema,
+  value: unknown,
+  Error: ParseInputErrorConstructor = InvalidInputError,
+): InferOutput<TSchema> {
+  const result = safeParse(schema, value);
+  if (result.success) {
+    return result.output;
+  }
+
+  const error = new Error({ value, issues: result.issues });
+  tryCaptureStackTrace(error, parseInput);
+  throw error;
+}
 
-export interface ParseErrorConstructor {
-  new (args: ParseErrorConstructorArgs): Error;
+export interface ParseOutputErrorConstructor {
+  new (args: InvalidOutputErrorArgs, options?: ErrorOptions): Error;
 }
 
-export function parse<const TSchema extends BaseSchema>(
+export function parseOutput<const TSchema extends BaseSchema>(
   schema: TSchema,
   value: unknown,
-  Error: ParseErrorConstructor = InvalidInputError,
+  Error: ParseOutputErrorConstructor = InvalidOutputError,
 ): InferOutput<TSchema> {
   const result = safeParse(schema, value);
   if (result.success) {
@@ -25,6 +65,6 @@ export function parse<const TSchema extends BaseSchema>(
   }
 
   const error = new Error({ value, issues: result.issues });
-  tryCaptureStackTrace(error, parse);
+  tryCaptureStackTrace(error, parseOutput);
   throw error;
 }

package/src/errors.ts

@@ -1,4 +1,10 @@
-import { setErrorMessage, ErrorBase, type ErrorOptions, type ErrorMeta, Key } from "@unikvs/core";
+import {
+  setErrorMessage,
+  ErrorBase,
+  type ErrorOptions,
+  type ErrorMeta,
+  type IStorage,
+} from "@unikvs/core";
 import type { BaseIssue } from "valibot";
 
 // -------------------------------------------------------------------------------------------------
@@ -90,7 +96,7 @@ export class UniKvsIsNotOpenError extends ErrorBase<undefined> {
 setErrorMessage(UniKvsIsNotOpenError, "UniKvs は開いていません", "ja");
 
 export type KeyNotFoundErrorMeta = {
-  readonly key: Key;
+  readonly key: IStorage.Key;
 };
 
 export type KeyNotFoundErrorArgs = KeyNotFoundErrorMeta;
@@ -101,7 +107,7 @@ export class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
   }
 
   public constructor(args: KeyNotFoundErrorArgs, options?: ErrorOptions) {
-    super(args, ({ key }) => `Key ${JSON.stringify(key)} not found`, options);
+    super(args, ({ key }) => `IStorage.Key ${JSON.stringify(key)} not found`, options);
   }
 }
 
@@ -197,6 +203,28 @@ setErrorMessage(
   "ja",
 );
 
+export type MultipartWriteNotSupportedErrorMeta = {
+  readonly name: string;
+};
+
+export type MultipartWriteNotSupportedErrorArgs = MultipartWriteNotSupportedErrorMeta;
+
+export class MultipartWriteNotSupportedError extends ErrorBase<MultipartWriteNotSupportedErrorMeta> {
+  static {
+    this.prototype.name = "UniKvsMultipartWriteNotSupportedError";
+  }
+
+  public constructor(args: MultipartWriteNotSupportedErrorArgs, options?: ErrorOptions) {
+    super(args, ({ name }) => `Storage "${name}" does not support multipart-write`, options);
+  }
+}
+
+setErrorMessage(
+  StorageIsNotOpenError,
+  ({ name }) => `ストレージ "${name}" はマルチパート書き込みをサポートしていません`,
+  "ja",
+);
+
 // -------------------------------------------------------------------------------------------------
 //
 // トランスフォーマー

package/src/unikvs-config.ts

@@ -3,13 +3,12 @@ import type {
   IReadableStreamStorage,
   IStorage,
   IWritableStreamStorage,
-  Key,
   IDecodableStreamTransformer,
   IEncodableStreamTransformer,
   ITransformer,
 } from "@unikvs/core";
 
-import { UniKvsStorage } from "./_storage.js";
+import UniKvsStorage from "./_storage.js";
 import UniKvsTransformer from "./_transformer.js";
 import type { ContextSource } from "./context.types.js";
 import { MissingStorageError } from "./errors.js";
@@ -95,18 +94,16 @@ export type StreamValue<TChunkData = any> = [Type: typeof STREAM_VALUE, ChunkDat
 /**
  * UniKvs で扱う値の抽象型です。プレーンな値かストリーム値のいずれかになります。
  *
- * @template TDataAndChunkData データまたはチャンクデータの型です。
+ * @template TData データまたはチャンクデータの型です。
  */
-export type Value<TDataAndChunkData = any> =
-  | PlainValue<TDataAndChunkData>
-  | StreamValue<TDataAndChunkData>;
+export type Value<TData = any> = PlainValue<TData> | StreamValue<TData>;
 
 /**
  * キーと値のマッピングを定義するオブジェクトの型です。
  *
  * @template T マッピングされる値の型です。
  */
-export type KeyValueMapping<T = any> = { readonly [key: Key]: Value<T> };
+export type KeyValueMapping<T = any> = { readonly [key: IStorage.Key]: Value<T> };
 
 /**
  * PlainValue 型から内部のデータ型を抽出します。
@@ -130,7 +127,7 @@ export type $InferStreamValueChunkData<TStremValue> =
  * @template TKeyValueMapping 対象となるマッピング型です。
  */
 export type KeyofKeyValueMapping<TKeyValueMapping extends KeyValueMapping = KeyValueMapping> =
-  Extract<keyof TKeyValueMapping, Key>;
+  Extract<keyof TKeyValueMapping, IStorage.Key>;
 
 /**
  * UniKvs の設定を構築するためのビルダーインターフェースです。