unikvs 0.0.3 → 0.0.4

package/dist/src/utils.types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * オブジェクトのプロパティー値の型のユニオン型を抽出するユーティリティー型です。
+ *
+ * @template T 対象となるオブジェクトの型です。
+ */
+export type ValueOf<T> = T[keyof T];
+//# sourceMappingURL=utils.types.d.ts.map

package/dist/src/utils.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.types.d.ts","sourceRoot":"","sources":["../../src/utils.types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/src/value-stream.types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 値を非同期に流すための読み取り専用ストリームを定義するインターフェースです。
+ *
+ * `ReadableStream` を拡張しており、標準的なストリーム操作に加えて非同期イテレーターによる反復処理をサポートします。
+ *
+ * @template T ストリームを流れるデータの型です。
+ */
+export interface ValueStream<T = any> extends Omit<ReadableStream, keyof AsyncDisposable | keyof AsyncIteratorObject<T>>, AsyncDisposable, AsyncIteratorObject<T, void, void> {
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=value-stream.types.d.ts.map

package/dist/src/value-stream.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-stream.types.d.ts","sourceRoot":"","sources":["../../src/value-stream.types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG,CAClC,SACE,IAAI,CAAC,cAAc,EAAE,MAAM,eAAe,GAAG,MAAM,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAC1E,eAAe,EACf,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC;IACpC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/package.json

@@ -1,11 +1,7 @@
 {
   "name": "unikvs",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "",
-  "keywords": [
-    "kv",
-    "kvs"
-  ],
   "homepage": "https://github.com/tai-kun/unikvs",
   "license": "MIT",
   "author": "tai-kun",
@@ -20,54 +16,41 @@
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/src/core/index.js",
-  "module": "./dist/src/core/index.js",
-  "types": "./dist/src/core/index.d.ts",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/src/core/index.d.ts",
-      "import": "./dist/src/core/index.js",
-      "require": "./dist/src/core/index.js"
-    },
-    "./storage/memory": {
-      "types": "./dist/src/destinations/memory-storage.d.ts",
-      "import": "./dist/src/destinations/memory-storage.js",
-      "require": "./dist/src/destinations/memory-storage.js"
-    },
-    "./types/storage": {
-      "types": "./dist/src/types/storage.d.ts",
-      "import": "./dist/src/types/storage.js",
-      "require": "./dist/src/types/storage.js"
-    },
-    "./types/transformer": {
-      "types": "./dist/src/types/transformer.d.ts",
-      "import": "./dist/src/types/transformer.js",
-      "require": "./dist/src/types/transformer.js"
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
     }
   },
   "scripts": {
     "build": "tsc --project ./.config/tsconfig.build.json"
   },
   "dependencies": {
-    "@logtape/logtape": "^2.0.5",
+    "@unikvs/core": "0.0.4",
     "asyncmux": "^0.0.5",
-    "i18n-error-base": "^0.0.3",
-    "type-name": "^2.0.2"
+    "call-fn-once": "^0.0.4",
+    "try-capture-stack-trace": "^0.0.3"
   },
   "devDependencies": {
     "@tsconfig/node22": "^22.0.5",
     "@tsconfig/strictest": "^2.0.8",
-    "@types/filename-reserved-regex": "^3.0.0",
     "@types/node": "^22.19.17",
-    "@types/type-name": "^1.0.32",
-    "@vitest/browser": "^4.1.2",
-    "@vitest/browser-playwright": "^4.1.2",
-    "npm-check-updates": "^20.0.0",
-    "oxfmt": "^0.44.0",
-    "oxlint": "^1.59.0",
-    "oxlint-tsgolint": "^0.20.0",
+    "@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",
+    "npm-check-updates": "^20.0.2",
     "playwright": "^1.59.1",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.4"
+  },
+  "peerDependencies": {
+    "@logtape/logtape": "^2.0.0",
+    "valibot": "^1.0.0"
   }
 }

package/src/_combine-signals.ts

