@compforge/harness-toolbox 0.4.2 → 0.4.4

package/dist/chunk-ajhdd4hp.js

@@ -1,267 +0,0 @@
-// src/redis/client.ts
-import { createClient } from "@redis/client";
-function stringValue(value) {
-  if (Buffer.isBuffer(value))
-    return value.toString("utf8");
-  return String(value ?? "");
-}
-function scalar(value) {
-  if (/^-?(?:\d+|\d+\.\d+)$/.test(value))
-    return Number(value);
-  return value;
-}
-function parseRedisInfo(raw) {
-  const result = {};
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line || line.startsWith("#"))
-      continue;
-    const separator = line.indexOf(":");
-    if (separator < 1)
-      continue;
-    const name = line.slice(0, separator);
-    const value = line.slice(separator + 1);
-    if (/^db\d+$/.test(name)) {
-      result[name] = Object.fromEntries(value.split(",").map((item) => {
-        const index = item.indexOf("=");
-        return [item.slice(0, index), scalar(item.slice(index + 1))];
-      }));
-    } else {
-      result[name] = scalar(value);
-    }
-  }
-  return result;
-}
-
-class RedisConnection {
-  endpoint;
-  client;
-  timeoutMs;
-  lastError;
-  constructor(endpoint, client, timeoutMs, lastError) {
-    this.endpoint = endpoint;
-    this.client = client;
-    this.timeoutMs = timeoutMs;
-    this.lastError = lastError;
-  }
-  static async connect(endpoint, mapped, config, clientFactory = createClient) {
-    const baseSocket = {
-      host: mapped.host,
-      port: mapped.port,
-      connectTimeout: config.timeoutMs,
-      reconnectStrategy: (retries) => retries >= 2 ? false : 100 * 2 ** retries
-    };
-    const socket = config.useSsl ? {
-      ...baseSocket,
-      tls: true,
-      servername: mapped.servername ?? endpoint.host
-    } : {
-      ...baseSocket,
-      tls: false
-    };
-    const client = clientFactory({
-      socket,
-      database: config.database,
-      username: config.username,
-      password: config.password,
-      commandOptions: { timeout: config.timeoutMs }
-    });
-    let lastError;
-    client.on("error", (err) => {
-      lastError = err instanceof Error ? err : new Error(String(err));
-    });
-    try {
-      await client.connect();
-    } catch (error) {
-      if (client.isOpen)
-        client.destroy();
-      throw error;
-    }
-    return new RedisConnection(endpoint, client, config.timeoutMs, () => lastError);
-  }
-  get isReady() {
-    return this.client.isReady;
-  }
-  async#execute(operationName, operation) {
-    try {
-      return await this.#executeOnce(operationName, operation);
-    } catch (err) {
-      if (this.client.isOpen && !this.client.isReady)
-        return this.#executeOnce(operationName, operation);
-      throw err;
-    }
-  }
-  async#executeOnce(operationName, operation) {
-    if (!this.client.isOpen) {
-      const reason = this.lastError()?.message;
-      throw new Error(`Redis connection is closed${reason ? `: ${reason}` : ""}`);
-    }
-    let timer;
-    const deadline = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        reject(new Error(`Redis ${operationName} timed out after ${this.timeoutMs}ms (${this.endpoint.host}:${this.endpoint.port})`));
-        this.close();
-      }, this.timeoutMs);
-    });
-    try {
-      return await Promise.race([Promise.resolve().then(operation), deadline]);
-    } finally {
-      if (timer)
-        clearTimeout(timer);
-    }
-  }
-  ping() {
-    return this.#execute("PING", () => this.client.ping());
-  }
-  async info(section) {
-    const raw = await this.#execute(section ? `INFO ${section}` : "INFO", () => section ? this.client.sendCommand(["INFO", section]) : this.client.sendCommand(["INFO"]));
-    return parseRedisInfo(stringValue(raw));
-  }
-  async dbSize() {
-    return Number(await this.#execute("DBSIZE", () => this.client.sendCommand(["DBSIZE"])));
-  }
-  command(args) {
-    return this.#execute(args[0]?.toUpperCase() ?? "command", () => this.client.sendCommand(args));
-  }
-  async pipeline(commands) {
-    const commandNames = new Set(commands.map((command) => command[0]?.toUpperCase()).filter(Boolean));
-    const operationName = commandNames.size === 1 ? `${[...commandNames][0]} pipeline` : "pipeline";
-    return await this.#execute(operationName, () => {
-      const pipeline = this.client.multi();
-      for (const command of commands)
-        pipeline.addCommand(command);
-      return pipeline.execAsPipeline();
-    });
-  }
-  async scan(cursor, count) {
-    const reply = await this.command(["SCAN", cursor, "COUNT", String(count)]);
-    if (!Array.isArray(reply) || !Array.isArray(reply[1]))
-      throw new Error("Redis SCAN 返回格式无效");
-    return { cursor: stringValue(reply[0]), keys: reply[1].map(stringValue) };
-  }
-  close() {
-    if (this.client.isOpen)
-      this.client.destroy();
-  }
-}
-
-class RedisAccess {
-  transport;
-  baseConfig;
-  connectionFactory;
-  #connections = new Map;
-  #closing;
-  constructor(transport, baseConfig, connectionFactory = RedisConnection.connect) {
-    this.transport = transport;
-    this.baseConfig = baseConfig;
-    this.connectionFactory = connectionFactory;
-  }
-  async connection(endpoint, database, credentials = this.baseConfig) {
-    if (this.#closing)
-      throw new Error("Redis access is closed");
-    const key = [
-      endpoint.host,
-      endpoint.port,
-      database,
-      credentials.username ?? "",
-      credentials.password ?? ""
-    ].join("\x00");
-    let pending = this.#connections.get(key);
-    if (pending) {
-      const connection = await pending;
-      if (this.#closing)
-        throw new Error("Redis access is closed");
-      if (connection.isReady)
-        return connection;
-      if (this.#connections.get(key) === pending) {
-        this.#connections.delete(key);
-        connection.close();
-      } else {
-        return this.connection(endpoint, database, credentials);
-      }
-    }
-    pending = this.transport.connect(endpoint).then((mapped) => this.connectionFactory(endpoint, mapped, {
-      ...this.baseConfig,
-      ...credentials,
-      database
-    }));
-    this.#connections.set(key, pending);
-    pending.catch(() => {
-      if (this.#connections.get(key) === pending)
-        this.#connections.delete(key);
-    });
-    return await pending;
-  }
-  close() {
-    return this.#closing ??= (async () => {
-      const settled = await Promise.allSettled(this.#connections.values());
-      this.#connections.clear();
-      const errors = [];
-      for (const result of settled)
-        if (result.status === "fulfilled") {
-          try {
-            result.value.close();
-          } catch (error) {
-            errors.push(error);
-          }
-        }
-      if (errors.length)
-        throw new AggregateError(errors, "Redis connection cleanup failed");
-    })();
-  }
-}
-
-class RedisClient {
-  source;
-  #controller = new AbortController;
-  signal;
-  #initialization;
-  #disposal;
-  #access;
-  #target;
-  constructor(source, lifecycle = {}) {
-    this.source = source;
-    this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
-  }
-  initialize() {
-    this.signal.throwIfAborted();
-    return this.#initialization ??= (async () => {
-      this.#target = await this.source.resolve();
-      this.signal.throwIfAborted();
-      const transport = this.source.transports[0];
-      if (!transport || transport.kind !== "tcp")
-        throw new Error("Redis requires a TCP transport");
-      this.#access = new RedisAccess(transport, this.#target);
-    })();
-  }
-  get access() {
-    this.signal.throwIfAborted();
-    if (!this.#access)
-      throw new Error("Redis client is not initialized");
-    return this.#access;
-  }
-  get target() {
-    if (!this.#target)
-      throw new Error("Redis client is not initialized");
-    return this.#target;
-  }
-  dispose() {
-    return this.#disposal ??= (async () => {
-      this.#controller.abort(new Error("Redis client disposed"));
-      await this.#initialization?.catch(() => {});
-      await this.#access?.close();
-    })();
-  }
-}
-async function openRedis(source, lifecycle = {}) {
-  const client = new RedisClient(source, lifecycle);
-  try {
-    await client.initialize();
-  } catch (error) {
-    await client.dispose();
-    throw error;
-  }
-  lifecycle.onDispose?.(() => client.dispose());
-  return client;
-}
-
-export { parseRedisInfo, RedisConnection, RedisAccess, RedisClient, openRedis };