@kabyeon/nexusjs 0.6.5

package/dist/grpc/service.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `GrpcService` — the main gRPC service.
+ *
+ * Owns the @grpc/grpc-js server, the loaded proto definition, and
+ * the registered service implementations. The service is
+ * registered in the DI container; the user calls `start()` to
+ * bind the server to a port.
+ *
+ *   const grpc = container.resolve(GrpcService);
+ *   await grpc.start();
+ *   // ...
+ *   await grpc.stop();
+ *
+ * The framework also exposes a `client<T>('ServiceName')` helper
+ * for creating typed clients against the same (or a different)
+ * server. Clients returned by this method are async — each method
+ * returns a Promise.
+ */
+import type { GrpcConfig } from "./types.js";
+export declare const GRPC_SERVICE_TOKEN: unique symbol;
+export declare class GrpcService {
+    #private;
+    readonly name = "grpc";
+    constructor(config: GrpcConfig);
+    /** True if the server is currently bound to a port. */
+    get isRunning(): boolean;
+    /** The actual host the server bound to. `null` until start(). */
+    get host(): string | null;
+    /** Inject a resolver function. Called by GrpcModule.forRoot(). */
+    setResolver(resolve: <T>(token: unknown) => T): void;
+    /** The actual port the server bound to. `null` until start(). */
+    get port(): number | null;
+    /**
+     * Load the .proto file(s) and prepare the server.
+     * Idempotent — call once at boot, before `start()`.
+     */
+    prepare(resolve: <T>(token: unknown) => T): Promise<void>;
+    /**
+     * Bind the server to the configured host/port. Resolves when
+     * the port is bound. Use `port: 0` in tests to let the OS
+     * pick a free port; the actual port is available via the
+     * `port` getter or the `onBound` callback.
+     */
+    start(): Promise<void>;
+    /** Stop the server and release the port. */
+    stop(): Promise<void>;
+    /**
+     * Build a typed client for a gRPC service. The returned object
+     * has one Promise-returning method per service method defined
+     * in the .proto file. Method names are converted to
+     * camelCase on the client side to match JS convention
+     * (e.g. `FindById` → `findById`).
+     */
+    client<T = Record<string, (...args: unknown[]) => Promise<unknown>>>(serviceName: string, options?: {
+        url: string;
+        tls?: boolean;
+    }): T;
+}
+export default GrpcService;
+//# sourceMappingURL=service.d.ts.map

package/dist/grpc/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/grpc/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,eAAO,MAAM,kBAAkB,eAAkC,CAAC;AAElE,qBAAa,WAAW;;IACvB,QAAQ,CAAC,IAAI,UAAU;gBAYX,MAAM,EAAE,UAAU;IAY9B,uDAAuD;IACvD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,iEAAiE;IACjE,IAAI,IAAI,IAAI,MAAM,GAAG,IAAI,CAExB;IAED,kEAAkE;IAClE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,IAAI;IAIpD,iEAAiE;IACjE,IAAI,IAAI,IAAI,MAAM,GAAG,IAAI,CAExB;IAED;;;OAGG;IACG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA2F/D;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuC5B,4CAA4C;IACtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB3B;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,EAClE,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAEpC,GACC,CAAC;CA8DJ;AAkCD,eAAe,WAAW,CAAC"}

package/dist/grpc/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Public types for `nexusjs/grpc`.
+ *
+ * `nexusjs/grpc` is a reflection-based gRPC integration. The user
+ * provides a `.proto` file and a service implementation class
+ * with `@GrpcService` / `@GrpcMethod` decorators. The framework
+ * loads the proto at runtime and wires the methods to the
+ * implementation.
+ *
+ * The gRPC server runs on a separate port (it needs HTTP/2) and
+ * is started manually via `GrpcService.start()`. This keeps the
+ * Hono HTTP/1 server independent and lets the user choose the
+ * port.
+ *
+ * Cross-runtime: works on Bun and Node via `@grpc/grpc-js`
+ * (which is built on Node's `http2` module — Bun supports
+ * this via Node-API compatibility).
+ *
+ * Unary methods only for v1; streaming (server / client / bidi)
+ * is a future addition.
+ */
+import type { ServiceDefinition, UntypedServiceImplementation } from "@grpc/grpc-js";
+export interface GrpcConfig {
+    /**
+     * Path to one or more `.proto` files. Paths are resolved
+     * against the process's cwd.
+     */
+    protoPath: string | string[];
+    /**
+     * Optional override for the proto package name. If omitted,
+     * the package is taken from the `.proto` file. Useful when
+     * the .proto file has multiple `package` declarations.
+     */
+    package?: string;
+    /**
+     * Service implementations to register. Each class must be
+     * decorated with `@GrpcService('Name')` and have its methods
+     * decorated with `@GrpcMethod('ProtoMethodName')`.
+     */
+    services: Array<new (...args: never[]) => unknown>;
+    /** Port to bind the gRPC server to. Default: 50051. */
+    port?: number;
+    /** Host to bind the gRPC server to. Default: "0.0.0.0". */
+    host?: string;
+    /**
+     * TLS credentials. If omitted, the server runs in plaintext
+     * (h2c). For production, provide a `tls: { cert, key }` pair.
+     */
+    tls?: {
+        cert: Buffer | string;
+        key: Buffer | string;
+    };
+    /**
+     * Optional callback that runs after the server is bound. Useful
+     * for tests that need to know the actual port (when `port: 0`
+     * is used).
+     */
+    onBound?: (host: string, port: number) => void;
+}
+export interface GrpcMethodMeta {
+    /** Service name (matches `@GrpcService(name)`). */
+    serviceName: string;
+    /** Method name as it appears in the .proto file. */
+    methodName: string;
+}
+/**
+ * Build a typed client for a gRPC service. The returned object
+ * has one method per service method defined in the .proto file,
+ * with the right TypeScript signature.
+ */
+export type GrpcClient<T> = T;
+export interface GrpcClientOptions {
+    /** Service URL (e.g. "localhost:50051"). */
+    url: string;
+    /** Use TLS. Default: false (insecure). */
+    tls?: boolean;
+}
+export type { ServiceDefinition, UntypedServiceImplementation };
+//# sourceMappingURL=types.d.ts.map

