@guren/server 1.0.0-rc.9 → 1.0.0

package/dist/chunk-74HTZG3V.js

@@ -0,0 +1,331 @@
+// 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;
+  }
+};
+
+export {
+  Event,
+  EventManager,
+  createEventManager,
+  Listener,
+  RequestReceived,
+  RequestFinished,
+  UserAuthenticated,
+  UserLoggedOut,
+  JobProcessed,
+  JobFailed,
+  ApplicationStarted,
+  ApplicationShutdown
+};