@@ -0,0 +1,67 @@
+/**
+ * 複数の AbortSignal を 1 つに結合します。
+ *
+ * @param signals 結合対象となる AbortSignal、または null / undefined の配列です。
+ * @returns 結合された新しい AbortSignal です。
+ */
+let combineSignals: (signals: readonly (AbortSignal | null | undefined)[]) => AbortSignal;
+
+if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+  // AbortSignal.any がネイティブでサポートされている場合はそれを使用します。
+
+  const AbortSignalAny = AbortSignal.any.bind(AbortSignal);
+  combineSignals = function combineSignals(inputSignals) {
+    const signals = inputSignals.filter((signal) => signal instanceof AbortSignal);
+    return AbortSignalAny(signals);
+  };
+} else {
+  // AbortSignal.any が未実装の環境向けのポリフィル実装です。
+
+  combineSignals = function combineSignals(inputSignals) {
+    const ac = new AbortController();
+    const signals: AbortSignal[] = [];
+    for (const signal of inputSignals) {
+      if (signal?.aborted) {
+        // すでに中断されている場合は、その理由（reason）を使用して即座に中断処理を行います。
+        ac.abort(signal.reason);
+        return ac.signal;
+      }
+
+      if (signal instanceof AbortSignal) {
+        signals.push(signal);
+      }
+    }
+
+    /**
+     * すべての監視対象信号からイベントリスナーを削除するクリーンアップ関数です。
+     *
+     * メモリーリークを防ぐために、いずれかの信号が中断された際に実行されます。
+     */
+    function cleanup(): void {
+      for (const signal of signals) {
+        signal.removeEventListener("abort", handleAbort);
+      }
+    }
+
+    /**
+     * いずれかの信号が abort イベントを発火させた際に呼び出されるハンドラーです。
+     *
+     * @this AbortSignal 中断を検知した AbortSignal インスタンス自身を指します。
+     */
+    function handleAbort(this: AbortSignal): void {
+      // 親のコントローラーに対して、検知した信号の理由を添えて中断を指示します。
+      ac.abort(this.reason);
+      // 一つの信号が中断されれば他の監視は不要になるため、クリーンアップを呼び出します。
+      cleanup();
+    }
+
+    // すべての有効な信号に対して、中断イベントを監視するリスナーを登録します。
+    for (const signal of signals) {
+      signal.addEventListener("abort", handleAbort, { once: true });
+    }
+
+    return ac.signal;
+  };
+}
+
+export default combineSignals;

package/src/_logger.ts

@@ -0,0 +1,5 @@
+import { getLogger } from "@logtape/logtape";
+
+const logger = getLogger("unikvs");
+
+export default logger;

package/src/_merge-context.ts

@@ -0,0 +1,10 @@
+import { Context } from "@unikvs/core";
+
+import type { ContextSource } from "./context.types.js";
+
+export default function mergeContext(
+  a: Readonly<Context>,
+  b: Readonly<Context> | ContextSource | undefined,
+): Context {
+  return { ...a, ...(Array.isArray(b) ? Object.fromEntries(b) : b) };
+}

package/src/_storage.ts