package/dist/grpc/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/grpc/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAMrF,MAAM,WAAW,UAAU;IAC1B;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,QAAQ,EAAE,KAAK,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,CAAC;IAEnD,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,GAAG,CAAC,EAAE;QACL,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;QACtB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;KACrB,CAAC;IAEF;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/C;AAMD,MAAM,WAAW,cAAc;IAC9B,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;CACnB;AAMD;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IACjC,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAMD,YAAY,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/health/health.controller.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `HealthController` — built-in `/health/live`, `/health/ready`,
+ * `/health/startup` endpoints.
+ *
+ * Mount `HealthModule.forRoot({...})` in your app module to get
+ * these routes automatically. Override paths or add an auth token
+ * via `HealthConfig`.
+ */
+import type { Context } from "hono";
+import { HealthCheckService } from "./health.service.js";
+import type { HealthConfig } from "./types.js";
+export declare class HealthController {
+    private readonly health;
+    constructor(health: HealthCheckService);
+    live(c: Context, _res: Response): Promise<Response & import("hono").TypedResponse<{
+        status: import("./types.js").HealthStatus;
+        results: {
+            name: string;
+            result: {
+                status: import("./types.js").HealthStatus;
+                data?: import("hono/utils/types").JSONValue | undefined;
+                message?: string | undefined;
+            };
+        }[];
+        durationMs: number;
+        timestamp: string;
+    }, 200 | 503, "json">>;
+    ready(c: Context, _res: Response): Promise<Response & import("hono").TypedResponse<{
+        status: import("./types.js").HealthStatus;
+        results: {
+            name: string;
+            result: {
+                status: import("./types.js").HealthStatus;
+                data?: import("hono/utils/types").JSONValue | undefined;
+                message?: string | undefined;
+            };
+        }[];
+        durationMs: number;
+        timestamp: string;
+    }, 200 | 503, "json">>;
+    startup(c: Context, _res: Response): Promise<Response & import("hono").TypedResponse<{
+        status: import("./types.js").HealthStatus;
+        results: {
+            name: string;
+            result: {
+                status: import("./types.js").HealthStatus;
+                data?: import("hono/utils/types").JSONValue | undefined;
+                message?: string | undefined;
+            };
+        }[];
+        durationMs: number;
+        timestamp: string;
+    }, 200 | 503, "json">>;
+    private respond;
+}
+declare module "./health.service.js" {
+    interface HealthCheckService {
+        config: HealthConfig;
+    }
+}
+//# sourceMappingURL=health.controller.d.ts.map

package/dist/health/health.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.controller.d.ts","sourceRoot":"","sources":["../../src/health/health.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAmB,YAAY,EAAE,MAAM,YAAY,CAAC;AAEhE,qBACa,gBAAgB;IACkB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,kBAAkB;IAGnF,IAAI,CAAQ,CAAC,EAAE,OAAO,EAAS,IAAI,EAAE,QAAQ;;;;;;;;;;;;;IAK7C,KAAK,CAAQ,CAAC,EAAE,OAAO,EAAS,IAAI,EAAE,QAAQ;;;;;;;;;;;;;IAK9C,OAAO,CAAQ,CAAC,EAAE,OAAO,EAAS,IAAI,EAAE,QAAQ;;;;;;;;;;;;;YAIxC,OAAO;CAKrB;AAGD,OAAO,QAAQ,qBAAqB,CAAC;IACpC,UAAU,kBAAkB;QAC3B,MAAM,EAAE,YAAY,CAAC;KACrB;CACD"}

