@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/health/index.js

@@ -0,0 +1,379 @@
+// src/health/HealthCheck.ts
+var HealthCheck = class {
+  /**
+   * Create a healthy result.
+   */
+  healthy(message, meta) {
+    return this.result("healthy", message, meta);
+  }
+  /**
+   * Create a degraded result.
+   */
+  degraded(message, meta) {
+    return this.result("degraded", message, meta);
+  }
+  /**
+   * Create an unhealthy result.
+   */
+  unhealthy(message, meta) {
+    return this.result("unhealthy", message, meta);
+  }
+  /**
+   * Create an unhealthy result from a caught error.
+   */
+  handleError(error, fallbackMessage) {
+    return this.unhealthy(
+      error instanceof Error ? error.message : fallbackMessage
+    );
+  }
+  /**
+   * Create a check result.
+   */
+  result(status, message, meta) {
+    const result = {
+      name: this.name,
+      status,
+      duration: 0
+      // Will be set by HealthManager
+    };
+    if (message !== void 0) {
+      result.message = message;
+    }
+    if (meta !== void 0) {
+      result.meta = meta;
+    }
+    return result;
+  }
+};
+
+// src/health/HealthManager.ts
+var HealthManager = class {
+  checks = /* @__PURE__ */ new Map();
+  /**
+   * Register a health check.
+   */
+  register(check, options = {}) {
+    this.checks.set(check.name, {
+      check,
+      options: {
+        timeout: options.timeout ?? 5e3,
+        critical: options.critical ?? false
+      }
+    });
+    return this;
+  }
+  /**
+   * Unregister a health check.
+   */
+  unregister(name) {
+    this.checks.delete(name);
+    return this;
+  }
+  /**
+   * Get all registered check names.
+   */
+  getCheckNames() {
+    return Array.from(this.checks.keys());
+  }
+  /**
+   * Run all health checks.
+   */
+  async check() {
+    return this.runChecks(this.getCheckNames());
+  }
+  /**
+   * Run specific health checks.
+   */
+  async checkOnly(names) {
+    const validNames = names.filter((name) => this.checks.has(name));
+    return this.runChecks(validNames);
+  }
+  /**
+   * Get a specific check result.
+   */
+  async getCheck(name) {
+    const registered = this.checks.get(name);
+    if (!registered) {
+      return null;
+    }
+    return this.runCheck(registered);
+  }
+  /**
+   * Create middleware for health endpoints.
+   */
+  middleware(options = {}) {
+    return async (ctx, next) => {
+      const report = options.checks ? await this.checkOnly(options.checks) : await this.check();
+      const statusCode = report.status === "healthy" ? 200 : report.status === "degraded" ? 200 : 503;
+      if (options.detailed === false) {
+        ctx.status(statusCode);
+        ctx.json({
+          status: report.status,
+          timestamp: report.timestamp.toISOString()
+        });
+      } else {
+        ctx.status(statusCode);
+        ctx.json({
+          status: report.status,
+          timestamp: report.timestamp.toISOString(),
+          checks: report.checks.map((check) => ({
+            name: check.name,
+            status: check.status,
+            message: check.message,
+            duration: check.duration,
+            meta: check.meta
+          }))
+        });
+      }
+    };
+  }
+  /**
+   * Run the specified checks.
+   */
+  async runChecks(names) {
+    const results = [];
+    let overallStatus = "healthy";
+    await Promise.all(
+      names.map(async (name) => {
+        const registered = this.checks.get(name);
+        if (!registered) return;
+        const result = await this.runCheck(registered);
+        results.push(result);
+        if (result.status === "unhealthy") {
+          if (registered.options.critical) {
+            overallStatus = "unhealthy";
+          } else if (overallStatus !== "unhealthy") {
+            overallStatus = "degraded";
+          }
+        } else if (result.status === "degraded" && overallStatus === "healthy") {
+          overallStatus = "degraded";
+        }
+      })
+    );
+    results.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+      status: overallStatus,
+      timestamp: /* @__PURE__ */ new Date(),
+      checks: results
+    };
+  }
+  /**
+   * Run a single check with timeout.
+   */
+  async runCheck(registered) {
+    const { check, options } = registered;
+    const start = performance.now();
+    try {
+      const result = await Promise.race([
+        check.check(),
+        this.timeoutPromise(options.timeout)
+      ]);
+      result.duration = Math.round(performance.now() - start);
+      return result;
+    } catch (error) {
+      const duration = Math.round(performance.now() - start);
+      return {
+        name: check.name,
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : "Check failed with error",
+        duration
+      };
+    }
+  }
+  /**
+   * Create a timeout promise.
+   */
+  timeoutPromise(ms) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Health check timed out after ${ms}ms`));
+      }, ms);
+    });
+  }
+};
+function createHealthManager() {
+  return new HealthManager();
+}
+
+// src/health/checks/DatabaseCheck.ts
+var DatabaseCheck = class extends HealthCheck {
+  name;
+  db;
+  query;
+  constructor(db, options = {}) {
+    super();
+    this.db = db;
+    this.name = options.name ?? "database";
+    this.query = options.query ?? "SELECT 1";
+  }
+  async check() {
+    try {
+      await this.db.query(this.query);
+      return this.healthy("Database connection is healthy");
+    } catch (error) {
+      return this.handleError(error, "Database connection failed");
+    }
+  }
+};
+
+// src/health/checks/RedisCheck.ts
+var RedisCheck = class extends HealthCheck {
+  name;
+  redis;
+  constructor(redis, options = {}) {
+    super();
+    this.redis = redis;
+    this.name = options.name ?? "redis";
+  }
+  async check() {
+    try {
+      const response = await this.redis.ping();
+      if (response === "PONG") {
+        return this.healthy("Redis connection is healthy");
+      }
+      return this.degraded(`Redis ping returned: ${response}`);
+    } catch (error) {
+      return this.handleError(error, "Redis connection failed");
+    }
+  }
+};
+
+// src/health/checks/CacheCheck.ts
+var CacheCheck = class extends HealthCheck {
+  name;
+  cache;
+  testKey;
+  constructor(cache, options = {}) {
+    super();
+    this.cache = cache;
+    this.name = options.name ?? "cache";
+    this.testKey = options.testKey ?? "__health_check__";
+  }
+  async check() {
+    const testValue = `health_check_${Date.now()}`;
+    try {
+      await this.cache.put(this.testKey, testValue, 60);
+      const retrieved = await this.cache.get(this.testKey);
+      await this.cache.forget(this.testKey);
+      if (retrieved === testValue) {
+        return this.healthy("Cache is functioning correctly");
+      }
+      return this.degraded(
+        `Cache read/write mismatch: expected "${testValue}", got "${retrieved}"`
+      );
+    } catch (error) {
+      return this.handleError(error, "Cache operation failed");
+    }
+  }
+};
+
+// src/health/checks/StorageCheck.ts
+var StorageCheck = class extends HealthCheck {
+  name;
+  storage;
+  testPath;
+  constructor(storage, options = {}) {
+    super();
+    this.storage = storage;
+    this.name = options.name ?? "storage";
+    this.testPath = options.testPath ?? "__health_check__.txt";
+  }
+  async check() {
+    const testContent = `health_check_${Date.now()}`;
+    try {
+      await this.storage.put(this.testPath, testContent);
+      const retrieved = await this.storage.get(this.testPath);
+      await this.storage.delete(this.testPath);
+      if (retrieved && retrieved.toString() === testContent) {
+        return this.healthy("Storage is functioning correctly");
+      }
+      return this.degraded("Storage read/write mismatch");
+    } catch (error) {
+      return this.handleError(error, "Storage operation failed");
+    }
+  }
+};
+
+// src/health/checks/MemoryCheck.ts
+var MemoryCheck = class extends HealthCheck {
+  name;
+  thresholdMb;
+  criticalThresholdMb;
+  constructor(options = {}) {
+    super();
+    this.name = options.name ?? "memory";
+    this.thresholdMb = options.thresholdMb ?? 512;
+    this.criticalThresholdMb = options.criticalThresholdMb ?? 1024;
+  }
+  async check() {
+    const usage = process.memoryUsage();
+    const usedMb = Math.round(usage.heapUsed / 1024 / 1024);
+    const totalMb = Math.round(usage.heapTotal / 1024 / 1024);
+    const rssMb = Math.round(usage.rss / 1024 / 1024);
+    const meta = {
+      usedMb,
+      totalMb,
+      rssMb,
+      thresholdMb: this.thresholdMb,
+      criticalThresholdMb: this.criticalThresholdMb
+    };
+    if (usedMb >= this.criticalThresholdMb) {
+      return this.unhealthy(
+        `Memory usage critical: ${usedMb}MB (threshold: ${this.criticalThresholdMb}MB)`,
+        meta
+      );
+    }
+    if (usedMb >= this.thresholdMb) {
+      return this.degraded(
+        `Memory usage elevated: ${usedMb}MB (threshold: ${this.thresholdMb}MB)`,
+        meta
+      );
+    }
+    return this.healthy(`Memory usage normal: ${usedMb}MB`, meta);
+  }
+};
+
+// src/health/checks/CustomCheck.ts
+var CustomCheck = class extends HealthCheck {
+  name;
+  callback;
+  constructor(name, callback) {
+    super();
+    this.name = name;
+    this.callback = callback;
+  }
+  async check() {
+    try {
+      const result = await this.callback();
+      switch (result.status) {
+        case "healthy":
+          return this.healthy(result.message, result.meta);
+        case "degraded":
+          return this.degraded(result.message, result.meta);
+        case "unhealthy":
+          return this.unhealthy(result.message, result.meta);
+        default:
+          return this.unhealthy("Unknown status returned from check");
+      }
+    } catch (error) {
+      return this.unhealthy(
+        error instanceof Error ? error.message : "Custom check failed"
+      );
+    }
+  }
+};
+function customCheck(name, callback) {
+  return new CustomCheck(name, callback);
+}
+export {
+  CacheCheck,
+  CustomCheck,
+  DatabaseCheck,
+  HealthCheck,
+  HealthManager,
+  MemoryCheck,
+  RedisCheck,
+  StorageCheck,
+  createHealthManager,
+  customCheck
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,101 @@
+import { P as PluralizationRule, T as TranslationLoader, c as TranslationMessages } from '../I18nManager-Dtgzsf5n.js';
+export { a as I18nConfig, I as I18nManager, R as ReplacementValues, b as TranslationLoaderFactory, d as Translator, e as TranslatorOptions, f as createI18n, g as getI18n, s as setI18n, t, h as tc } from '../I18nManager-Dtgzsf5n.js';
+
+/**
+ * Default pluralization rules for common languages.
+ *
+ * Returns the index of the plural form to use.
+ * Most languages use: 0 = one, 1 = other
+ * Some languages have more complex rules.
+ */
+declare const pluralizationRules: Record<string, PluralizationRule>;
+/**
+ * Get pluralization rule for a locale.
+ */
+declare function getPluralizationRule(locale: string): PluralizationRule;
+/**
+ * Select the appropriate plural form from a translation.
+ *
+ * Translation format: "singular|plural" or "one|few|many"
+ */
+declare function selectPluralForm(translation: string, count: number, rule: PluralizationRule): string;
+
+/**
+ * JSON file-based translation loader.
+ *
+ * Expected directory structure:
+ * path/
+ *   en/
+ *     messages.json
+ *     validation.json
+ *   ja/
+ *     messages.json
+ *     validation.json
+ */
+declare class JsonLoader implements TranslationLoader {
+    private basePath;
+    private cache;
+    private useCache;
+    constructor(basePath: string, options?: {
+        cache?: boolean;
+    });
+    /**
+     * Load all translations for a locale.
+     */
+    load(locale: string): Promise<TranslationMessages>;
+    /**
+     * Load translations for a specific namespace.
+     */
+    loadNamespace(locale: string, namespace: string): Promise<TranslationMessages>;
+    /**
+     * Get available locales.
+     */
+    getAvailableLocales(): Promise<string[]>;
+    /**
+     * Clear the cache.
+     */
+    clearCache(): void;
+    /**
+     * Enable or disable caching.
+     */
+    setCaching(enabled: boolean): void;
+}
+
+/**
+ * In-memory translation loader.
+ * Useful for testing or when translations are bundled with the application.
+ */
+declare class MemoryLoader implements TranslationLoader {
+    private messages;
+    constructor(messages?: Record<string, TranslationMessages>);
+    /**
+     * Load all translations for a locale.
+     */
+    load(locale: string): Promise<TranslationMessages>;
+    /**
+     * Load translations for a specific namespace.
+     */
+    loadNamespace(locale: string, namespace: string): Promise<TranslationMessages>;
+    /**
+     * Get available locales.
+     */
+    getAvailableLocales(): Promise<string[]>;
+    /**
+     * Add messages for a locale.
+     */
+    addMessages(locale: string, messages: TranslationMessages): void;
+    /**
+     * Set messages for a locale (replaces existing).
+     */
+    setMessages(locale: string, messages: TranslationMessages): void;
+    /**
+     * Remove messages for a locale.
+     */
+    removeLocale(locale: string): void;
+    /**
+     * Clear all messages.
+     */
+    clear(): void;
+}
+
+export { JsonLoader, MemoryLoader, PluralizationRule, TranslationLoader, TranslationMessages, getPluralizationRule, pluralizationRules, selectPluralForm };