@@ -0,0 +1,130 @@
+import type { Context, IReadableStream, IStorage, IWritableStream, Key } from "@unikvs/core";
+
+import {
+  type PluginOperationAggregateError,
+  ReadableStreamNotSupportedError,
+  StorageIsNotOpenError,
+  WritableStreamNotSupportedError,
+} from "./errors.js";
+
+export class UniKvsStorage {
+  private readonly io: IStorage;
+
+  public constructor(io: IStorage) {
+    this.io = io;
+  }
+
+  public async open(context: Context, signal: AbortSignal): Promise<void> {
+    if (typeof this.io.open !== "function") {
+      return;
+    }
+
+    if (!this.io.isOpen) {
+      await this.io.open({ signal, context });
+    }
+  }
+
+  public async close(context: Context, signal: AbortSignal): Promise<void> {
+    if (typeof this.io.close !== "function") {
+      return;
+    }
+
+    if (this.io.isOpen) {
+      await this.io.close({ signal, context });
+    }
+  }
+
+  public async onOtherWriteError(
+    context: Context,
+    signal: AbortSignal,
+    key: Key,
+    error: PluginOperationAggregateError,
+  ): Promise<void> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    if (typeof this.io.onOtherWriteError !== "function") {
+      return;
+    }
+
+    await this.io.onOtherWriteError({
+      key,
+      error: error as any,
+      signal,
+      context,
+    });
+  }
+
+  public async write(context: Context, signal: AbortSignal, key: Key, data: any): Promise<void> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    await this.io.write({ key, data, signal, context });
+  }
+
+  public async read(context: Context, signal: AbortSignal, key: Key): Promise<any> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    return await this.io.read({ key, signal, context });
+  }
+
+  public async exists(context: Context, signal: AbortSignal, key: Key): Promise<boolean> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    return await this.io.exists({ key, signal, context });
+  }
+
+  public async delete(context: Context, signal: AbortSignal, key: Key): Promise<void> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    await this.io.delete({ key, signal, context });
+  }
+
+  public async clear(context: Context, signal: AbortSignal): Promise<void> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    await this.io.clear({ signal, context });
+  }
+
+  public async getWritable(
+    context: Context,
+    signal: AbortSignal,
+    key: Key,
+  ): Promise<IWritableStream> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    if (typeof this.io.getWritable !== "function") {
+      throw new WritableStreamNotSupportedError({ name: this.io.name });
+    }
+
+    return await this.io.getWritable({ key, signal, context });
+  }
+
+  public async getReadable(
+    context: Context,
+    signal: AbortSignal,
+    key: Key,
+  ): Promise<IReadableStream> {
+    if (!this.io.isOpen) {
+      throw new StorageIsNotOpenError({ name: this.io.name });
+    }
+
+    if (typeof this.io.getReadable !== "function") {
+      throw new ReadableStreamNotSupportedError({ name: this.io.name });
+    }
+
+    return await this.io.getReadable({ key, signal, context });
+  }
+}

package/src/_to-value-stream.ts

@@ -0,0 +1,59 @@
+import type { IReadableStream } from "@unikvs/core";
+import { callAsyncableFnOnce } from "call-fn-once";
+
+import logger from "./_logger.js";
+import type { ValueStream } from "./value-stream.types.js";
+
+/**
+ * 与えられた `IReadableStream` を `ValueStream` に変換します。
+ *
+ * @template T ストリームが保持する値の型です。
+ * @param readableStream 変換対象となる `IReadableStream` インスタンスです。
+ * @param onAsyncDispose ストリーム破棄時の処理です。
+ * @returns 非同期イテレーターが付与された `ValueStream` インスタンスを返します。
+ */
+export default function toValueStream<T>(
+  readableStream: IReadableStream<T>,
+  onAsyncDispose: () => Promise<void>,
+): ValueStream<T> {
+  const cacheMap = new Map();
+  async function handleDispose(): Promise<void> {
+    await callAsyncableFnOnce(cacheMap, "dispose", onAsyncDispose);
+  }
+
+  // 既存のストリームに対して Symbol.asyncIterator を動的に割り当てて返します。
+  return Object.assign(readableStream.pipeThrough(new TransformStream({ flush: handleDispose })), {
+    dispose: handleDispose,
+    [Symbol.asyncDispose]: handleDispose,
+    async *[Symbol.asyncIterator](this: IReadableStream<T>) {
+      const r = this.getReader();
+      try {
+        // ストリームが終了するまでループを回し、チャンクを読み取ります。
+        while (true) {
+          const { done, value } = await r.read();
+          if (done) {
+            break;
+          }
+
+          yield value;
+        }
+      } catch (ex) {
+        // エラーが発生した場合は、リーダーのキャンセルを試みます。
+        try {
+          await r.cancel(ex);
+        } catch (ex) {
+          logger.error`Failed to cancel reader: ${ex}`;
+        }
+
+        throw ex;
+      } finally {
+        // 最後に必ずリーダーのロックを解放し、ストリームを再利用可能な状態にします。
+        try {
+          r.releaseLock();
+        } catch (ex) {
+          logger.error`Failed to release reader's lock: ${ex}`;
+        }
+      }
+    },
+  }) as unknown as ValueStream<T>;
+}

package/src/_transformer.ts

