unikvs 0.0.10 → 0.0.13

package/src/_unikvs.schemas.ts

@@ -0,0 +1,451 @@
+import type { TupleSchema, ObjectSchema } from "@tai-kun/valibot-extra-lab";
+import type {
+  StringSchema,
+  BooleanSchema,
+  GenericSchema,
+  UnknownSchema,
+  InstanceSchema,
+  OptionalSchema,
+} from "valibot";
+
+import type { VariablesEntry } from "./_contexts.js";
+import {
+  omit,
+  pipe,
+  tuple,
+  union,
+  custom,
+  object,
+  record,
+  string,
+  boolean,
+  unknown,
+  instance,
+  optional,
+  transform,
+} from "./_valibot.js";
+
+export const VariablesKeySchema: StringSchema<undefined> = string();
+
+export const VariablesInitSchema: GenericSchema<any, readonly VariablesEntry[]> = pipe(
+  union([
+    custom<Iterable<VariablesEntry>>(
+      // 各アイテムの検証は今後の課題です。
+      (input) => typeof input === "object" && input !== null && Symbol.iterator in input,
+      "Expected a Iterable object",
+    ),
+    record(VariablesKeySchema, unknown()),
+  ]),
+  transform(
+    (input: Iterable<VariablesEntry> | Record<string, unknown>): readonly VariablesEntry[] => {
+      if (Symbol.iterator in input) {
+        return [...input];
+      }
+
+      return Object.entries(input);
+    },
+  ),
+);
+
+export const VariablesArgsSchema: TupleSchema<[typeof VariablesInitSchema], undefined> = tuple([
+  VariablesInitSchema,
+]);
+
+export const OpenOptionsSchema: ObjectSchema<
+  {
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  /**
+   * 処理の中断を通知するためのシグナルです。
+   */
+  signal: optional(instance(AbortSignal)),
+
+  /**
+   * 実行時の変数です。
+   */
+  vars: optional(VariablesInitSchema),
+});
+
+export const OpenArgsSchema: TupleSchema<
+  [OptionalSchema<typeof OpenOptionsSchema, undefined>],
+  undefined
+> = tuple([optional(OpenOptionsSchema)]);
+
+export const CloseOptionsSchema: ObjectSchema<
+  {
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  /**
+   * 処理の中断を通知するためのシグナルです。
+   */
+  signal: optional(instance(AbortSignal)),
+
+  /**
+   * 実行時の変数です。
+   */
+  vars: optional(VariablesInitSchema),
+});
+
+export const CloseArgsSchema: TupleSchema<
+  [OptionalSchema<typeof CloseOptionsSchema, undefined>],
+  undefined
+> = tuple([optional(CloseOptionsSchema)]);
+
+export const SetOptionsSchema: ObjectSchema<
+  {
+    readonly key: StringSchema<undefined>;
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly value: UnknownSchema;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  key: string(),
+  vars: optional(VariablesInitSchema),
+  value: unknown(),
+  signal: optional(instance(AbortSignal)),
+});
+
+export const SetArgsSchema: GenericSchema<
+  any,
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly value: unknown;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly value: unknown;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+> = union([
+  tuple([SetOptionsSchema]),
+  pipe(
+    tuple([
+      SetOptionsSchema.entries.key,
+      SetOptionsSchema.entries.value,
+      optional(omit(SetOptionsSchema, ["key", "value"])),
+    ]),
+    transform(
+      ([key, value, options]: [
+        string,
+        unknown,
+        (
+          | {
+              vars?: readonly VariablesEntry[] | undefined;
+              signal?: AbortSignal | undefined;
+            }
+          | undefined
+        ),
+      ]): [
+        {
+          key: string;
+          vars?: readonly VariablesEntry[] | undefined;
+          value: unknown;
+          signal?: AbortSignal | undefined;
+        },
+      ] => [
+        {
+          ...options,
+          key,
+          value,
+        },
+      ],
+    ),
+  ),
+]);
+
+export const GetOptionsSchema: ObjectSchema<
+  {
+    readonly key: StringSchema<undefined>;
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly repair: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+    readonly throwOnRepairDenied: OptionalSchema<BooleanSchema<undefined>, undefined>;
+  },
+  undefined
+> = object({
+  key: string(),
+  vars: optional(VariablesInitSchema),
+  repair: optional(boolean()),
+  signal: optional(instance(AbortSignal)),
+  throwOnRepairDenied: optional(boolean()),
+});
+
+export const GetArgsSchema: GenericSchema<
+  any,
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly repair?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+        readonly throwOnRepairDenied?: boolean | undefined;
+      },
+    ]
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly repair?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+        readonly throwOnRepairDenied?: boolean | undefined;
+      },
+    ]
+> = union([
+  tuple([GetOptionsSchema]),
+  pipe(
+    tuple([GetOptionsSchema.entries.key, optional(omit(GetOptionsSchema, ["key"]))]),
+    transform(
+      ([key, options]: [
+        string,
+        (
+          | {
+              vars?: readonly VariablesEntry[] | undefined;
+              repair?: boolean | undefined;
+              signal?: AbortSignal | undefined;
+              throwOnRepairDenied?: boolean | undefined;
+            }
+          | undefined
+        ),
+      ]): [
+        {
+          key: string;
+          vars?: readonly VariablesEntry[] | undefined;
+          repair?: boolean | undefined;
+          signal?: AbortSignal | undefined;
+          throwOnRepairDenied?: boolean | undefined;
+        },
+      ] => [
+        {
+          ...options,
+          key,
+        },
+      ],
+    ),
+  ),
+]);
+
+export const StreamOptionsSchema: ObjectSchema<
+  {
+    readonly key: StringSchema<undefined>;
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly repair: OptionalSchema<BooleanSchema<undefined>, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+    readonly throwOnRepairDenied: OptionalSchema<BooleanSchema<undefined>, undefined>;
+  },
+  undefined
+> = object({
+  key: string(),
+  vars: optional(VariablesInitSchema),
+  repair: optional(boolean()),
+  signal: optional(instance(AbortSignal)),
+  throwOnRepairDenied: optional(boolean()),
+});
+
+export const StreamArgsSchema: GenericSchema<
+  any,
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly repair?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+        readonly throwOnRepairDenied?: boolean | undefined;
+      },
+    ]
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly repair?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+        readonly throwOnRepairDenied?: boolean | undefined;
+      },
+    ]
+> = union([
+  tuple([StreamOptionsSchema]),
+  pipe(
+    tuple([StreamOptionsSchema.entries.key, optional(omit(StreamOptionsSchema, ["key"]))]),
+    transform(
+      ([key, options]: [
+        string,
+        (
+          | {
+              vars?: readonly VariablesEntry[] | undefined;
+              repair?: boolean | undefined;
+              signal?: AbortSignal | undefined;
+              throwOnRepairDenied?: boolean | undefined;
+            }
+          | undefined
+        ),
+      ]): [
+        {
+          key: string;
+          vars?: readonly VariablesEntry[] | undefined;
+          repair?: boolean | undefined;
+          signal?: AbortSignal | undefined;
+          throwOnRepairDenied?: boolean | undefined;
+        },
+      ] => [
+        {
+          ...options,
+          key,
+        },
+      ],
+    ),
+  ),
+]);
+
+export const HasOptionsSchema: ObjectSchema<
+  {
+    readonly key: StringSchema<undefined>;
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  key: string(),
+  vars: optional(VariablesInitSchema),
+  signal: optional(instance(AbortSignal)),
+});
+
+export const HasArgsSchema: GenericSchema<
+  any,
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+> = union([
+  tuple([HasOptionsSchema]),
+  pipe(
+    tuple([HasOptionsSchema.entries.key, optional(omit(HasOptionsSchema, ["key"]))]),
+    transform(
+      ([key, options]: [
+        string,
+        (
+          | {
+              vars?: readonly VariablesEntry[] | undefined;
+              signal?: AbortSignal | undefined;
+            }
+          | undefined
+        ),
+      ]): [
+        {
+          key: string;
+          vars?: readonly VariablesEntry[] | undefined;
+          signal?: AbortSignal | undefined;
+        },
+      ] => [
+        {
+          ...options,
+          key,
+        },
+      ],
+    ),
+  ),
+]);
+
+export const DeleteOptionsSchema: ObjectSchema<
+  {
+    readonly key: StringSchema<undefined>;
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  key: string(),
+  vars: optional(VariablesInitSchema),
+  signal: optional(instance(AbortSignal)),
+});
+
+export const DeleteArgsSchema: GenericSchema<
+  any,
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+  | readonly [
+      {
+        readonly key: string;
+        readonly vars?: readonly VariablesEntry[] | undefined;
+        readonly signal?: AbortSignal | undefined;
+      },
+    ]
+> = union([
+  tuple([DeleteOptionsSchema]),
+  pipe(
+    tuple([DeleteOptionsSchema.entries.key, optional(omit(DeleteOptionsSchema, ["key"]))]),
+    transform(
+      ([key, options]: [
+        string,
+        (
+          | {
+              vars?: readonly VariablesEntry[] | undefined;
+              signal?: AbortSignal | undefined;
+            }
+          | undefined
+        ),
+      ]): [
+        {
+          key: string;
+          vars?: readonly VariablesEntry[] | undefined;
+          signal?: AbortSignal | undefined;
+        },
+      ] => [
+        {
+          ...options,
+          key,
+        },
+      ],
+    ),
+  ),
+]);
+
+export const ClearOptionsSchema: ObjectSchema<
+  {
+    readonly vars: OptionalSchema<typeof VariablesInitSchema, undefined>;
+    readonly signal: OptionalSchema<InstanceSchema<typeof AbortSignal, undefined>, undefined>;
+  },
+  undefined
+> = object({
+  /**
+   * 処理の中断を通知するためのシグナルです。
+   */
+  signal: optional(instance(AbortSignal)),
+
+  /**
+   * 実行時の変数です。
+   */
+  vars: optional(VariablesInitSchema),
+});
+
+export const ClearArgsSchema: TupleSchema<
+  [OptionalSchema<typeof ClearOptionsSchema, undefined>],
+  undefined
+> = tuple([optional(ClearOptionsSchema)]);