package/dist/health/health.module.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `HealthModule` — drop-in module for `/health/live`, `/health/ready`,
+ * `/health/startup` endpoints.
+ *
+ * Usage:
+ *   @Module({
+ *     imports: [
+ *       HealthModule.forRoot({
+ *         builtIn: {
+ *           memory: true,
+ *           disk: { threshold: 0.1 },
+ *           http: { url: 'https://api.stripe.com/v1/healthcheck' },
+ *         },
+ *       }),
+ *     ],
+ *   })
+ *   export class AppModule {}
+ *
+ * Then `/health/live`, `/health/ready`, `/health/startup` respond
+ * with a JSON body. Status 200 on `'up'`, 503 on `'down'`.
+ */
+import "reflect-metadata";
+import type { HealthConfig } from "./types.js";
+export declare class HealthModule {
+    static forRoot(config?: HealthConfig): {
+        new (): {};
+    };
+}
+//# sourceMappingURL=health.module.d.ts.map

package/dist/health/health.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.module.d.ts","sourceRoot":"","sources":["../../src/health/health.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,kBAAkB,CAAC;AAI1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,qBAQa,YAAY;IACxB,MAAM,CAAC,OAAO,CAAC,MAAM,GAAE,YAAiB;;;CAkBxC"}

package/dist/health/health.service.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `HealthCheckService` — runs a list of indicators in parallel and
+ * aggregates the result.
+ *
+ * Typically injected into a controller that mounts the
+ * `/health/live`, `/health/ready`, `/health/startup` endpoints.
+ */
+import type { HealthCheckResult, HealthIndicator, HealthCheckKind, HealthConfig } from "./types.js";
+export declare class HealthCheckService {
+    /** DI token — use with `@Inject(HealthCheckService.TOKEN)`. */
+    static readonly TOKEN: unique symbol;
+    /** Registered indicators keyed by name. */
+    indicators: Map<string, HealthIndicator>;
+    /** Public, read-only view of the resolved config. */
+    config: HealthConfig;
+    constructor(config?: HealthConfig);
+    /**
+     * Register an indicator at runtime (e.g. a DB-specific indicator
+     * from a feature module).
+     */
+    register(indicator: HealthIndicator): void;
+    /** Remove a registered indicator. */
+    unregister(name: string): boolean;
+    /** List registered indicator names. */
+    list(): string[];
+    /**
+     * Run all registered indicators in parallel and aggregate.
+     *
+     *   await health.check()  → 200 if all 'up', 503 if any 'down'.
+     */
+    check(kind?: HealthCheckKind): Promise<HealthCheckResult>;
+    private registerBuiltIns;
+}
+//# sourceMappingURL=health.service.d.ts.map

package/dist/health/health.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.service.d.ts","sourceRoot":"","sources":["../../src/health/health.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACX,iBAAiB,EAEjB,eAAe,EAEf,eAAe,EACf,YAAY,EACZ,MAAM,YAAY,CAAC;AAOpB,qBACa,kBAAkB;IAC9B,+DAA+D;IAC/D,MAAM,CAAC,QAAQ,CAAC,KAAK,gBAA0C;IAE/D,2CAA2C;IAC3C,UAAU,+BAAsC;IAChD,qDAAqD;IACrD,MAAM,EAAE,YAAY,CAAC;gBAEgB,MAAM,GAAE,YAAiB;IAK9D;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAI1C,qCAAqC;IACrC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,uCAAuC;IACvC,IAAI,IAAI,MAAM,EAAE;IAIhB;;;;OAIG;IACG,KAAK,CAAC,IAAI,GAAE,eAA6B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAmC5E,OAAO,CAAC,gBAAgB;CAqBxB"}

package/dist/health/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Public API for `nexusjs/health`.
+ *
+ * Quick start:
+ *   // src/app/app.module.ts
+ *   import { Module } from 'nexusjs';
+ *   import { HealthModule } from 'nexusjs/health';
+ *
+ *   @Module({
+ *     imports: [
+ *       HealthModule.forRoot({
+ *         builtIn: { memory: true, disk: { threshold: 0.1 } },
+ *       }),
+ *     ],
+ *   })
+ *   export class AppModule {}
+ *
+ * Endpoints (auto-mounted by HealthController):
+ *   GET /health/live     — fast in-process check (no DB ping)
+ *   GET /health/ready    — runs every registered indicator
+ *   GET /health/startup  — same as readiness; distinct path for K8s
+ *
+ * Response body:
+ *   {
+ *     "status": "up" | "down",
+ *     "results": [{ "name": "memory", "result": { "status": "up", "data": {...} } }, ...],
+ *     "durationMs": 12,
+ *     "timestamp": "2026-06-20T12:00:00.000Z"
+ *   }
+ *
+ * Status code: 200 when all 'up', 503 when any 'down'.
+ */
+export * from "./types.js";
+export { HealthCheckService } from "./health.service.js";
+export { HealthController } from "./health.controller.js";
+export { HealthModule } from "./health.module.js";
+export { MemoryHealthIndicator, DiskHealthIndicator, HttpHealthIndicator, CustomPingIndicator, } from "./indicators/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/health/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/health/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EACN,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACnB,MAAM,uBAAuB,CAAC"}