@@ -0,0 +1,75 @@
+import type { Context, IDecodable, ITransformer, IEncodable } from "@unikvs/core";
+
+import {
+  DecodableStreamNotSupportedError,
+  EncodableStreamNotSupportedError,
+  TransformerIsNotOpenError,
+} from "./errors.js";
+
+export default class UniKvsTransformer {
+  private readonly tf: ITransformer;
+
+  public constructor(tf: ITransformer) {
+    this.tf = tf;
+  }
+
+  public async open(context: Context, signal: AbortSignal): Promise<void> {
+    if (typeof this.tf.open !== "function") {
+      return;
+    }
+
+    if (!this.tf.isOpen) {
+      await this.tf.open({ signal, context });
+    }
+  }
+
+  public async close(context: Context, signal: AbortSignal): Promise<void> {
+    if (typeof this.tf.close !== "function") {
+      return;
+    }
+
+    if (this.tf.isOpen) {
+      await this.tf.close({ signal, context });
+    }
+  }
+
+  public async encode(context: Context, signal: AbortSignal, data: any): Promise<void> {
+    if (!this.tf.isOpen) {
+      throw new TransformerIsNotOpenError({ name: this.tf.name });
+    }
+
+    return await this.tf.encode({ data, signal, context });
+  }
+
+  public async decode(context: Context, signal: AbortSignal, data: any): Promise<any> {
+    if (!this.tf.isOpen) {
+      throw new TransformerIsNotOpenError({ name: this.tf.name });
+    }
+
+    return await this.tf.decode({ data, signal, context });
+  }
+
+  public async getEncodable(context: Context, signal: AbortSignal): Promise<IEncodable> {
+    if (!this.tf.isOpen) {
+      throw new TransformerIsNotOpenError({ name: this.tf.name });
+    }
+
+    if (typeof this.tf.getEncodable !== "function") {
+      throw new EncodableStreamNotSupportedError({ name: this.tf.name });
+    }
+
+    return await this.tf.getEncodable({ signal, context });
+  }
+
+  public async getDecodable(context: Context, signal: AbortSignal): Promise<IDecodable> {
+    if (!this.tf.isOpen) {
+      throw new TransformerIsNotOpenError({ name: this.tf.name });
+    }
+
+    if (typeof this.tf.getDecodable !== "function") {
+      throw new DecodableStreamNotSupportedError({ name: this.tf.name });
+    }
+
+    return await this.tf.getDecodable({ signal, context });
+  }
+}

package/src/_valibot.ts

@@ -0,0 +1,30 @@
+import { tryCaptureStackTrace } from "try-capture-stack-trace";
+import { type InferOutput, safeParse } from "valibot";
+
+import { InvalidInputError, type Issue } from "./errors.js";
+
+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 ParseErrorConstructor {
+  new (args: ParseErrorConstructorArgs): Error;
+}
+
+export function parse<const TSchema extends BaseSchema>(
+  schema: TSchema,
+  value: unknown,
+  Error: ParseErrorConstructor = InvalidInputError,
+): InferOutput<TSchema> {
+  const result = safeParse(schema, value);
+  if (result.success) {
+    return result.output;
+  }
+
+  const error = new Error({ value, issues: result.issues });
+  tryCaptureStackTrace(error, parse);
+  throw error;
+}

package/src/context.types.ts

@@ -0,0 +1,19 @@
+import type { Context } from "@unikvs/core";
+
+import type { ValueOf } from "./utils.types.js";
+
+/**
+ * コンテキストの単一のエントリーを表す、読み取り専用のキーと値のペア（タプル）です。
+ *
+ * インデックス 0 はキー、1 は値を保持します。
+ */
+export type ContextKeyValuePair = readonly [key: keyof Context, value: ValueOf<Context>];
+
+/**
+ * コンテキストの初期化や更新に使用できる、データソースの型定義です。
+ *
+ * 以下のいずれかの形式を受け入れます：
+ * 1. 読み取り専用のコンテキストオブジェクト
+ * 2. キーと値のペアを列挙した反復可能なオブジェクト
+ */
+export type ContextSource = Readonly<Context> | readonly ContextKeyValuePair[];