unikvs 0.0.2 → 0.0.3

package/src/core/unikvs.ts

@@ -0,0 +1,740 @@
+import { asyncmux, Asyncmux } from "asyncmux";
+
+import combineSignals from "./_combine-signals.js";
+import log from "./_logger.js";
+import mergeContext from "./_merge-context.js";
+import toValueStream from "./_to-value-stream.js";
+import type { Context, ContextSource } from "./context.types.js";
+import type { IPlugin } from "./plugin.types.js";
+import type { IReadableStream, IStorage, Key } from "./storage.types.js";
+import type { ITransformer } from "./transformer.types.js";
+import UniKvsConfig, {
+  type $InferPlainValueData,
+  type $InferStreamValueChunkData,
+  type IUniKvsConfigBuilder,
+  type KeyofKeyValueMapping,
+  type KeyValueMapping,
+  type PlainValue,
+  type StreamValue,
+  type Value,
+} from "./unikvs-config.js";
+import type { ValueOf } from "./utils.types.js";
+import type { ValueStream } from "./value-stream.types.js";
+
+export type InputValue<TValue extends Value> =
+  | $InferPlainValueData<TValue>
+  | (TValue extends StreamValue<infer TChunkData> ? ReadableStream<TChunkData> : never);
+
+export type KeyofKeyValueMappingHasPlainValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
+  [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: PlainValue extends TKeyValueMapping[TKey]
+    ? TKey
+    : never;
+}>;
+
+export type KeyofKeyValueMappingHasStreamValue<TKeyValueMapping extends KeyValueMapping> = ValueOf<{
+  [TKey in KeyofKeyValueMapping<TKeyValueMapping>]: StreamValue extends TKeyValueMapping[TKey]
+    ? TKey
+    : never;
+}>;
+
+export type OpenOptions = {
+  readonly signal?: AbortSignal | undefined;
+};
+
+export type CloseOptions = {
+  readonly signal?: AbortSignal | undefined;
+};
+
+export type SetOptions<
+  TKeyValueMapping extends KeyValueMapping = KeyValueMapping,
+  TKey extends KeyofKeyValueMapping<TKeyValueMapping> = KeyofKeyValueMapping<TKeyValueMapping>,
+> = {
+  readonly key: TKey;
+  readonly value: InputValue<TKeyValueMapping[TKey]>;
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+export type GetOptions<TKey = Key> = {
+  readonly key: TKey;
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+export type StreamOptions<TKey = Key> = {
+  readonly key: TKey;
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+export type HasOptions<TKey = Key> = {
+  readonly key: TKey;
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+// export type KeysOptions = {
+//   readonly signal?: AbortSignal | undefined;
+//   readonly context?: Context | ContextSource | undefined;
+// };
+
+export type DeleteOptions<TKey = Key> = {
+  readonly key: TKey;
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+export type ClearOptions = {
+  readonly signal?: AbortSignal | undefined;
+  readonly context?: Context | ContextSource | undefined;
+};
+
+export default class UniKvs<TKeyValueMapping extends KeyValueMapping = KeyValueMapping> {
+  public static config<
+    TKeyValueMapping extends KeyValueMapping,
+  >(): IUniKvsConfigBuilder<TKeyValueMapping> {
+    return new UniKvsConfig(this);
+  }
+
+  #con: null | {
+    ac: AbortController;
+    ioMux: Asyncmux;
+  };
+
+  readonly #context: Readonly<Context>;
+
+  readonly #destinations: readonly [IStorage, ...IStorage[]];
+
+  readonly #transformers: readonly ITransformer[];
+
+  readonly #transformerSet: ReadonlySet<IPlugin>;
+
+  public constructor(
+    context: Readonly<Context>,
+    destinations: readonly [IStorage, ...IStorage[]],
+    transformers: readonly ITransformer[],
+  ) {
+    this.#con = null;
+    this.#context = context;
+    this.#destinations = destinations;
+    this.#transformers = transformers;
+    this.#transformerSet = new Set(transformers);
+  }
+
+  public get isOpen(): boolean {
+    return !!this.#con;
+  }
+
+  public open(signal?: AbortSignal): Promise<void>;
+
+  public open(options?: OpenOptions): Promise<void>;
+
+  public open(signalOrOptions?: AbortSignal | OpenOptions): Promise<void>;
+
+  public async open(arg0: AbortSignal | OpenOptions = {}): Promise<void> {
+    if (this.#con) {
+      throw new Error();
+    }
+
+    this.#con = {
+      ac: new AbortController(),
+      ioMux: new Asyncmux(),
+    };
+    const { ac } = this.#con;
+
+    const { signal } = (function parseOpenArguments() {
+      const { signal } = arg0 instanceof AbortSignal ? { signal: arg0 } : arg0;
+
+      return {
+        signal: combineSignals([signal, ac.signal]),
+      };
+    })();
+
+    using _ = await asyncmux(this, signal);
+
+    if (this.#con.ac !== ac) {
+      throw new Error();
+    }
+
+    const context: Context = { "unikvs:action": "open" };
+    const plugins: IPlugin[] = [...this.#destinations, ...this.#transformers];
+    const openFns: (() => Promise<void>)[] = [];
+    const dispose: (() => Promise<void>)[] = [];
+    for (const plugin of plugins) {
+      if (plugin.isOpen || !plugin.open) {
+        continue;
+      }
+
+      openFns.push(async () => {
+        await plugin.open!(signal, context);
+        if (!plugin.close) {
+          return;
+        }
+
+        dispose.push(async () => {
+          try {
+            await plugin.close!(signal, context);
+          } catch (ex) {
+            if (!this.#transformerSet.has(plugin)) {
+              log.warn`Failed to close storage: ${ex}`;
+            } else {
+              log.warn`Failed to close transformer: ${ex}`;
+            }
+          }
+        });
+      });
+    }
+
+    try {
+      if (openFns.length > 0) {
+        const errors: unknown[] = [];
+        await Promise.all(
+          openFns.map(async (f) => {
+            try {
+              await f();
+            } catch (ex) {
+              errors.push(ex);
+            }
+          }),
+        );
+        switch (errors.length) {
+          case 0:
+            break;
+          case 1:
+            throw errors[0];
+          default:
+            throw new AggregateError(errors);
+        }
+      }
+    } catch (ex) {
+      if (dispose.length > 0) {
+        await Promise.all(dispose.map((f) => f()));
+      }
+
+      this.#con = null;
+
+      throw ex;
+    }
+  }
+
+  public close(signal?: AbortSignal): Promise<void>;
+
+  public close(options?: CloseOptions): Promise<void>;
+
+  public close(signalOrOptions?: AbortSignal | CloseOptions): Promise<void>;
+
+  public async close(arg0: AbortSignal | CloseOptions = {}): Promise<void> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { signal } = (function parseCloseArguments() {
+      const { signal } = arg0 instanceof AbortSignal ? { signal: arg0 } : arg0;
+
+      return {
+        signal: combineSignals([signal, AbortSignal.timeout(10e3)]),
+      };
+    })();
+
+    const { ac, ioMux } = this.#con;
+    ac.abort();
+
+    using _lock = await asyncmux(this, signal);
+    using _ioLock = await ioMux.lock({ signal });
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const context: Context = { "unikvs:action": "close" };
+    const plugins: IPlugin[] = [...this.#destinations, ...this.#transformers];
+    const closeFns: (() => Promise<void>)[] = [];
+    for (const plugin of plugins) {
+      if (plugin.isOpen || !plugin.close) {
+        continue;
+      }
+
+      closeFns.push(async () => {
+        await plugin.close!(signal, context);
+      });
+    }
+
+    if (closeFns.length > 0) {
+      const errors: unknown[] = [];
+      await Promise.all(
+        closeFns.map(async (f) => {
+          try {
+            await f();
+          } catch (ex) {
+            errors.push(ex);
+          }
+        }),
+      );
+      switch (errors.length) {
+        case 0:
+          break;
+        case 1:
+          throw errors[0];
+        default:
+          throw new AggregateError(errors);
+      }
+    }
+  }
+
+  async #open(signal: AbortSignal, context: Context): Promise<AsyncDisposable> {
+    const plugins: IPlugin[] = [...this.#destinations, ...this.#transformers];
+    const openFns: (() => Promise<void>)[] = [];
+    const dispose: (() => Promise<void>)[] = [];
+    for (const plugin of plugins) {
+      if (plugin.isOpen || !plugin.open) {
+        continue;
+      }
+
+      openFns.push(async () => {
+        await plugin.open!(signal, context);
+        if (!plugin.close) {
+          return;
+        }
+
+        dispose.push(async () => {
+          try {
+            await plugin.close!(signal, context);
+          } catch (ex) {
+            if (!this.#transformerSet.has(plugin)) {
+              log.warn`Failed to close storage: ${ex}`;
+            } else {
+              log.warn`Failed to close transformer: ${ex}`;
+            }
+          }
+        });
+      });
+    }
+
+    if (openFns.length > 0) {
+      const errors: unknown[] = [];
+      await Promise.all(
+        openFns.map(async (f) => {
+          try {
+            await f();
+          } catch (ex) {
+            errors.push(ex);
+          }
+        }),
+      );
+      switch (errors.length) {
+        case 0:
+          break;
+        case 1:
+          throw errors[0];
+        default:
+          throw new AggregateError(errors);
+      }
+    }
+
+    return {
+      async [Symbol.asyncDispose]() {
+        if (dispose.length > 0) {
+          await Promise.all(dispose.map((f) => f()));
+        }
+      },
+    };
+  }
+
+  public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
+    key: TKey,
+    value: InputValue<TKeyValueMapping[TKey]>,
+    options?: Omit<SetOptions, "key" | "value">,
+  ): Promise<void>;
+
+  public set<const TKey extends KeyofKeyValueMapping<TKeyValueMapping>>(
+    options: SetOptions<TKeyValueMapping, TKey>,
+  ): Promise<void>;
+
+  public async set(
+    arg0: Key | SetOptions,
+    arg1?: unknown,
+    arg2?: Omit<SetOptions, "key" | "value">,
+  ): Promise<void> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { key, value, signal, context } = (function parseSetArguments(ctx) {
+      const { key, value, signal, context } =
+        typeof arg0 === "object"
+          ? arg0
+          : {
+              ...arg2,
+              key: arg0,
+              value: arg1,
+            };
+
+      return {
+        key,
+        value,
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "set";
+
+    await using _close = await this.#open(signal, context);
+
+    const errors: unknown[] = [];
+    if (value instanceof ReadableStream) {
+      let data = value;
+      for (const transformer of this.#transformers) {
+        const e = await transformer.getEncodable!(signal, context);
+        data = data.pipeThrough(e);
+      }
+
+      using _ioLock = await ioMux.lock({ key, signal });
+      await Promise.all(
+        this.#destinations.map(async (storage, i) => {
+          let r = data;
+          if (i !== this.#destinations.length - 1) {
+            [r, data] = data.tee();
+          }
+
+          try {
+            const w = await storage.getWritable!(key, signal, context);
+            await r.pipeTo(w, { signal });
+          } catch (ex) {
+            errors.push(ex);
+          }
+        }),
+      );
+    } else {
+      let data = value;
+      for (const transformer of this.#transformers) {
+        data = await transformer.encode(data, signal, context);
+      }
+
+      using _ioLock = await ioMux.lock({ key, signal });
+      await Promise.all(
+        this.#destinations.map(async (storage) => {
+          try {
+            await storage.write(key, data, signal, context);
+          } catch (ex) {
+            errors.push(ex);
+          }
+        }),
+      );
+    }
+
+    switch (errors.length) {
+      case 0:
+        break;
+      case 1:
+        throw errors[0];
+      default:
+        throw new AggregateError(errors);
+    }
+  }
+
+  public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
+    key: TKey,
+    options?: Omit<GetOptions, "key">,
+  ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
+
+  public get<const TKey extends KeyofKeyValueMappingHasPlainValue<TKeyValueMapping>>(
+    options: GetOptions<TKey>,
+  ): Promise<$InferPlainValueData<TKeyValueMapping[TKey]>>;
+
+  public async get(arg0: Key | GetOptions, arg1: Omit<GetOptions, "key"> = {}): Promise<unknown> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { key, signal, context } = (function parseGetArguments(ctx) {
+      const { key, signal, context } =
+        typeof arg0 === "object"
+          ? arg0
+          : {
+              ...arg1,
+              key: arg0,
+            };
+
+      return {
+        key,
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "get";
+
+    await using _close = await this.#open(signal, context);
+
+    const NONE = {};
+    let data: unknown = NONE;
+
+    {
+      using _ioLock = await ioMux.rLock({ key, signal });
+      for (const storage of this.#destinations) {
+        if (await storage.exists(key, signal, context)) {
+          data = await storage.read(key, signal, context);
+        }
+      }
+    }
+
+    if (data === NONE) {
+      throw new Error();
+    }
+
+    if (this.#transformers.length > 0) {
+      for (const transformer of this.#transformers.toReversed()) {
+        data = await transformer.decode(data, signal, context);
+      }
+    }
+
+    return data;
+  }
+
+  public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
+    key: TKey,
+    options?: Omit<StreamOptions, "key">,
+  ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
+
+  public stream<const TKey extends KeyofKeyValueMappingHasStreamValue<TKeyValueMapping>>(
+    options: StreamOptions<TKey>,
+  ): Promise<ValueStream<$InferStreamValueChunkData<TKeyValueMapping[TKey]>>>;
+
+  public async stream(
+    arg0: Key | StreamOptions,
+    arg1: Omit<GetOptions, "key"> = {},
+  ): Promise<ValueStream<unknown>> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { key, signal, context } = (function parseStreamArguments(ctx) {
+      const { key, signal, context } =
+        typeof arg0 === "object"
+          ? arg0
+          : {
+              ...arg1,
+              key: arg0,
+            };
+
+      return {
+        key,
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "stream";
+
+    await using _close = await this.#open(signal, context);
+
+    const NONE: any = {};
+    let r: IReadableStream = NONE;
+
+    {
+      using _ioLock = await ioMux.rLock({ key, signal });
+      for (const storage of this.#destinations) {
+        if (await storage.exists(key, signal, context)) {
+          r = await storage.getReadable!(key, signal, context);
+        }
+      }
+    }
+
+    if (r === NONE) {
+      throw new Error();
+    }
+
+    if (this.#transformers.length > 0) {
+      for (const transformer of this.#transformers.toReversed()) {
+        const d = await transformer.getDecodable!(signal, context);
+        r = r.pipeThrough(d);
+      }
+    }
+
+    return toValueStream(r);
+  }
+
+  public has(
+    key: KeyofKeyValueMapping<TKeyValueMapping>,
+    options?: Omit<HasOptions, "key">,
+  ): Promise<boolean>;
+
+  public has(options: HasOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<boolean>;
+
+  public async has(arg0: Key | HasOptions, arg1: Omit<HasOptions, "key"> = {}): Promise<boolean> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { key, signal, context } = (function parseHasArguments(ctx) {
+      const { key, signal, context } =
+        typeof arg0 === "object"
+          ? arg0
+          : {
+              ...arg1,
+              key: arg0,
+            };
+
+      return {
+        key,
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "has";
+
+    await using _close = await this.#open(signal, context);
+
+    using _ioLock = await ioMux.rLock({ key, signal });
+    for (const storage of this.#destinations) {
+      if (await storage.exists(key, signal, context)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  public delete(
+    key: KeyofKeyValueMapping<TKeyValueMapping>,
+    options?: Omit<DeleteOptions, "key">,
+  ): Promise<void>;
+
+  public delete(options: DeleteOptions<KeyofKeyValueMapping<TKeyValueMapping>>): Promise<void>;
+
+  public async delete(
+    arg0: Key | DeleteOptions,
+    arg1: Omit<DeleteOptions, "key"> = {},
+  ): Promise<void> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { key, signal, context } = (function parseDeleteArguments(ctx) {
+      const { key, signal, context } =
+        typeof arg0 === "object"
+          ? arg0
+          : {
+              ...arg1,
+              key: arg0,
+            };
+
+      return {
+        key,
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "delete";
+
+    await using _close = await this.#open(signal, context);
+
+    const errors: unknown[] = [];
+    using _ioLock = await ioMux.lock({ key, signal });
+    await Promise.all(
+      this.#destinations.map(async (storage) => {
+        try {
+          if (await storage.exists(key, signal, context)) {
+            await storage.delete(key, signal, context);
+          }
+        } catch (ex) {
+          errors.push(ex);
+        }
+      }),
+    );
+
+    switch (errors.length) {
+      case 0:
+        break;
+      case 1:
+        throw errors[0];
+      default:
+        throw new AggregateError(errors);
+    }
+  }
+
+  public async clear(options: ClearOptions = {}): Promise<void> {
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    const { ac, ioMux } = this.#con;
+    const { signal, context } = (function parseClearArguments(ctx) {
+      const { signal, context } = options;
+
+      return {
+        signal: combineSignals([signal, ac.signal]),
+        context: mergeContext(ctx, context),
+      };
+    })(this.#context);
+
+    using _lock = await asyncmux.readonly(this, signal);
+
+    if (!this.#con) {
+      throw new Error();
+    }
+
+    context["unikvs:action"] = "clear";
+
+    await using _close = await this.#open(signal, context);
+
+    const errors: unknown[] = [];
+    using _ioLock = await ioMux.lock({ signal });
+    await Promise.all(
+      this.#destinations.map(async (storage) => {
+        try {
+          await storage.clear(signal, context);
+        } catch (ex) {
+          errors.push(ex);
+        }
+      }),
+    );
+
+    switch (errors.length) {
+      case 0:
+        break;
+      case 1:
+        throw errors[0];
+      default:
+        throw new AggregateError(errors);
+    }
+  }
+}