@guren/server 1.0.0-rc.9 → 1.0.0

package/dist/events/index.js

@@ -1,319 +1,17 @@
-// src/events/Event.ts
-var Event = class {
-  /**
-   * Timestamp when the event was created.
-   */
-  timestamp = /* @__PURE__ */ new Date();
-  /**
-   * Get the event name (class name by default).
-   * Override this to customize the event name.
-   */
-  static get eventName() {
-    return this.name;
-  }
-  /**
-   * Get the event name from an instance.
-   */
-  get eventName() {
-    return this.constructor.eventName;
-  }
-};
-
-// src/events/EventManager.ts
-var EventManager = class {
-  listeners = /* @__PURE__ */ new Map();
-  /**
-   * Queue dispatcher function (set when Queue system is integrated).
-   */
-  queueDispatcher;
-  /**
-   * Register a listener for an event.
-   *
-   * @param event - Event class to listen for
-   * @param listener - Listener function
-   * @param options - Listener options
-   * @returns Subscription handle for unsubscribing
-   *
-   * @example
-   * ```ts
-   * // Basic usage
-   * events.on(UserRegistered, (e) => console.log(e.email))
-   *
-   * // With options
-   * events.on(UserRegistered, (e) => sendEmail(e), { priority: 10 })
-   *
-   * // Unsubscribe later
-   * const sub = events.on(UserRegistered, handler)
-   * sub.unsubscribe()
-   * ```
-   */
-  on(event, listener, options = {}) {
-    const eventName = typeof event === "string" ? event : event.eventName;
-    const registeredListeners = this.listeners.get(eventName) ?? [];
-    const registered = {
-      listener,
-      options: { once: false, priority: 0, ...options }
-    };
-    registeredListeners.push(registered);
-    registeredListeners.sort((a, b) => (b.options.priority ?? 0) - (a.options.priority ?? 0));
-    this.listeners.set(eventName, registeredListeners);
-    return {
-      unsubscribe: () => this.off(event, listener)
-    };
-  }
-  /**
-   * Register a one-time listener for an event.
-   * The listener will be automatically removed after the first invocation.
-   *
-   * @param event - Event class to listen for
-   * @param listener - Listener function
-   * @param options - Additional listener options (once is always true)
-   * @returns Subscription handle for unsubscribing
-   */
-  once(event, listener, options = {}) {
-    return this.on(event, listener, { ...options, once: true });
-  }
-  /**
-   * Remove a listener for an event.
-   *
-   * @param event - Event class
-   * @param listener - Listener to remove (if omitted, all listeners for the event are removed)
-   */
-  off(event, listener) {
-    const eventName = typeof event === "string" ? event : event.eventName;
-    const registeredListeners = this.listeners.get(eventName);
-    if (!registeredListeners) return;
-    if (!listener) {
-      this.listeners.delete(eventName);
-      return;
-    }
-    const index = registeredListeners.findIndex((r) => r.listener === listener);
-    if (index !== -1) {
-      registeredListeners.splice(index, 1);
-      if (registeredListeners.length === 0) {
-        this.listeners.delete(eventName);
-      }
-    }
-  }
-  /**
-   * Emit an event to all registered listeners.
-   * Listeners are executed in order of priority (highest first).
-   * Async listeners are awaited sequentially.
-   *
-   * @param event - Event instance to emit
-   *
-   * @example
-   * ```ts
-   * await events.emit(new UserRegistered('123', 'user@example.com'))
-   * ```
-   */
-  async emit(event) {
-    const eventName = event.eventName;
-    const registeredListeners = this.listeners.get(eventName);
-    if (!registeredListeners || registeredListeners.length === 0) {
-      return;
-    }
-    const listenersToCall = [...registeredListeners];
-    const toRemove = [];
-    for (const registered of listenersToCall) {
-      if (registered.options.queue && this.queueDispatcher) {
-        await this.queueDispatcher(registered.options.queue, eventName, event);
-      } else {
-        await registered.listener(event);
-      }
-      if (registered.options.once) {
-        toRemove.push(registered);
-      }
-    }
-    for (const registered of toRemove) {
-      const index = registeredListeners.indexOf(registered);
-      if (index !== -1) {
-        registeredListeners.splice(index, 1);
-      }
-    }
-    if (registeredListeners.length === 0) {
-      this.listeners.delete(eventName);
-    }
-  }
-  /**
-   * Emit an event to all registered listeners in parallel.
-   * Use this when listener execution order doesn't matter and you want faster execution.
-   *
-   * @param event - Event instance to emit
-   */
-  async emitParallel(event) {
-    const eventName = event.eventName;
-    const registeredListeners = this.listeners.get(eventName);
-    if (!registeredListeners || registeredListeners.length === 0) {
-      return;
-    }
-    const listenersToCall = [...registeredListeners];
-    const toRemove = [];
-    await Promise.all(
-      listenersToCall.map(async (registered) => {
-        if (registered.options.queue && this.queueDispatcher) {
-          await this.queueDispatcher(registered.options.queue, eventName, event);
-        } else {
-          await registered.listener(event);
-        }
-        if (registered.options.once) {
-          toRemove.push(registered);
-        }
-      })
-    );
-    for (const registered of toRemove) {
-      const index = registeredListeners.indexOf(registered);
-      if (index !== -1) {
-        registeredListeners.splice(index, 1);
-      }
-    }
-    if (registeredListeners.length === 0) {
-      this.listeners.delete(eventName);
-    }
-  }
-  /**
-   * Check if an event has any listeners registered.
-   *
-   * @param event - Event class or event name
-   */
-  hasListeners(event) {
-    const eventName = typeof event === "string" ? event : event.eventName;
-    const listeners = this.listeners.get(eventName);
-    return listeners !== void 0 && listeners.length > 0;
-  }
-  /**
-   * Get all listeners for an event.
-   *
-   * @param event - Event class or event name
-   */
-  getListeners(event) {
-    const eventName = typeof event === "string" ? event : event.eventName;
-    const registeredListeners = this.listeners.get(eventName);
-    if (!registeredListeners) return [];
-    return registeredListeners.map((r) => r.listener);
-  }
-  /**
-   * Get the count of listeners for an event.
-   *
-   * @param event - Event class or event name
-   */
-  listenerCount(event) {
-    const eventName = typeof event === "string" ? event : event.eventName;
-    return this.listeners.get(eventName)?.length ?? 0;
-  }
-  /**
-   * Get all registered event names.
-   */
-  eventNames() {
-    return Array.from(this.listeners.keys());
-  }
-  /**
-   * Remove all listeners for all events.
-   */
-  removeAllListeners() {
-    this.listeners.clear();
-  }
-  /**
-   * Set the queue dispatcher function.
-   * This is called by the Queue system when it's integrated.
-   */
-  setQueueDispatcher(dispatcher) {
-    this.queueDispatcher = dispatcher;
-  }
-};
-function createEventManager() {
-  return new EventManager();
-}
-
-// src/events/Listener.ts
-var Listener = class {
-  /**
-   * The event class this listener handles.
-   * Must be set by subclasses.
-   */
-  static event;
-  /**
-   * Whether this listener should be queued instead of executed immediately.
-   * @default false
-   */
-  static shouldQueue = false;
-  /**
-   * The queue name to dispatch to when shouldQueue is true.
-   * @default 'default'
-   */
-  static queue = "default";
-  /**
-   * Priority of this listener. Higher values are executed first.
-   * @default 0
-   */
-  static priority = 0;
-};
-
-// src/events/builtin.ts
-var RequestReceived = class extends Event {
-  constructor(method, path, requestId) {
-    super();
-    this.method = method;
-    this.path = path;
-    this.requestId = requestId;
-  }
-};
-var RequestFinished = class extends Event {
-  constructor(method, path, status, durationMs, requestId) {
-    super();
-    this.method = method;
-    this.path = path;
-    this.status = status;
-    this.durationMs = durationMs;
-    this.requestId = requestId;
-  }
-};
-var UserAuthenticated = class extends Event {
-  constructor(userId, guard = "default") {
-    super();
-    this.userId = userId;
-    this.guard = guard;
-  }
-};
-var UserLoggedOut = class extends Event {
-  constructor(userId, guard = "default") {
-    super();
-    this.userId = userId;
-    this.guard = guard;
-  }
-};
-var JobProcessed = class extends Event {
-  constructor(jobId, jobName, queue, durationMs) {
-    super();
-    this.jobId = jobId;
-    this.jobName = jobName;
-    this.queue = queue;
-    this.durationMs = durationMs;
-  }
-};
-var JobFailed = class extends Event {
-  constructor(jobId, jobName, queue, error, attempts) {
-    super();
-    this.jobId = jobId;
-    this.jobName = jobName;
-    this.queue = queue;
-    this.error = error;
-    this.attempts = attempts;
-  }
-};
-var ApplicationStarted = class extends Event {
-  constructor(port, host) {
-    super();
-    this.port = port;
-    this.host = host;
-  }
-};
-var ApplicationShutdown = class extends Event {
-  constructor(reason) {
-    super();
-    this.reason = reason;
-  }
-};
+import {
+  ApplicationShutdown,
+  ApplicationStarted,
+  Event,
+  EventManager,
+  JobFailed,
+  JobProcessed,
+  Listener,
+  RequestFinished,
+  RequestReceived,
+  UserAuthenticated,
+  UserLoggedOut,
+  createEventManager
+} from "../chunk-74HTZG3V.js";
 export {
   ApplicationShutdown,
   ApplicationStarted,

package/dist/health/index.js

@@ -1,370 +1,15 @@
-// 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);
-}
+import {
+  CacheCheck,
+  CustomCheck,
+  DatabaseCheck,
+  HealthCheck,
+  HealthManager,
+  MemoryCheck,
+  RedisCheck,
+  StorageCheck,
+  createHealthManager,
+  customCheck
+} from "../chunk-SIP34GBE.js";
 export {
   CacheCheck,
   CustomCheck,