package/src/_valibot.ts

@@ -8,19 +8,23 @@ import {
   InvalidOutputError,
 } from "./errors.js";
 
-export type { InferInput, InferOutput } from "valibot";
+export type { InferInput, InferOutput, GenericSchema } from "valibot";
 export {
   any,
   omit,
   pipe,
+  check,
   union,
+  custom,
   number,
   string,
   symbol,
+  boolean,
   unknown,
   instance,
   minValue,
   optional,
+  safeParse,
   safeInteger,
 } from "valibot";
 
@@ -38,12 +42,17 @@ export function parseInput<const TSchema extends BaseSchema>(
   Error: IParseInputErrorConstructor = InvalidInputError,
 ): InferOutput<TSchema> {
   const result = safeParse(schema, value);
+
   if (result.success) {
     return result.output;
   }
 
-  const error = new Error({ value, issues: result.issues });
+  const error = new Error({
+    value,
+    issues: result.issues,
+  });
   tryCaptureStackTrace(error, parseInput);
+
   throw error;
 }
 
@@ -57,11 +66,16 @@ export function parseOutput<const TSchema extends BaseSchema>(
   Error: ParseOutputErrorConstructor = InvalidOutputError,
 ): InferOutput<TSchema> {
   const result = safeParse(schema, value);
+
   if (result.success) {
     return result.output;
   }
 
-  const error = new Error({ value, issues: result.issues });
+  const error = new Error({
+    value,
+    issues: result.issues,
+  });
   tryCaptureStackTrace(error, parseOutput);
+
   throw error;
 }

