@buenojs/bueno 0.8.3 → 0.8.5

package/dist/lock/index.js

@@ -0,0 +1,367 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/lock/index.ts
+var sharedLockStore = new Map;
+var cleanupInterval = null;
+function ensureCleanup() {
+  if (!cleanupInterval) {
+    cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, lock] of sharedLockStore.entries()) {
+        if (now >= lock.expiresAt) {
+          sharedLockStore.delete(key);
+        }
+      }
+    }, 1e4);
+  }
+}
+
+class MemoryLockDriver {
+  constructor() {
+    ensureCleanup();
+  }
+  async acquire(key, value, ttl) {
+    const now = Date.now();
+    const existing = sharedLockStore.get(key);
+    if (existing && now < existing.expiresAt) {
+      return false;
+    }
+    sharedLockStore.set(key, {
+      value,
+      expiresAt: now + ttl
+    });
+    return true;
+  }
+  async release(key, value) {
+    const lock = sharedLockStore.get(key);
+    if (lock && lock.value === value) {
+      sharedLockStore.delete(key);
+      return true;
+    }
+    return false;
+  }
+  async extend(key, value, ttl) {
+    const lock = sharedLockStore.get(key);
+    if (lock && lock.value === value) {
+      const now = Date.now();
+      if (now >= lock.expiresAt) {
+        return false;
+      }
+      lock.expiresAt = now + ttl;
+      return true;
+    }
+    return false;
+  }
+  async isValid(key, value) {
+    const lock = sharedLockStore.get(key);
+    const now = Date.now();
+    return lock !== undefined && lock.value === value && now < lock.expiresAt;
+  }
+  async getTTL(key, value) {
+    const lock = sharedLockStore.get(key);
+    const now = Date.now();
+    if (!lock || lock.value !== value) {
+      return -1;
+    }
+    const remaining = lock.expiresAt - now;
+    return remaining > 0 ? remaining : -1;
+  }
+  destroy() {}
+}
+
+class RedisLockDriver {
+  client = null;
+  url;
+  _isConnected = false;
+  releaseScript = `
+    if redis.call("get", KEYS[1]) == ARGV[1] then
+      return redis.call("del", KEYS[1])
+    else
+      return 0
+    end
+  `;
+  extendScript = `
+    if redis.call("get", KEYS[1]) == ARGV[1] then
+      return redis.call("pexpire", KEYS[1], ARGV[2])
+    else
+      return 0
+    end
+  `;
+  constructor(url) {
+    this.url = url;
+  }
+  async connect() {
+    try {
+      const { RedisClient } = await Promise.resolve(globalThis.Bun);
+      this.client = new RedisClient(this.url);
+      this._isConnected = true;
+    } catch (error) {
+      throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async disconnect() {
+    const client = this.client;
+    if (client?.close) {
+      await client.close();
+    }
+    this._isConnected = false;
+    this.client = null;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  async acquire(key, value, ttl) {
+    const client = this.client;
+    const result = await client.set(key, value, { nx: true, px: ttl });
+    return result === "OK";
+  }
+  async release(key, value) {
+    const client = this.client;
+    const result = await client.eval(this.releaseScript, [key], [value]);
+    return result === 1;
+  }
+  async extend(key, value, ttl) {
+    const client = this.client;
+    const result = await client.eval(this.extendScript, [key], [value, String(ttl)]);
+    return result === 1;
+  }
+  async isValid(key, value) {
+    const client = this.client;
+    const stored = await client.get(key);
+    return stored === value;
+  }
+  async getTTL(key, value) {
+    const client = this.client;
+    const stored = await client.get(key);
+    if (stored !== value) {
+      return -1;
+    }
+    return client.pttl(key);
+  }
+}
+
+class DistributedLock {
+  driver;
+  driverType;
+  keyPrefix;
+  defaultTTL;
+  defaultRetryCount;
+  defaultRetryDelay;
+  _isConnected = false;
+  constructor(config = {}) {
+    this.driverType = config.driver ?? "memory";
+    this.keyPrefix = config.keyPrefix ?? "lock:";
+    this.defaultTTL = config.defaultTTL ?? 30000;
+    this.defaultRetryCount = config.retryCount ?? 3;
+    this.defaultRetryDelay = config.retryDelay ?? 200;
+    if (this.driverType === "redis" && config.url) {
+      this.driver = new RedisLockDriver(config.url);
+    } else {
+      this.driver = new MemoryLockDriver;
+      this._isConnected = true;
+    }
+  }
+  async connect() {
+    if (this.driver instanceof RedisLockDriver) {
+      await this.driver.connect();
+    }
+    this._isConnected = true;
+  }
+  async disconnect() {
+    if (this.driver instanceof RedisLockDriver) {
+      await this.driver.disconnect();
+    } else {
+      this.driver.destroy();
+    }
+    this._isConnected = false;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  getDriverType() {
+    return this.driverType;
+  }
+  generateLockValue() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  async tryAcquire(key, value, ttl) {
+    return this.driver.acquire(key, value, ttl);
+  }
+  async acquire(key, options = {}) {
+    const fullKey = this.keyPrefix + key;
+    const ttl = options.ttl ?? this.defaultTTL;
+    const retryCount = options.retryCount ?? this.defaultRetryCount;
+    const retryDelay = options.retryDelay ?? this.defaultRetryDelay;
+    const value = this.generateLockValue();
+    let acquired = false;
+    let attempts = 0;
+    while (!acquired && attempts <= retryCount) {
+      acquired = await this.tryAcquire(fullKey, value, ttl);
+      if (!acquired && attempts < retryCount) {
+        await this.sleep(retryDelay);
+      }
+      attempts++;
+    }
+    const acquiredAt = Date.now();
+    return {
+      acquired,
+      key: fullKey,
+      value,
+      release: async () => {
+        if (!acquired)
+          return false;
+        return this.driver.release(fullKey, value);
+      },
+      extend: async (newTTL) => {
+        if (!acquired)
+          return false;
+        return this.driver.extend(fullKey, value, newTTL ?? ttl);
+      },
+      isValid: async () => {
+        if (!acquired)
+          return false;
+        return this.driver.isValid(fullKey, value);
+      },
+      getRemainingTTL: async () => {
+        if (!acquired)
+          return -1;
+        return this.driver.getTTL(fullKey, value);
+      }
+    };
+  }
+  async withLock(key, fn, options = {}) {
+    const lock = await this.acquire(key, options);
+    if (!lock.acquired) {
+      throw new LockAcquireError(`Failed to acquire lock: ${key}`);
+    }
+    try {
+      return await fn(lock);
+    } finally {
+      await lock.release();
+    }
+  }
+  async withAutoExtend(key, fn, options = {}) {
+    const lock = await this.acquire(key, options);
+    if (!lock.acquired) {
+      throw new LockAcquireError(`Failed to acquire lock: ${key}`);
+    }
+    const ttl = options.ttl ?? this.defaultTTL;
+    const extendInterval = ttl * 0.7;
+    let extendTimer = null;
+    let completed = false;
+    extendTimer = setInterval(async () => {
+      if (!completed) {
+        const remaining = await lock.getRemainingTTL();
+        if (remaining > 0 && remaining < extendInterval) {
+          await lock.extend(ttl);
+        }
+      }
+    }, extendInterval);
+    try {
+      const result = await fn(lock);
+      completed = true;
+      return result;
+    } finally {
+      if (extendTimer) {
+        clearInterval(extendTimer);
+      }
+      await lock.release();
+    }
+  }
+  async tryLock(key, options = {}) {
+    return this.acquire(key, { ...options, retryCount: 0 });
+  }
+  async isLocked(key) {
+    const fullKey = this.keyPrefix + key;
+    const value = this.generateLockValue();
+    const acquired = await this.driver.acquire(fullKey, value, 1);
+    if (acquired) {
+      await this.driver.release(fullKey, value);
+      return false;
+    }
+    return true;
+  }
+  async forceRelease(key) {
+    const fullKey = this.keyPrefix + key;
+    const value = this.generateLockValue();
+    await this.driver.release(fullKey, value);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+class LockAcquireError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockAcquireError";
+  }
+}
+
+class LockTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockTimeoutError";
+  }
+}
+function createDistributedLock(config) {
+  return new DistributedLock(config);
+}
+function createRedisLock(url, options) {
+  return new DistributedLock({ driver: "redis", url, ...options });
+}
+function createMemoryLock() {
+  return new DistributedLock({ driver: "memory" });
+}
+var defaultLock = null;
+function getDefaultLock() {
+  if (!defaultLock) {
+    defaultLock = new DistributedLock({ driver: "memory" });
+  }
+  return defaultLock;
+}
+function setDefaultLock(lock) {
+  defaultLock = lock;
+}
+async function lock(key, fn, options) {
+  return getDefaultLock().withLock(key, async () => fn(), options);
+}
+export {
+  setDefaultLock,
+  lock,
+  getDefaultLock,
+  createRedisLock,
+  createMemoryLock,
+  createDistributedLock,
+  LockTimeoutError,
+  LockAcquireError,
+  DistributedLock
+};

package/dist/logger/index.js

@@ -0,0 +1,281 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/logger/index.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4
+};
+
+class Logger {
+  level;
+  pretty;
+  timestamp;
+  context;
+  output;
+  constructor(config = {}) {
+    this.level = config.level ?? "info";
+    this.pretty = config.pretty ?? true;
+    this.timestamp = config.timestamp ?? true;
+    this.context = config.context ?? {};
+    if (typeof config.output === "function") {
+      this.output = config.output;
+    } else if (config.output === "stdout") {
+      this.output = (entry) => console.log(this.serialize(entry));
+    } else {
+      this.output = (entry) => {
+        if (this.pretty) {
+          this.prettyPrint(entry);
+        } else {
+          console.log(this.serialize(entry));
+        }
+      };
+    }
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  serialize(entry) {
+    return JSON.stringify(entry);
+  }
+  prettyPrint(entry) {
+    const timestamp = entry.timestamp;
+    const levelColors = {
+      debug: "\x1B[36m",
+      info: "\x1B[32m",
+      warn: "\x1B[33m",
+      error: "\x1B[31m",
+      fatal: "\x1B[35m"
+    };
+    const reset = "\x1B[0m";
+    const color = levelColors[entry.level];
+    let output = `${timestamp} ${color}[${entry.level.toUpperCase()}]${reset} ${entry.message}`;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      output += ` ${reset}\x1B[90m${JSON.stringify(entry.context)}\x1B[0m`;
+    }
+    if (entry.duration !== undefined) {
+      output += ` \x1B[90m(${entry.duration}ms)\x1B[0m`;
+    }
+    if (entry.error) {
+      output += `
+  \x1B[31m${entry.error.name}: ${entry.error.message}\x1B[0m`;
+      if (entry.error.stack) {
+        output += `
+  \x1B[90m${entry.error.stack}\x1B[0m`;
+      }
+    }
+    switch (entry.level) {
+      case "error":
+      case "fatal":
+        console.error(output);
+        break;
+      case "warn":
+        console.warn(output);
+        break;
+      default:
+        console.log(output);
+    }
+  }
+  createEntry(level, message, context, error) {
+    const entry = {
+      level,
+      message,
+      timestamp: this.timestamp ? new Date().toISOString() : "",
+      ...this.context
+    };
+    if (context) {
+      entry.context = context;
+    }
+    if (error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return entry;
+  }
+  debug(message, context) {
+    if (!this.shouldLog("debug"))
+      return;
+    this.output(this.createEntry("debug", message, context));
+  }
+  info(message, context) {
+    if (!this.shouldLog("info"))
+      return;
+    this.output(this.createEntry("info", message, context));
+  }
+  warn(message, context) {
+    if (!this.shouldLog("warn"))
+      return;
+    this.output(this.createEntry("warn", message, context));
+  }
+  error(message, error, context) {
+    if (!this.shouldLog("error"))
+      return;
+    const err = error instanceof Error ? error : undefined;
+    this.output(this.createEntry("error", message, context, err));
+  }
+  fatal(message, error, context) {
+    if (!this.shouldLog("fatal"))
+      return;
+    const err = error instanceof Error ? error : undefined;
+    this.output(this.createEntry("fatal", message, context, err));
+  }
+  child(context) {
+    return new Logger({
+      level: this.level,
+      pretty: this.pretty,
+      timestamp: this.timestamp,
+      context: { ...this.context, ...context },
+      output: this.output
+    });
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  addContext(context) {
+    Object.assign(this.context, context);
+  }
+  async time(label, fn) {
+    const start = Date.now();
+    try {
+      const result = await fn();
+      this.debug(`${label} completed`, { duration: Date.now() - start });
+      return result;
+    } catch (error) {
+      this.error(`${label} failed`, error, { duration: Date.now() - start });
+      throw error;
+    }
+  }
+  startTimer(label) {
+    const start = Date.now();
+    return () => {
+      const duration = Date.now() - start;
+      this.debug(`${label}`, { duration });
+      return duration;
+    };
+  }
+}
+function createRequestLogger(logger) {
+  return async (ctx, next) => {
+    const context = ctx;
+    const start = Date.now();
+    const requestId = context.getHeader("x-request-id") || crypto.randomUUID();
+    context.set("requestId", requestId);
+    const requestContext = {
+      requestId,
+      method: context.method,
+      path: context.path,
+      query: context.url?.search,
+      ip: context.ip,
+      userAgent: context.getHeader("user-agent")
+    };
+    logger.info("Request started", requestContext);
+    try {
+      const response = await next();
+      const duration = Date.now() - start;
+      const responseContext = {
+        ...requestContext,
+        statusCode: response?.status ?? 200,
+        duration
+      };
+      logger.info("Request completed", responseContext);
+      return response;
+    } catch (error) {
+      const duration = Date.now() - start;
+      logger.error("Request failed", error, {
+        ...requestContext,
+        duration
+      });
+      throw error;
+    }
+  };
+}
+
+class PerformanceLogger {
+  logger;
+  metrics = new Map;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  record(name, value) {
+    if (!this.metrics.has(name)) {
+      this.metrics.set(name, []);
+    }
+    this.metrics.get(name)?.push(value);
+  }
+  stats(name) {
+    const values = this.metrics.get(name);
+    if (!values || values.length === 0)
+      return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const count = sorted.length;
+    const min = sorted[0];
+    const max = sorted[count - 1];
+    const avg = sorted.reduce((a, b) => a + b, 0) / count;
+    const p99Index = Math.floor(count * 0.99);
+    const p99 = sorted[p99Index];
+    return { count, min, max, avg, p99 };
+  }
+  logMetrics() {
+    for (const [name] of this.metrics) {
+      const stats = this.stats(name);
+      if (stats) {
+        this.logger.info(`Metric: ${name}`, stats);
+      }
+    }
+  }
+  clear() {
+    this.metrics.clear();
+  }
+}
+var defaultLogger = null;
+function getLogger() {
+  if (!defaultLogger) {
+    defaultLogger = new Logger;
+  }
+  return defaultLogger;
+}
+function setLogger(logger) {
+  defaultLogger = logger;
+}
+function createLogger(config) {
+  return new Logger(config);
+}
+export {
+  setLogger,
+  getLogger,
+  createRequestLogger,
+  createLogger,
+  PerformanceLogger,
+  Logger
+};