unikvs 0.0.9 → 0.0.12

package/src/errors.ts

@@ -13,55 +13,109 @@ import type { BaseIssue } from "valibot";
 //
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class InvalidUsageErrorBase<
   TMeta extends ErrorMeta | undefined = ErrorMeta | undefined,
 > extends ErrorBase<TMeta> {}
 
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type Issue = BaseIssue<unknown>;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type InvalidInputErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly input: unknown;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly issues: readonly [Issue, ...Issue[]];
 };
 
-export type InvalidInputErrorArgs = {
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type InvalidInputErrorArgs = ErrorOptions & {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly value: unknown;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly issues: readonly [Issue, ...Issue[]];
 };
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class InvalidInputError extends InvalidUsageErrorBase<InvalidInputErrorMeta> {
   static {
     this.prototype.name = "UniKvsInvalidInputError";
   }
 
-  public constructor(args: InvalidInputErrorArgs, options?: ErrorOptions) {
-    const { value: input, issues } = args;
-    super({ input, issues }, ({ issues }) => issues.map((i) => i.message).join(": "), options);
+  public constructor(args: InvalidInputErrorArgs) {
+    const { value: input, issues, ...options } = args;
+    const meta: InvalidInputErrorMeta = { input, issues };
+    super(meta, ({ issues }) => issues.map((i) => i.message).join(": "), options);
   }
 }
 
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type InvalidOutputErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly output: unknown;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly issues: readonly [Issue, ...Issue[]];
 };
 
-export type InvalidOutputErrorArgs = {
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type InvalidOutputErrorArgs = ErrorOptions & {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly value: unknown;
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly issues: readonly [Issue, ...Issue[]];
 };
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class InvalidOutputError extends InvalidUsageErrorBase<InvalidOutputErrorMeta> {
   static {
     this.prototype.name = "UniKvsInvalidOutputError";
   }
 
-  public constructor(args: InvalidOutputErrorArgs, options?: ErrorOptions) {
-    const { value: output, issues } = args;
-    super({ output, issues }, ({ issues }) => issues.map((i) => i.message).join(": "), options);
+  public constructor(args: InvalidOutputErrorArgs) {
+    const { value: output, issues, ...options } = args;
+    const meta: InvalidOutputErrorMeta = { output, issues };
+    super(meta, ({ issues }) => issues.map((i) => i.message).join(": "), options);
   }
 }
 
@@ -71,6 +125,9 @@ export class InvalidOutputError extends InvalidUsageErrorBase<InvalidOutputError
 //
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class UniKvsIsOpenError extends ErrorBase<undefined> {
   static {
     this.prototype.name = "UniKvsIsOpenError";
@@ -83,6 +140,9 @@ export class UniKvsIsOpenError extends ErrorBase<undefined> {
 
 setErrorMessage(UniKvsIsOpenError, "UniKvs は開いています", "ja");
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class UniKvsIsNotOpenError extends ErrorBase<undefined> {
   static {
     this.prototype.name = "UniKvsIsNotOpenError";
@@ -95,19 +155,33 @@ export class UniKvsIsNotOpenError extends ErrorBase<undefined> {
 
 setErrorMessage(UniKvsIsNotOpenError, "UniKvs は開いていません", "ja");
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type KeyNotFoundErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly key: IStorage.Key;
 };
 
-export type KeyNotFoundErrorArgs = KeyNotFoundErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type KeyNotFoundErrorArgs = ErrorOptions & KeyNotFoundErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class KeyNotFoundError extends ErrorBase<KeyNotFoundErrorMeta> {
   static {
     this.prototype.name = "UniKvsKeyNotFoundError";
   }
 
-  public constructor(args: KeyNotFoundErrorArgs, options?: ErrorOptions) {
-    super(args, ({ key }) => `IStorage.Key ${JSON.stringify(key)} not found`, options);
+  public constructor(args: KeyNotFoundErrorArgs) {
+    const { key, ...options } = args;
+    const meta: KeyNotFoundErrorMeta = { key };
+    super(meta, ({ key }) => `IStorage.Key ${JSON.stringify(key)} not found`, options);
   }
 }
 
@@ -141,86 +215,147 @@ setErrorMessage(
 
 // setErrorMessage(StorageIsOpenError, ({ name }) => `ストレージ "${name}" は開いています`, "ja");
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type StorageIsNotOpenErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type StorageIsNotOpenErrorArgs = StorageIsNotOpenErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type StorageIsNotOpenErrorArgs = ErrorOptions & StorageIsNotOpenErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class StorageIsNotOpenError extends ErrorBase<StorageIsNotOpenErrorMeta> {
   static {
     this.prototype.name = "UniKvsStorageIsNotOpenError";
   }
 
-  public constructor(args: StorageIsNotOpenErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Storage "${name}" is not open`, options);
+  public constructor(args: StorageIsNotOpenErrorArgs) {
+    const { name, ...options } = args;
+    const meta: StorageIsNotOpenErrorMeta = { name };
+    super(meta, ({ name }) => `Storage "${name}" is not open`, options);
   }
 }
 
 setErrorMessage(StorageIsNotOpenError, ({ name }) => `ストレージ "${name}" は開いていません`, "ja");
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type WritableStreamNotSupportedErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type WritableStreamNotSupportedErrorArgs = WritableStreamNotSupportedErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type WritableStreamNotSupportedErrorArgs = ErrorOptions &
+  WritableStreamNotSupportedErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class WritableStreamNotSupportedError extends ErrorBase<WritableStreamNotSupportedErrorMeta> {
   static {
     this.prototype.name = "UniKvsWritableStreamNotSupportedError";
   }
 
-  public constructor(args: WritableStreamNotSupportedErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Storage "${name}" does not support writable stream`, options);
+  public constructor(args: WritableStreamNotSupportedErrorArgs) {
+    const { name, ...options } = args;
+    const meta: WritableStreamNotSupportedErrorMeta = { name };
+    super(meta, ({ name }) => `Storage "${name}" does not support writable stream`, options);
   }
 }
 
 setErrorMessage(
-  StorageIsNotOpenError,
+  WritableStreamNotSupportedError,
   ({ name }) => `ストレージ "${name}" は書き込み可能なストリームをサポートしていません`,
   "ja",
 );
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type ReadableStreamNotSupportedErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type ReadableStreamNotSupportedErrorArgs = ReadableStreamNotSupportedErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type ReadableStreamNotSupportedErrorArgs = ErrorOptions &
+  ReadableStreamNotSupportedErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class ReadableStreamNotSupportedError extends ErrorBase<ReadableStreamNotSupportedErrorMeta> {
   static {
     this.prototype.name = "UniKvsReadableStreamNotSupportedError";
   }
 
-  public constructor(args: ReadableStreamNotSupportedErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Storage "${name}" does not support readable stream`, options);
+  public constructor(args: ReadableStreamNotSupportedErrorArgs) {
+    const { name, ...options } = args;
+    const meta: ReadableStreamNotSupportedErrorMeta = { name };
+    super(meta, ({ name }) => `Storage "${name}" does not support readable stream`, options);
   }
 }
 
 setErrorMessage(
-  StorageIsNotOpenError,
+  ReadableStreamNotSupportedError,
   ({ name }) => `ストレージ "${name}" は読み取り可能なストリームをサポートしていません`,
   "ja",
 );
 
+/**
+ * MultipartWriteNotSupportedError に付与されるメタデータです。
+ */
 export type MultipartWriteNotSupportedErrorMeta = {
+  /**
+   * 対象のストレージの名前です。
+   */
   readonly name: string;
 };
 
-export type MultipartWriteNotSupportedErrorArgs = MultipartWriteNotSupportedErrorMeta;
-
+/**
+ * MultipartWriteNotSupportedError のコンストラクター引数です。
+ *
+ * エラーの追加情報 (`cause`) も含みます。
+ */
+export type MultipartWriteNotSupportedErrorArgs = ErrorOptions &
+  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);
+  public constructor(args: MultipartWriteNotSupportedErrorArgs) {
+    const { name, ...options } = args;
+    const meta: MultipartWriteNotSupportedErrorMeta = { name };
+    super(meta, ({ name }) => `Storage "${name}" does not support multipart-write`, options);
   }
 }
 
 setErrorMessage(
-  StorageIsNotOpenError,
+  MultipartWriteNotSupportedError,
   ({ name }) => `ストレージ "${name}" はマルチパート書き込みをサポートしていません`,
   "ja",
 );
@@ -249,19 +384,33 @@ setErrorMessage(
 
 // setErrorMessage(TransformerIsOpenError, ({ name }) => `トランスフォーマー "${name}" は開いています`, "ja");
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type TransformerIsNotOpenErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type TransformerIsNotOpenErrorArgs = TransformerIsNotOpenErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type TransformerIsNotOpenErrorArgs = ErrorOptions & TransformerIsNotOpenErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class TransformerIsNotOpenError extends ErrorBase<TransformerIsNotOpenErrorMeta> {
   static {
     this.prototype.name = "UniKvsTransformerIsNotOpenError";
   }
 
-  public constructor(args: TransformerIsNotOpenErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Transformer "${name}" is not open`, options);
+  public constructor(args: TransformerIsNotOpenErrorArgs) {
+    const { name, ...options } = args;
+    const meta: TransformerIsNotOpenErrorMeta = { name };
+    super(meta, ({ name }) => `Transformer "${name}" is not open`, options);
   }
 }
 
@@ -271,46 +420,76 @@ setErrorMessage(
   "ja",
 );
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type EncodableStreamNotSupportedErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type EncodableStreamNotSupportedErrorArgs = EncodableStreamNotSupportedErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type EncodableStreamNotSupportedErrorArgs = ErrorOptions &
+  EncodableStreamNotSupportedErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class EncodableStreamNotSupportedError extends ErrorBase<EncodableStreamNotSupportedErrorMeta> {
   static {
     this.prototype.name = "UniKvsEncodableStreamNotSupportedError";
   }
 
-  public constructor(args: EncodableStreamNotSupportedErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Transformer "${name}" does not support encodable stream`, options);
+  public constructor(args: EncodableStreamNotSupportedErrorArgs) {
+    const { name, ...options } = args;
+    const meta: EncodableStreamNotSupportedErrorMeta = { name };
+    super(meta, ({ name }) => `Transformer "${name}" does not support encodable stream`, options);
   }
 }
 
 setErrorMessage(
-  TransformerIsNotOpenError,
+  EncodableStreamNotSupportedError,
   ({ name }) => `トランスフォーマー "${name}" はエンコード可能なストリームをサポートしていません`,
   "ja",
 );
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type DecodableStreamNotSupportedErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly name: string;
 };
 
-export type DecodableStreamNotSupportedErrorArgs = DecodableStreamNotSupportedErrorMeta;
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type DecodableStreamNotSupportedErrorArgs = ErrorOptions &
+  DecodableStreamNotSupportedErrorMeta;
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class DecodableStreamNotSupportedError extends ErrorBase<DecodableStreamNotSupportedErrorMeta> {
   static {
     this.prototype.name = "UniKvsDecodableStreamNotSupportedError";
   }
 
-  public constructor(args: DecodableStreamNotSupportedErrorArgs, options?: ErrorOptions) {
-    super(args, ({ name }) => `Transformer "${name}" does not support decodable stream`, options);
+  public constructor(args: DecodableStreamNotSupportedErrorArgs) {
+    const { name, ...options } = args;
+    const meta: DecodableStreamNotSupportedErrorMeta = { name };
+    super(meta, ({ name }) => `Transformer "${name}" does not support decodable stream`, options);
   }
 }
 
 setErrorMessage(
-  TransformerIsNotOpenError,
+  DecodableStreamNotSupportedError,
   ({ name }) => `トランスフォーマー "${name}" はデコード可能なストリームをサポートしていません`,
   "ja",
 );
@@ -321,41 +500,89 @@ setErrorMessage(
 //
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export type PluginOperationAggregateErrorMeta = {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly plugin: "plugin" | "storage" | "transformer";
-  readonly action: "open" | "close" | "write" | "delete" | "clear";
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
+  readonly action: "open" | "close" | "write" | "read" | "delete" | "clear";
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly errors: readonly {
+    /**
+     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+     */
     readonly plugin: "storage" | "transformer";
+
+    /**
+     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+     */
     readonly reason: unknown;
   }[];
 };
 
-export type PluginOperationAggregateErrorArgs = {
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
+export type PluginOperationAggregateErrorArgs = ErrorOptions & {
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly plugin?: "storage" | "transformer";
-  readonly action: "open" | "close" | "write" | "delete" | "clear";
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
+  readonly action: "open" | "close" | "write" | "read" | "delete" | "clear";
+
+  /**
+   * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+   */
   readonly errors: readonly {
+    /**
+     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+     */
     readonly plugin?: "storage" | "transformer";
+
+    /**
+     * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+     */
     readonly reason: unknown;
   }[];
 };
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class PluginOperationAggregateError extends ErrorBase<PluginOperationAggregateErrorMeta> {
   static {
     this.prototype.name = "UniKvsPluginOperationAggregateError";
   }
 
-  public constructor(args: PluginOperationAggregateErrorArgs, options?: ErrorOptions) {
-    const errors = args.errors.map((error) => ({
-      plugin: error.plugin ?? args.plugin ?? ("" as never),
+  public constructor(args: PluginOperationAggregateErrorArgs) {
+    const { plugin, action, errors, ...options } = args;
+    // 個々のエラーで種別が指定されていない場合は、既定の種別で補完します。
+    const normalizedErrors = errors.map((error) => ({
+      plugin: error.plugin ?? plugin ?? ("" as never),
       reason: error.reason,
     }));
-    const plugins = [...new Set(errors.map((error) => error.plugin))];
+    const plugins = [...new Set(normalizedErrors.map((error) => error.plugin))];
+    const meta: PluginOperationAggregateErrorMeta = {
+      plugin: plugins.length === 1 ? plugins[0]! : "plugin",
+      action,
+      errors: normalizedErrors,
+    };
     super(
-      {
-        plugin: plugins.length === 1 ? plugins[0]! : "plugin",
-        action: args.action,
-        errors,
-      },
+      meta,
       ({ action, errors, plugin }) => `${errors.length} ${plugin}(s) fail ${action} operation`,
       options,
     );
@@ -375,6 +602,9 @@ setErrorMessage(
 //
 // -------------------------------------------------------------------------------------------------
 
+/**
+ * [API Reference](https://tai-kun.github.io/unikvs/packages/unikvs#errors)
+ */
 export class MissingStorageError extends ErrorBase<undefined> {
   static {
     this.prototype.name = "UniKvsMissingStorageError";
@@ -390,21 +620,3 @@ setErrorMessage(
   "UniKvs を使用するためには最低 1 つのストレージが必要です",
   "ja",
 );
-
-// -------------------------------------------------------------------------------------------------
-
-export class TransformerRegistrationError extends ErrorBase<undefined> {
-  static {
-    this.prototype.name = "UniKvsTransformerRegistrationError";
-  }
-
-  public constructor(options?: ErrorOptions) {
-    super("Cannot add transformers after storage has already been registered", options);
-  }
-}
-
-setErrorMessage(
-  MissingStorageError,
-  "ストレージが登録された後にトランスフォーマーを追加することはできません",
-  "ja",
-);

package/src/index.ts

@@ -1,4 +1,4 @@
-export type * from "./context.types.js";
+export type * from "./variables.types.js";
 
 export type {
   DecodableStreamNotSupportedErrorArgs,
@@ -35,14 +35,13 @@ export {
   ReadableStreamNotSupportedError,
   StorageIsNotOpenError,
   TransformerIsNotOpenError,
-  TransformerRegistrationError,
   UniKvsIsNotOpenError,
   UniKvsIsOpenError,
   WritableStreamNotSupportedError,
 } from "./errors.js";
 
 export type * from "./unikvs-config.js";
-export { default as UniKvsConfig } from "./unikvs-config.js";
+export { PlainValue, StreamValue, Value, default as UniKvsConfig } from "./unikvs-config.js";
 
 export type * from "./unikvs.js";
 export { default as UniKvs } from "./unikvs.js";