@kabyeon/nexusjs 0.6.5

package/dist/health/index.js

@@ -0,0 +1,599 @@
+// @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/health/types.ts
+class HealthIndicator {
+}
+// 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/health/indicators/drizzle.ts
+class DrizzleHealthIndicator {
+  name;
+  #db;
+  #timeoutMs;
+  #probe;
+  constructor(name, db, options = {}) {
+    this.name = name;
+    this.#db = db;
+    this.#timeoutMs = options.timeoutMs ?? 3000;
+    this.#probe = options.probe ?? "SELECT 1";
+  }
+  async check() {
+    const start = Date.now();
+    try {
+      const probe = this.#probe;
+      await Promise.race([
+        this.#db.rawQuery(probe),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`probe timed out after ${this.#timeoutMs}ms`)), this.#timeoutMs))
+      ]);
+      return {
+        status: "up",
+        data: { latencyMs: Date.now() - start, probe: this.#probe }
+      };
+    } catch (err) {
+      return {
+        status: "down",
+        message: err instanceof Error ? err.message : String(err),
+        data: { latencyMs: Date.now() - start, probe: this.#probe }
+      };
+    }
+  }
+}
+
+// src/health/indicators/index.ts
+class MemoryHealthIndicator {
+  name = "memory";
+  #threshold;
+  constructor(options = {}) {
+    this.#threshold = options.threshold ?? 0.9;
+  }
+  async check() {
+    const mem = process.memoryUsage();
+    const total = mem.heapTotal;
+    const used = mem.heapUsed;
+    const ratio = total > 0 ? used / total : 0;
+    if (ratio > this.#threshold) {
+      return {
+        status: "down",
+        message: `heap usage ${(ratio * 100).toFixed(1)}% exceeds threshold ${(this.#threshold * 100).toFixed(0)}%`,
+        data: { heapUsed: used, heapTotal: total, ratio }
+      };
+    }
+    return {
+      status: "up",
+      data: { heapUsed: used, heapTotal: total, ratio }
+    };
+  }
+}
+
+class DiskHealthIndicator {
+  name = "disk";
+  #threshold;
+  #path;
+  constructor(options = {}) {
+    this.#threshold = options.threshold ?? 0.1;
+    this.#path = options.path ?? process.cwd();
+  }
+  async check() {
+    try {
+      const statfs = await import("fs/promises").then((m) => m.statfs).catch(() => null);
+      if (!statfs) {
+        return { status: "up", message: "statfs unavailable; skipping" };
+      }
+      const s = await statfs(this.#path);
+      const free = s.bavail * s.bsize;
+      const total = s.blocks * s.bsize;
+      const freeRatio = total > 0 ? free / total : 1;
+      if (freeRatio < this.#threshold) {
+        return {
+          status: "down",
+          message: `disk free ${(freeRatio * 100).toFixed(1)}% below threshold ${(this.#threshold * 100).toFixed(0)}%`,
+          data: { free, total, freeRatio, path: this.#path }
+        };
+      }
+      return {
+        status: "up",
+        data: { free, total, freeRatio, path: this.#path }
+      };
+    } catch (err) {
+      return {
+        status: "down",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+}
+
+class HttpHealthIndicator {
+  name;
+  #url;
+  #timeoutMs;
+  constructor(name, options) {
+    this.name = name;
+    this.#url = options.url;
+    this.#timeoutMs = options.timeoutMs ?? 3000;
+  }
+  async check() {
+    const ctrl = new AbortController;
+    const timer = setTimeout(() => ctrl.abort(), this.#timeoutMs);
+    try {
+      const res = await fetch(this.#url, { signal: ctrl.signal });
+      if (res.status >= 200 && res.status < 300) {
+        return { status: "up", data: { status: res.status } };
+      }
+      return {
+        status: "down",
+        message: `HTTP ${res.status}`,
+        data: { status: res.status }
+      };
+    } catch (err) {
+      return {
+        status: "down",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+class CustomPingIndicator {
+  name;
+  #ping;
+  #timeoutMs;
+  constructor(name, ping, timeoutMs = 3000) {
+    this.name = name;
+    this.#ping = ping;
+    this.#timeoutMs = timeoutMs;
+  }
+  async check() {
+    const ctrl = new AbortController;
+    const timer = setTimeout(() => ctrl.abort(), this.#timeoutMs);
+    try {
+      await Promise.race([
+        Promise.resolve(this.#ping()),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`ping timed out after ${this.#timeoutMs}ms`)), this.#timeoutMs))
+      ]);
+      return { status: "up" };
+    } catch (err) {
+      return {
+        status: "down",
+        message: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+// src/health/health.service.ts
+class HealthCheckService {
+  static TOKEN = Symbol.for("nexus:HealthCheckService");
+  indicators = new Map;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.registerBuiltIns();
+  }
+  register(indicator) {
+    this.indicators.set(indicator.name, indicator);
+  }
+  unregister(name) {
+    return this.indicators.delete(name);
+  }
+  list() {
+    return [...this.indicators.keys()];
+  }
+  async check(kind = "readiness") {
+    const start = Date.now();
+    const indicators = [...this.indicators.values()];
+    const settled = await Promise.allSettled(indicators.map((i) => i.check()));
+    const entries = indicators.map((i, idx) => {
+      const s = settled[idx];
+      if (s.status === "fulfilled") {
+        return { name: i.name, result: s.value };
+      }
+      const err = s.reason;
+      return {
+        name: i.name,
+        result: {
+          status: "down",
+          message: err instanceof Error ? err.message : String(err)
+        }
+      };
+    });
+    const status = entries.every((e) => e.result.status === "up") ? "up" : "down";
+    return {
+      status,
+      results: entries,
+      durationMs: Date.now() - start,
+      timestamp: new Date().toISOString()
+    };
+  }
+  registerBuiltIns() {
+    const bi = this.config.builtIn ?? {};
+    if (bi.memory) {
+      const opts = typeof bi.memory === "object" ? bi.memory : {};
+      this.register(new MemoryHealthIndicator(opts));
+    }
+    if (bi.disk) {
+      this.register(new DiskHealthIndicator(bi.disk));
+    }
+    if (bi.http) {
+      const host = (() => {
+        try {
+          return new URL(bi.http.url).host || "http";
+        } catch {
+          return "http";
+        }
+      })();
+      this.register(new HttpHealthIndicator(host, bi.http));
+    }
+  }
+}
+HealthCheckService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("HEALTH_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof HealthConfig === "undefined" ? Object : HealthConfig
+  ])
+], HealthCheckService);
+// src/health/health.controller.ts
+class HealthController {
+  health;
+  constructor(health) {
+    this.health = health;
+  }
+  async live(c, _res) {
+    return this.respond(c, "liveness", this.health.config.livenessPath ?? "/health/live");
+  }
+  async ready(c, _res) {
+    return this.respond(c, "readiness", this.health.config.readinessPath ?? "/health/ready");
+  }
+  async startup(c, _res) {
+    return this.respond(c, "startup", this.health.config.startupPath ?? "/health/startup");
+  }
+  async respond(c, kind, _configuredPath) {
+    const result = await this.health.check(kind);
+    const status = result.status === "up" ? 200 : 503;
+    return c.json(result, status);
+  }
+}
+__legacyDecorateClassTS([
+  Get("/health/live"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Res()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], HealthController.prototype, "live", null);
+__legacyDecorateClassTS([
+  Get("/health/ready"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Res()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], HealthController.prototype, "ready", null);
+__legacyDecorateClassTS([
+  Get("/health/startup"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Res()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], HealthController.prototype, "startup", null);
+HealthController = __legacyDecorateClassTS([
+  Controller(),
+  __legacyDecorateParamTS(0, Inject(HealthCheckService.TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof HealthCheckService === "undefined" ? Object : HealthCheckService
+  ])
+], HealthController);
+// src/health/health.module.ts
+import"reflect-metadata";
+class HealthModule {
+  static forRoot(config = {}) {
+    class ConfiguredHealthModule {
+    }
+    ConfiguredHealthModule = __legacyDecorateClassTS([
+      Module({
+        controllers: [HealthController],
+        providers: [
+          HealthCheckService,
+          { provide: HealthCheckService.TOKEN, useExisting: HealthCheckService },
+          { provide: "HEALTH_CONFIG", useValue: config }
+        ],
+        exports: [HealthCheckService, HealthCheckService.TOKEN]
+      })
+    ], ConfiguredHealthModule);
+    Object.defineProperty(ConfiguredHealthModule, "name", {
+      value: "ConfiguredHealthModule"
+    });
+    return ConfiguredHealthModule;
+  }
+}
+HealthModule = __legacyDecorateClassTS([
+  Module({
+    controllers: [HealthController],
+    providers: [
+      HealthCheckService,
+      { provide: HealthCheckService.TOKEN, useExisting: HealthCheckService }
+    ],
+    exports: [HealthCheckService, HealthCheckService.TOKEN]
+  })
+], HealthModule);
+export {
+  MemoryHealthIndicator,
+  HttpHealthIndicator,
+  HealthModule,
+  HealthIndicator,
+  HealthController,
+  HealthCheckService,
+  DiskHealthIndicator,
+  CustomPingIndicator
+};
+
+//# debugId=D3D549A0F061137064756E2164756E21
+//# sourceMappingURL=index.js.map