package/src/_value-schemas.ts

@@ -0,0 +1,192 @@
+import type { GenericSchema } from "./_valibot.js";
+import { union, safeParse } from "./_valibot.js";
+import { InvalidInputError } from "./errors.js";
+import type { PlainValue, StreamValue } from "./value-schemas.js";
+
+// -------------------------------------------------------------------------------------------------。
+//
+// 値の型。
+//
+// -------------------------------------------------------------------------------------------------。
+
+/**
+ * PlainValue 型から内部のデータ型を抽出します。
+ *
+ * @template TPlainValue 対象となる PlainValue 型です。
+ */
+export type $InferPlainValueData<TPlainValue> =
+  TPlainValue extends PlainValue<infer TData, any> ? TData : never;
+
+/**
+ * PlainValue 型から入力データの型を抽出します。
+ *
+ * @template TPlainValue 対象となる PlainValue 型です。
+ */
+export type $InferPlainValueInput<TPlainValue> =
+  TPlainValue extends PlainValue<any, infer TInput> ? TInput : never;
+
+/**
+ * StreamValue 型から内部のチャンクデータ型を抽出します。
+ *
+ * @template TStreamValue 対象となる StreamValue 型です。
+ */
+export type $InferStreamValueChunkData<TStreamValue> =
+  TStreamValue extends StreamValue<infer TChunkData, any> ? TChunkData : never;
+
+/**
+ * StreamValue 型から入力チャンクデータの型を抽出します。
+ *
+ * @template TStreamValue 対象となる StreamValue 型です。
+ */
+export type $InferStreamValueChunkInput<TStreamValue> =
+  TStreamValue extends StreamValue<any, infer TChunkInput> ? TChunkInput : never;
+
+/**
+ * スキーマ付きの値であることを識別するためのブランドです。
+ *
+ * 同じライブラリーが複数読み込まれた環境でも認識できるようにグローバルシンボルを使用します。
+ */
+export const VALUE_SCHEMA_BRAND: unique symbol = /* #__PURE__ */ Symbol.for(
+  "unikvs:VALUE_SCHEMA_BRAND",
+);
+
+/**
+ * スキーマ付きの値が扱うデータの種類です。
+ *
+ * - `"plain"`: プレーンな値のみを扱います。
+ * - `"stream"`: ストリーム形式の値のみを扱います。
+ * - `"any"`: プレーンな値とストリーム形式の値のどちらも扱います。
+ */
+export type ValueSchemaKind = "plain" | "stream" | "any";
+
+/**
+ * キーに対応する値のスキーマ情報です。
+ */
+export type ValueSchemaInfo = {
+  /**
+   * 扱うデータの種類です。
+   */
+  readonly kind: ValueSchemaKind;
+
+  /**
+   * データの検証に使用するスキーマです。
+   */
+  readonly schema: GenericSchema;
+};
+
+// -------------------------------------------------------------------------------------------------。
+//
+// スキーマ定義。
+//
+// -------------------------------------------------------------------------------------------------。
+
+/**
+ * 検証済みのオブジェクト形式のスキーマ定義です。
+ */
+type UniKvsSchemaInfoRecord = Readonly<Record<string, ValueSchemaInfo>>;
+
+/**
+ * 検証済みの配列形式のスキーマ定義です。
+ */
+type UniKvsSchemaInfoEntries = readonly (readonly [GenericSchema, ValueSchemaInfo])[];
+
+/**
+ * 検証済みのスキーマ定義です。
+ */
+type UniKvsSchemaInfo = UniKvsSchemaInfoRecord | UniKvsSchemaInfoEntries;
+
+// -------------------------------------------------------------------------------------------------。
+//
+// スキーマリゾルバー。
+//
+// -------------------------------------------------------------------------------------------------。
+
+/**
+ * キーに対応する値のスキーマ情報を解決するインターフェースです。
+ */
+export interface IValueSchemaResolver {
+  /**
+   * キーに対応する値のスキーマ情報を返します。
+   *
+   * @param key 解決するキーです。
+   *
+   * @returns 対応するスキーマ情報を返します。対応する定義がない場合は `undefined` を返します。
+   *
+   * @throws キーがどのキースキーマにも一致しない場合に `InvalidInputError` を投げます。
+   */
+  resolve(key: string): ValueSchemaInfo | undefined;
+}
+
+/**
+ * オブジェクト形式のスキーマ定義からスキーマ情報を解決します。
+ */
+class RecordValueSchemaResolver implements IValueSchemaResolver {
+  readonly #entries: Map<string, ValueSchemaInfo>;
+
+  public constructor(entries: UniKvsSchemaInfoRecord) {
+    this.#entries = new Map(Object.entries(entries));
+  }
+
+  public resolve(key: string): ValueSchemaInfo | undefined {
+    return this.#entries.get(key);
+  }
+}
+
+/**
+ * 配列形式のスキーマ定義からスキーマ情報を解決します。
+ *
+ * キースキーマに最初に一致した定義を採用します。
+ */
+class EntriesValueSchemaResolver implements IValueSchemaResolver {
+  readonly #entries: UniKvsSchemaInfoEntries;
+
+  readonly #keySchema: GenericSchema | undefined;
+
+  public constructor(entries: UniKvsSchemaInfoEntries) {
+    this.#entries = entries;
+    if (entries.length > 0) {
+      this.#keySchema = union(entries.map(([keySchema]) => keySchema));
+    }
+  }
+
+  public resolve(key: string): ValueSchemaInfo | undefined {
+    let resolved: ValueSchemaInfo | undefined;
+
+    for (const [keySchema, valueSchema] of this.#entries) {
+      const result = safeParse(keySchema, key);
+
+      if (result.success) {
+        resolved = valueSchema;
+        break;
+      }
+    }
+
+    if (resolved === undefined && this.#keySchema) {
+      const result = safeParse(this.#keySchema, key);
+
+      if (!result.success) {
+        throw new InvalidInputError({
+          value: key,
+          issues: result.issues,
+        });
+      }
+    }
+
+    return resolved;
+  }
+}
+
+/**
+ * 検証済みのスキーマ定義からスキーマリゾルバーを生成します。
+ *
+ * @param schema 検証済みのスキーマ定義です。
+ *
+ * @returns スキーマリゾルバーを返します。
+ */
+export function createValueSchemaResolver(schema: UniKvsSchemaInfo): IValueSchemaResolver {
+  if (Array.isArray(schema)) {
+    return new EntriesValueSchemaResolver(schema);
+  }
+
+  return new RecordValueSchemaResolver(schema);
+}