@kabyeon/nexusjs 0.6.5

package/dist/events/index.js

@@ -0,0 +1,646 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+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 __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+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/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+// src/events/emitter.ts
+class NexusEventEmitter {
+  #listeners = [];
+  #emitterListeners = new Set;
+  #maxPerPattern;
+  #throwOnError;
+  #defaultPriority;
+  #nextId = 1;
+  constructor(config = {}) {
+    this.#maxPerPattern = config.maxListenersPerPattern ?? 10;
+    this.#throwOnError = config.throwOnError ?? false;
+    this.#defaultPriority = config.defaultPriority ?? 5;
+  }
+  on(pattern, listener, options = {}) {
+    const existing = this.#listeners.filter((l) => l.pattern === pattern);
+    if (existing.length >= this.#maxPerPattern) {
+      throw new Error(`[events] Too many listeners registered for "${pattern}" ` + `(max ${this.#maxPerPattern}). Increase \`maxListenersPerPattern\` ` + `or call \`off()\` on stale listeners.`);
+    }
+    const id = this.#allocateId();
+    const internal = {
+      id,
+      pattern,
+      regex: compilePattern(pattern),
+      priority: options.priority ?? this.#defaultPriority,
+      once: options.once ?? false,
+      listener,
+      createdAt: Date.now()
+    };
+    if (options.if !== undefined) {
+      internal.guard = options.if;
+    }
+    this.#listeners.push(internal);
+    this.#sortListeners();
+    this.#emitEmitterEvent({ kind: "listener:registered", id, pattern });
+    return id;
+  }
+  once(pattern, listener, options = {}) {
+    return this.on(pattern, listener, { ...options, once: true });
+  }
+  off(idOrPattern) {
+    const before = this.#listeners.length;
+    const removed = [];
+    this.#listeners = this.#listeners.filter((l) => {
+      const match = l.id === idOrPattern || l.pattern === idOrPattern;
+      if (match)
+        removed.push(l);
+      return !match;
+    });
+    for (const r of removed) {
+      this.#emitEmitterEvent({ kind: "listener:removed", id: r.id });
+    }
+    return before - this.#listeners.length;
+  }
+  async emit(name, payload) {
+    const result = {
+      name,
+      matched: 0,
+      completed: 0,
+      failed: 0,
+      errors: []
+    };
+    const matches = this.#matchingListeners(name);
+    result.matched = matches.length;
+    if (matches.length === 0)
+      return result;
+    const eligible = [];
+    for (const l of matches) {
+      if (l.guard) {
+        try {
+          const ok = await l.guard(payload);
+          if (!ok) {
+            this.#emitEmitterEvent({
+              kind: "listener:skipped",
+              id: l.id,
+              pattern: l.pattern,
+              reason: "guard"
+            });
+            continue;
+          }
+        } catch {
+          this.#emitEmitterEvent({
+            kind: "listener:skipped",
+            id: l.id,
+            pattern: l.pattern,
+            reason: "guard"
+          });
+          continue;
+        }
+      }
+      eligible.push({ listener: l, payload });
+    }
+    const toRemove = [];
+    for (const { listener, payload: p } of eligible) {
+      const start = Date.now();
+      try {
+        await listener.listener(p);
+        result.completed++;
+        this.#emitEmitterEvent({
+          kind: "listener:fired",
+          id: listener.id,
+          pattern: listener.pattern,
+          durationMs: Date.now() - start
+        });
+      } catch (err) {
+        result.failed++;
+        const error = err instanceof Error ? err : new Error(String(err));
+        result.errors.push({
+          listenerId: listener.id,
+          listenerName: listener.pattern,
+          error: error.message
+        });
+        this.#emitEmitterEvent({
+          kind: "listener:failed",
+          id: listener.id,
+          pattern: listener.pattern,
+          error
+        });
+        if (this.#throwOnError) {
+          throw error;
+        }
+      } finally {
+        if (listener.once)
+          toRemove.push(listener);
+      }
+    }
+    if (toRemove.length > 0) {
+      const ids = new Set(toRemove.map((l) => l.id));
+      this.#listeners = this.#listeners.filter((l) => !ids.has(l.id));
+    }
+    return result;
+  }
+  emitSync(name, payload) {
+    const result = {
+      name,
+      matched: 0,
+      completed: 0,
+      failed: 0,
+      errors: []
+    };
+    const matches = this.#matchingListeners(name);
+    result.matched = matches.length;
+    if (matches.length === 0)
+      return result;
+    const toRemove = [];
+    for (const l of matches) {
+      if (l.guard) {
+        let ok;
+        try {
+          ok = l.guard(payload);
+        } catch {
+          continue;
+        }
+        if (!ok)
+          continue;
+      }
+      const start = Date.now();
+      try {
+        const ret = l.listener(payload);
+        if (ret && typeof ret.then === "function") {
+          ret.then(() => {
+            result.completed++;
+            if (l.once)
+              toRemove.push(l);
+          }, (err) => {
+            result.failed++;
+            result.errors.push({
+              listenerId: l.id,
+              listenerName: l.pattern,
+              error: err instanceof Error ? err.message : String(err)
+            });
+            if (l.once)
+              toRemove.push(l);
+          });
+        } else {
+          result.completed++;
+          if (l.once)
+            toRemove.push(l);
+        }
+        this.#emitEmitterEvent({
+          kind: "listener:fired",
+          id: l.id,
+          pattern: l.pattern,
+          durationMs: Date.now() - start
+        });
+      } catch (err) {
+        result.failed++;
+        const error = err instanceof Error ? err : new Error(String(err));
+        result.errors.push({
+          listenerId: l.id,
+          listenerName: l.pattern,
+          error: error.message
+        });
+        if (l.once)
+          toRemove.push(l);
+      }
+    }
+    if (toRemove.length > 0) {
+      const ids = new Set(toRemove.map((l) => l.id));
+      this.#listeners = this.#listeners.filter((l) => !ids.has(l.id));
+    }
+    return result;
+  }
+  listenerCount(pattern) {
+    if (pattern === undefined)
+      return this.#listeners.length;
+    return this.#listeners.filter((l) => l.pattern === pattern).length;
+  }
+  listListeners(pattern) {
+    const list = pattern === undefined ? this.#listeners : this.#listeners.filter((l) => l.pattern === pattern);
+    return list.map((l) => ({
+      id: l.id,
+      pattern: l.pattern,
+      priority: l.priority,
+      once: l.once
+    }));
+  }
+  removeAllListeners() {
+    const ids = this.#listeners.map((l) => l.id);
+    this.#listeners = [];
+    for (const id of ids) {
+      this.#emitEmitterEvent({ kind: "listener:removed", id });
+    }
+  }
+  onEmitterEvent(listener) {
+    this.#emitterListeners.add(listener);
+    return () => this.#emitterListeners.delete(listener);
+  }
+  #allocateId() {
+    return `evt-${this.#nextId++}`;
+  }
+  #matchingListeners(name) {
+    return this.#listeners.filter((l) => {
+      if (l.regex === null)
+        return l.pattern === name;
+      return l.regex.test(name);
+    });
+  }
+  #sortListeners() {
+    this.#listeners.sort((a, b) => {
+      if (a.priority !== b.priority)
+        return a.priority - b.priority;
+      return a.createdAt - b.createdAt;
+    });
+  }
+  #emitEmitterEvent(event) {
+    for (const l of this.#emitterListeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+function compilePattern(pattern) {
+  if (!pattern.includes("*"))
+    return null;
+  const DOUBLE = "\x00DOUBLE\x00";
+  const SINGLE = "\x00SINGLE\x00";
+  let p = pattern.split("**").join(DOUBLE).split("*").join(SINGLE);
+  p = p.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  p = p.split(DOUBLE).join(".*").split(SINGLE).join("[^.]+");
+  return new RegExp(`^${p}$`);
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/events/event.service.ts
+class EventService {
+  config;
+  static TOKEN = Symbol.for("nexus:EventService");
+  emitter;
+  constructor(config = {}) {
+    this.config = config;
+    this.emitter = new NexusEventEmitter(config);
+  }
+  on(pattern, listener, options) {
+    return this.emitter.on(pattern, listener, options);
+  }
+  once(pattern, listener, options) {
+    return this.emitter.once(pattern, listener, options);
+  }
+  off(idOrPattern) {
+    return this.emitter.off(idOrPattern);
+  }
+  emit(name, payload) {
+    return this.emitter.emit(name, payload);
+  }
+  emitSync(name, payload) {
+    return this.emitter.emitSync(name, payload);
+  }
+  listenerCount(pattern) {
+    return this.emitter.listenerCount(pattern);
+  }
+  listListeners(pattern) {
+    return this.emitter.listListeners(pattern);
+  }
+  removeAllListeners() {
+    this.emitter.removeAllListeners();
+  }
+  onEmitterEvent(listener) {
+    const internal = this.emitter;
+    if (typeof internal.onEmitterEvent === "function") {
+      return internal.onEmitterEvent(listener);
+    }
+    return () => {};
+  }
+  #bridgeEmitterEvents() {
+    const internal = this.emitter;
+    if (typeof internal.onEmitterEvent === "function") {
+      internal.onEmitterEvent((event) => {});
+    }
+  }
+}
+EventService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("EVENTS_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof EventsConfig === "undefined" ? Object : EventsConfig
+  ])
+], EventService);
+// src/events/events.module.ts
+import"reflect-metadata";
+class EventsModule {
+  static forRoot(config = {}) {
+    class ConfiguredEventsModule {
+    }
+    ConfiguredEventsModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          EventService,
+          { provide: EventService.TOKEN, useExisting: EventService },
+          { provide: "EVENTS_CONFIG", useValue: config }
+        ],
+        exports: [EventService, EventService.TOKEN]
+      })
+    ], ConfiguredEventsModule);
+    Object.defineProperty(ConfiguredEventsModule, "name", {
+      value: "ConfiguredEventsModule"
+    });
+    return ConfiguredEventsModule;
+  }
+}
+EventsModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      EventService,
+      { provide: EventService.TOKEN, useExisting: EventService }
+    ],
+    exports: [EventService, EventService.TOKEN]
+  })
+], EventsModule);
+// src/events/decorators/on-event.ts
+import"reflect-metadata";
+var ON_EVENT_META = "nexus:events:on-event";
+function OnEvent(pattern, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@OnEvent can only decorate methods.");
+    }
+    const ctor = target.constructor;
+    const hooks = Reflect.getMetadata(ON_EVENT_META, ctor) ?? [];
+    hooks.push({ method: String(propertyKey), pattern, options });
+    Reflect.defineMetadata(ON_EVENT_META, hooks, ctor);
+  };
+}
+function getOnEventHooks(target) {
+  const ctor = target.constructor ?? target;
+  return Reflect.getMetadata(ON_EVENT_META, ctor) ?? [];
+}
+function scanForListeners(instance, service) {
+  const ids = [];
+  for (const h of getOnEventHooks(instance)) {
+    const fn = instance[h.method];
+    if (typeof fn !== "function")
+      continue;
+    const id = service.on(h.pattern, fn.bind(instance), {
+      priority: h.options.priority,
+      once: h.options.once,
+      if: h.options.if
+    });
+    ids.push(id);
+  }
+  return ids;
+}
+export {
+  scanForListeners,
+  getOnEventHooks,
+  compilePattern,
+  OnEvent,
+  NexusEventEmitter,
+  EventsModule,
+  EventService
+};
+
+//# debugId=CC457D1178A415F864756E2164756E21
+//# sourceMappingURL=index.js.map