unikvs 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unikvs",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "",
   "homepage": "https://github.com/tai-kun/unikvs",
   "license": "MIT",
@@ -24,33 +24,35 @@
       "default": "./dist/src/index.js"
     }
   },
-  "scripts": {
-    "build": "tsc --project ./.config/tsconfig.build.json"
-  },
   "dependencies": {
-    "@unikvs/core": "0.0.4",
-    "asyncmux": "^0.0.5",
+    "@tai-kun/valibot-extra-lab": "^0.0.4",
+    "@unikvs/core": "0.0.6",
+    "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.6",
+    "@unikvs/compression": "0.0.6",
+    "@unikvs/fs.node": "0.0.6",
+    "@unikvs/memory": "0.0.6",
+    "@unikvs/opfs": "0.0.6",
+    "@unikvs/utils": "0.0.6",
+    "@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,61 @@
+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 type { InferInput, InferOutput } from "valibot";
+export {
+  any,
+  omit,
+  pipe,
+  union,
+  number,
+  string,
+  symbol,
+  unknown,
+  instance,
+  minValue,
+  optional,
+  safeInteger,
+} from "valibot";
+
+export { array, tuple, object, record, transform } from "@tai-kun/valibot-extra-lab";
 
 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 +63,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 の設定を構築するためのビルダーインターフェースです。