@buenojs/bueno 0.8.3 → 0.8.5

package/dist/health/index.js

@@ -0,0 +1,364 @@
+// @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/health/index.ts
+class HealthCheckManager {
+  checks = new Map;
+  startTime = Date.now();
+  version;
+  constructor(version) {
+    this.version = version ?? "0.1.0";
+  }
+  registerCheck(name, checkFn, options = {}) {
+    this.checks.set(name, {
+      name,
+      fn: checkFn,
+      options: {
+        critical: options.critical ?? true,
+        timeout: options.timeout ?? 5000,
+        description: options.description ?? ""
+      }
+    });
+    return this;
+  }
+  removeCheck(name) {
+    return this.checks.delete(name);
+  }
+  getCheckNames() {
+    return Array.from(this.checks.keys());
+  }
+  hasCheck(name) {
+    return this.checks.has(name);
+  }
+  async runSingleCheck(check) {
+    const start = Date.now();
+    try {
+      const result = await Promise.race([
+        check.fn(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Check timed out after ${check.options.timeout}ms`)), check.options.timeout))
+      ]);
+      return {
+        ...result,
+        latency: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: error instanceof Error ? error.message : "Check failed"
+      };
+    }
+  }
+  async runChecks() {
+    const results = {};
+    const entries = Array.from(this.checks.values());
+    const outcomes = await Promise.all(entries.map(async (check) => ({
+      name: check.name,
+      result: await this.runSingleCheck(check),
+      critical: check.options.critical
+    })));
+    for (const { name, result } of outcomes) {
+      results[name] = result;
+    }
+    return results;
+  }
+  getHealth() {
+    return {
+      status: "healthy",
+      timestamp: new Date().toISOString(),
+      version: this.version,
+      uptime: Math.floor((Date.now() - this.startTime) / 1000)
+    };
+  }
+  async getReadiness() {
+    const checks = await this.runChecks();
+    let status = "healthy";
+    let hasUnhealthyCritical = false;
+    let hasUnhealthyNonCritical = false;
+    let hasDegraded = false;
+    const entries = Array.from(this.checks.values());
+    for (const entry of entries) {
+      const checkResult = checks[entry.name];
+      if (checkResult) {
+        if (entry.options.critical && checkResult.status === "unhealthy") {
+          hasUnhealthyCritical = true;
+        }
+        if (!entry.options.critical && checkResult.status === "unhealthy") {
+          hasUnhealthyNonCritical = true;
+        }
+        if (checkResult.status === "degraded") {
+          hasDegraded = true;
+        }
+      }
+    }
+    if (hasUnhealthyCritical) {
+      status = "unhealthy";
+    } else if (hasUnhealthyNonCritical || hasDegraded) {
+      status = "degraded";
+    }
+    return {
+      status,
+      timestamp: new Date().toISOString(),
+      version: this.version,
+      uptime: Math.floor((Date.now() - this.startTime) / 1000),
+      checks
+    };
+  }
+  getUptime() {
+    return Math.floor((Date.now() - this.startTime) / 1000);
+  }
+  resetStartTime() {
+    this.startTime = Date.now();
+  }
+}
+function createHealthMiddleware(options = {}) {
+  const {
+    healthPath = "/health",
+    readyPath = "/ready",
+    exposeMetrics = true,
+    checks = {},
+    version
+  } = options;
+  const manager = new HealthCheckManager(version);
+  for (const [name, check] of Object.entries(checks)) {
+    if (typeof check === "function") {
+      manager.registerCheck(name, check);
+    } else {
+      manager.registerCheck(name, check.fn, check.options);
+    }
+  }
+  const middleware = async (context, next) => {
+    const path = context.path;
+    if (path === healthPath && context.method === "GET") {
+      const health = manager.getHealth();
+      return context.json(health);
+    }
+    if (path === readyPath && context.method === "GET") {
+      const readiness = await manager.getReadiness();
+      if (readiness.status === "unhealthy") {
+        context.status(503);
+      } else if (readiness.status === "degraded") {
+        context.status(200);
+      }
+      const response = exposeMetrics ? readiness : { status: readiness.status, timestamp: readiness.timestamp };
+      return context.json(response);
+    }
+    return next();
+  };
+  return { middleware, manager };
+}
+function createDatabaseCheck(db, options = {}) {
+  const { query = "SELECT 1" } = options;
+  return async () => {
+    const start = Date.now();
+    try {
+      if (typeof db.healthCheck === "function") {
+        const isHealthy = await db.healthCheck();
+        return {
+          status: isHealthy ? "healthy" : "unhealthy",
+          latency: Date.now() - start,
+          message: isHealthy ? "Database connection OK" : "Database health check failed"
+        };
+      }
+      if (typeof db.query === "function") {
+        await db.query(query);
+        return {
+          status: "healthy",
+          latency: Date.now() - start,
+          message: "Database connection OK"
+        };
+      }
+      if (typeof db.execute === "function") {
+        await db.execute(query);
+        return {
+          status: "healthy",
+          latency: Date.now() - start,
+          message: "Database connection OK"
+        };
+      }
+      return {
+        status: "degraded",
+        latency: Date.now() - start,
+        message: "No compatible database method found"
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: error instanceof Error ? error.message : "Database check failed"
+      };
+    }
+  };
+}
+function createCacheCheck(cache, options = {}) {
+  const { testKey = "__health_check__" } = options;
+  return async () => {
+    const start = Date.now();
+    try {
+      if (typeof cache.healthCheck === "function") {
+        const isHealthy = await cache.healthCheck();
+        return {
+          status: isHealthy ? "healthy" : "unhealthy",
+          latency: Date.now() - start,
+          message: isHealthy ? "Cache connection OK" : "Cache health check failed"
+        };
+      }
+      if (typeof cache.ping === "function") {
+        await cache.ping();
+        return {
+          status: "healthy",
+          latency: Date.now() - start,
+          message: "Cache ping OK"
+        };
+      }
+      if (typeof cache.set === "function" && typeof cache.get === "function") {
+        const testValue = Date.now().toString();
+        await cache.set(testKey, testValue);
+        const retrieved = await cache.get(testKey);
+        if (retrieved === testValue || retrieved?.toString() === testValue) {
+          return {
+            status: "healthy",
+            latency: Date.now() - start,
+            message: "Cache read/write OK"
+          };
+        }
+        return {
+          status: "degraded",
+          latency: Date.now() - start,
+          message: "Cache read/write mismatch"
+        };
+      }
+      return {
+        status: "degraded",
+        latency: Date.now() - start,
+        message: "No compatible cache method found"
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: error instanceof Error ? error.message : "Cache check failed"
+      };
+    }
+  };
+}
+function createCustomCheck(checkFn, options = {}) {
+  const { message = "Custom check" } = options;
+  return async () => {
+    const start = Date.now();
+    try {
+      const result = await checkFn();
+      return {
+        status: result ? "healthy" : "unhealthy",
+        latency: Date.now() - start,
+        message: result ? `${message} OK` : `${message} failed`
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: error instanceof Error ? error.message : `${message} failed`
+      };
+    }
+  };
+}
+function createTCPCheck(host, port, options = {}) {
+  const { timeout = 5000 } = options;
+  return async () => {
+    const start = Date.now();
+    try {
+      const socket = await Bun.connect({
+        hostname: host,
+        port,
+        socket: {
+          data() {},
+          error() {}
+        }
+      });
+      socket.end();
+      return {
+        status: "healthy",
+        latency: Date.now() - start,
+        message: `TCP ${host}:${port} reachable`
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: `TCP ${host}:${port} unreachable: ${error instanceof Error ? error.message : "unknown error"}`
+      };
+    }
+  };
+}
+function createHTTPCheck(url, options = {}) {
+  const { expectedStatus = 200, timeout = 5000, headers = {} } = options;
+  return async () => {
+    const start = Date.now();
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === expectedStatus) {
+        return {
+          status: "healthy",
+          latency: Date.now() - start,
+          message: `HTTP ${url} returned ${response.status}`
+        };
+      }
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: `HTTP ${url} returned ${response.status}, expected ${expectedStatus}`
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        latency: Date.now() - start,
+        message: `HTTP ${url} failed: ${error instanceof Error ? error.message : "unknown error"}`
+      };
+    }
+  };
+}
+function createHealthManager(version) {
+  return new HealthCheckManager(version);
+}
+export {
+  createTCPCheck,
+  createHealthMiddleware,
+  createHealthManager,
+  createHTTPCheck,
+  createDatabaseCheck,
+  createCustomCheck,
+  createCacheCheck,
+  HealthCheckManager
+};

package/dist/i18n/index.js

@@ -0,0 +1,345 @@
+// @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/i18n/loader.ts
+import { existsSync, readFileSync, watch } from "fs";
+import { join, resolve } from "path";
+function flattenTranslations(obj, prefix = "", result = new Map) {
+  for (const [key, value] of Object.entries(obj)) {
+    const dotKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      flattenTranslations(value, dotKey, result);
+    } else {
+      result.set(dotKey, String(value ?? ""));
+    }
+  }
+  return result;
+}
+
+class TranslationLoader {
+  cache = new Map;
+  watchers = new Map;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  load(locale) {
+    const cached = this.cache.get(locale);
+    if (cached)
+      return cached;
+    return this._loadFromDisk(locale);
+  }
+  preload() {
+    for (const locale of this.config.supportedLocales) {
+      try {
+        this._loadFromDisk(locale);
+      } catch {
+        if (locale !== this.config.defaultLocale) {
+          this.cache.set(locale, {
+            locale,
+            translations: new Map,
+            loadedAt: Date.now()
+          });
+        }
+      }
+    }
+  }
+  invalidate(locale) {
+    this.cache.delete(locale);
+  }
+  loadedLocales() {
+    return Array.from(this.cache.keys());
+  }
+  watch(locale) {
+    const filePath = this._resolvePath(locale);
+    if (!existsSync(filePath))
+      return;
+    if (this.watchers.has(locale))
+      return;
+    const watcher = watch(filePath, () => {
+      this.invalidate(locale);
+      try {
+        this._loadFromDisk(locale);
+      } catch {}
+    });
+    this.watchers.set(locale, watcher);
+  }
+  stopWatching() {
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+  }
+  _resolvePath(locale) {
+    return resolve(join(this.config.basePath, `${locale}.json`));
+  }
+  _loadFromDisk(locale) {
+    const filePath = this._resolvePath(locale);
+    if (!existsSync(filePath)) {
+      if (locale === this.config.defaultLocale) {
+        throw new Error(`[i18n] Default locale file not found: ${filePath}. ` + `Create ${locale}.json in ${this.config.basePath}`);
+      }
+      const empty = {
+        locale,
+        translations: new Map,
+        loadedAt: Date.now()
+      };
+      this.cache.set(locale, empty);
+      return empty;
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(`[i18n] Failed to parse locale file ${filePath}: ${String(err)}`);
+    }
+    const bundle = {
+      locale,
+      translations: flattenTranslations(parsed),
+      loadedAt: Date.now()
+    };
+    this.cache.set(locale, bundle);
+    return bundle;
+  }
+}
+
+// src/i18n/negotiator.ts
+function parseAcceptLanguage(header) {
+  if (!header.trim())
+    return [];
+  return header.split(",").map((part) => {
+    const [localeRaw, qRaw] = part.trim().split(";");
+    const locale = localeRaw?.trim() ?? "";
+    const quality = qRaw ? Number.parseFloat(qRaw.trim().replace("q=", "")) : 1;
+    return { locale, quality: isNaN(quality) ? 1 : quality };
+  }).filter((e) => e.locale.length > 0).sort((a, b) => b.quality - a.quality);
+}
+function normaliseLocale(locale) {
+  const parts = locale.replace("_", "-").split("-");
+  if (parts.length === 0)
+    return locale;
+  const lang = parts[0].toLowerCase();
+  if (parts.length === 1)
+    return lang;
+  const region = parts[1].toUpperCase();
+  return `${lang}-${region}`;
+}
+function languageSubtag(locale) {
+  return locale.split("-")[0].toLowerCase();
+}
+
+class LocaleNegotiator {
+  supported;
+  defaultLocale;
+  constructor(supportedLocales, defaultLocale) {
+    this.supported = supportedLocales;
+    this.defaultLocale = defaultLocale;
+  }
+  negotiate(acceptLanguageHeader) {
+    const entries = parseAcceptLanguage(acceptLanguageHeader);
+    for (const entry of entries) {
+      const norm = normaliseLocale(entry.locale);
+      const exact = this.supported.find((s) => normaliseLocale(s) === norm);
+      if (exact) {
+        return { locale: exact, strategy: "exact", source: entry.locale };
+      }
+    }
+    for (const entry of entries) {
+      const lang = languageSubtag(entry.locale);
+      const prefix = this.supported.find((s) => languageSubtag(s) === lang);
+      if (prefix) {
+        return { locale: prefix, strategy: "prefix", source: entry.locale };
+      }
+    }
+    return {
+      locale: this.defaultLocale,
+      strategy: "default",
+      source: ""
+    };
+  }
+  isSupported(locale) {
+    return this.supported.includes(locale);
+  }
+}
+
+// src/i18n/engine.ts
+var DEFAULT_I18N_CONFIG = {
+  defaultLocale: "en",
+  supportedLocales: ["en"],
+  basePath: "resources/i18n",
+  fallbackToDefault: true,
+  cookieName: "bueno_locale",
+  cookieMaxAge: 31536000
+};
+function selectPluralKey(count, availableKeys, base) {
+  const candidates = count === 0 ? ["zero", "other"] : count === 1 ? ["one", "other"] : ["other"];
+  for (const form of candidates) {
+    const candidate = `${base}_${form}`;
+    if (availableKeys.has(candidate))
+      return candidate;
+  }
+  return base;
+}
+function interpolate(template, params) {
+  return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, key) => {
+    const val = params[key];
+    return val === undefined || val === null ? "" : String(val);
+  });
+}
+
+class I18n {
+  loader;
+  negotiator;
+  config;
+  metrics = {
+    totalLookups: 0,
+    hits: 0,
+    fallbacks: 0,
+    misses: 0,
+    loadedLocales: []
+  };
+  constructor(config = {}) {
+    this.config = {
+      defaultLocale: config.defaultLocale ?? DEFAULT_I18N_CONFIG.defaultLocale,
+      supportedLocales: config.supportedLocales ?? DEFAULT_I18N_CONFIG.supportedLocales,
+      basePath: config.basePath ?? DEFAULT_I18N_CONFIG.basePath,
+      fallbackToDefault: config.fallbackToDefault ?? DEFAULT_I18N_CONFIG.fallbackToDefault,
+      cookieName: config.cookieName ?? DEFAULT_I18N_CONFIG.cookieName,
+      cookieMaxAge: config.cookieMaxAge ?? DEFAULT_I18N_CONFIG.cookieMaxAge
+    };
+    this.loader = new TranslationLoader(this.config);
+    this.negotiator = new LocaleNegotiator(this.config.supportedLocales, this.config.defaultLocale);
+  }
+  preload() {
+    this.loader.preload();
+  }
+  watchAll() {
+    for (const locale of this.config.supportedLocales) {
+      this.loader.watch(locale);
+    }
+  }
+  stopWatching() {
+    this.loader.stopWatching();
+  }
+  createTranslator(locale) {
+    return (key, params) => {
+      return this.t(locale, key, params);
+    };
+  }
+  t(locale, key, params) {
+    this.metrics.totalLookups++;
+    const hasCount = params !== undefined && "count" in params && typeof params.count === "number";
+    const result = this._resolve(locale, key, params, hasCount);
+    if (result !== null) {
+      this.metrics.hits++;
+      return result;
+    }
+    if (this.config.fallbackToDefault && locale !== this.config.defaultLocale) {
+      const fallbackResult = this._resolve(this.config.defaultLocale, key, params, hasCount);
+      if (fallbackResult !== null) {
+        this.metrics.fallbacks++;
+        return fallbackResult;
+      }
+    }
+    this.metrics.misses++;
+    return key;
+  }
+  getNegotiator() {
+    return this.negotiator;
+  }
+  getMetrics() {
+    return {
+      ...this.metrics,
+      loadedLocales: this.loader.loadedLocales()
+    };
+  }
+  _resolve(locale, key, params, hasCount) {
+    const bundle = this.loader.load(locale);
+    const translations = bundle.translations;
+    const availableKeys = new Set(translations.keys());
+    let resolvedKey = key;
+    if (hasCount) {
+      resolvedKey = selectPluralKey(params.count, availableKeys, key);
+    }
+    const raw = translations.get(resolvedKey);
+    if (raw === undefined)
+      return null;
+    return params ? interpolate(raw, params) : raw;
+  }
+}
+function createI18n(config) {
+  return new I18n(config);
+}
+// src/i18n/middleware.ts
+function getLocale(ctx) {
+  return ctx.get("locale") ?? "en";
+}
+function getT(ctx) {
+  return ctx.get("t") ?? ((key) => key);
+}
+function i18nMiddleware(options = {}) {
+  const engine = options.i18n ?? createI18n(options);
+  const negotiator = engine.getNegotiator();
+  const cookieName = engine.config.cookieName;
+  const cookieMaxAge = engine.config.cookieMaxAge;
+  return async (ctx, next) => {
+    let locale;
+    const cookieLocale = ctx.getCookie(cookieName);
+    if (cookieLocale && negotiator.isSupported(cookieLocale)) {
+      locale = cookieLocale;
+    } else {
+      const acceptLanguage = ctx.getHeader("accept-language") ?? "";
+      if (acceptLanguage) {
+        const match = negotiator.negotiate(acceptLanguage);
+        locale = match.locale;
+      } else {
+        locale = engine.config.defaultLocale;
+      }
+    }
+    ctx.set("locale", locale);
+    ctx.set("t", engine.createTranslator(locale));
+    const response = await next();
+    const cookieValue = `${cookieName}=${locale}; Max-Age=${cookieMaxAge}; Path=/; SameSite=Lax`;
+    response.headers.append("Set-Cookie", cookieValue);
+    const existing = response.headers.get("Vary");
+    response.headers.set("Vary", existing ? `${existing}, Accept-Language` : "Accept-Language");
+    return response;
+  };
+}
+export {
+  parseAcceptLanguage,
+  normaliseLocale,
+  i18nMiddleware,
+  getT,
+  getLocale,
+  createI18n,
+  TranslationLoader,
+  LocaleNegotiator,
+  I18n
+};