@nimbus-cqrs/hono 2.0.0-beta.0

package/esm/lib/middleware/logger.js

@@ -0,0 +1,94 @@
+import { getLogger } from '../../deps/jsr.io/@nimbus/core/2.0.0/src/index.js';
+import { context, propagation, SpanKind, SpanStatusCode, trace, } from '@opentelemetry/api';
+import { getCorrelationId } from './correlationId.js';
+const humanize = (times) => {
+    const [delimiter, separator] = [',', '.'];
+    const orderTimes = times.map((v) => v.replaceAll(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + delimiter));
+    return orderTimes.join(separator);
+};
+const time = (start) => {
+    const delta = Date.now() - start;
+    return humanize([
+        delta < 1000 ? delta + 'ms' : Math.round(delta / 1000) + 's',
+    ]);
+};
+/**
+ * Logger middleware for Hono with optional OpenTelemetry tracing.
+ *
+ * When tracing is enabled, the middleware:
+ * - Extracts trace context from incoming request headers (traceparent/tracestate)
+ * - Creates a server span for the HTTP request
+ * - Makes the span active so child spans can be created in handlers
+ * - Records HTTP method, path, and status code as span attributes
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { logger } from '@nimbus/hono';
+ *
+ * const app = new Hono();
+ * app.use(logger({ enableTracing: true }));
+ * ```
+ */
+export const logger = (options) => {
+    const enableTracing = options?.enableTracing ?? true;
+    const tracerName = options?.tracerName ?? 'nimbus';
+    const tracer = trace.getTracer(tracerName);
+    return async (c, next) => {
+        const startTime = Date.now();
+        const correlationId = getCorrelationId(c);
+        getLogger().info({
+            category: 'API',
+            message: `REQ: [${c.req.method}] ${c.req.path}`,
+            correlationId,
+        });
+        if (enableTracing) {
+            // Extract trace context from incoming headers (traceparent, tracestate)
+            const parentContext = propagation.extract(context.active(), c.req.raw.headers, {
+                get: (headers, key) => headers.get(key) ?? undefined,
+                keys: (headers) => [...headers.keys()],
+            });
+            // Run the request within the extracted context
+            await context.with(parentContext, async () => {
+                await tracer.startActiveSpan(`HTTP ${c.req.method} ${c.req.path}`, {
+                    kind: SpanKind.SERVER,
+                    attributes: {
+                        'http.method': c.req.method,
+                        'url.path': c.req.path,
+                        'http.target': c.req.url,
+                        ...(correlationId && {
+                            correlation_id: correlationId,
+                        }),
+                    },
+                }, async (span) => {
+                    try {
+                        await next();
+                        span.setAttribute('http.status_code', c.res.status);
+                        if (c.res.status >= 400) {
+                            span.setStatus({ code: SpanStatusCode.ERROR });
+                        }
+                    }
+                    catch (err) {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err.message,
+                        });
+                        span.recordException(err);
+                        throw err;
+                    }
+                    finally {
+                        span.end();
+                    }
+                });
+            });
+        }
+        else {
+            await next();
+        }
+        getLogger().info({
+            category: 'API',
+            message: `RES: [${c.req.method}] ${c.req.path} - ${time(startTime)}`,
+            correlationId,
+        });
+    };
+};

package/esm/lib/onError.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from 'hono';
+import type { HTTPResponseError } from 'hono/types';
+/**
+ * An error handler for Hono applications that maps
+ * Nimbus exceptions to HTTP responses and handles
+ * other unhandled errors.
+ *
+ * @param error - The error to handle.
+ * @param c - The Hono context.
+ *
+ * @example
+ * ```ts
+ * import { handleError } from '@nimbus/hono';
+ *
+ * const app = new Hono();
+ * app.onError(handleError);
+ * ```
+ */
+export declare const handleError: (error: Error | HTTPResponseError, c: Context) => Response;
+//# sourceMappingURL=onError.d.ts.map

package/esm/lib/onError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onError.d.ts","sourceRoot":"","sources":["../../src/lib/onError.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,GACpB,OAAO,KAAK,GAAG,iBAAiB,EAChC,GAAG,OAAO,KACX,QAsCF,CAAC"}

package/esm/lib/onError.js

@@ -0,0 +1,54 @@
+import { Exception, getLogger } from '../deps/jsr.io/@nimbus/core/2.0.0/src/index.js';
+/**
+ * An error handler for Hono applications that maps
+ * Nimbus exceptions to HTTP responses and handles
+ * other unhandled errors.
+ *
+ * @param error - The error to handle.
+ * @param c - The Hono context.
+ *
+ * @example
+ * ```ts
+ * import { handleError } from '@nimbus/hono';
+ *
+ * const app = new Hono();
+ * app.onError(handleError);
+ * ```
+ */
+export const handleError = (error, c) => {
+    let statusCode = 500;
+    let response = {
+        error: 'INTERNAL_SERVER_ERROR',
+    };
+    const isNimbusException = error instanceof Exception;
+    if (isNimbusException) {
+        statusCode = error.statusCode ?? 500;
+        response = {
+            error: error.name,
+            message: error.message,
+            ...(error.details && { details: error.details }),
+        };
+        if (statusCode >= 500) {
+            getLogger().error({
+                category: 'Nimbus',
+                message: error.message,
+                error,
+            });
+        }
+        else {
+            getLogger().debug({
+                category: 'Nimbus',
+                message: error.message,
+                error,
+            });
+        }
+    }
+    else {
+        getLogger().critical({
+            category: 'Nimbus',
+            message: 'An unhandled error occurred',
+            error,
+        });
+    }
+    return c.json(response, statusCode);
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nimbus-cqrs/hono",
+  "version": "2.0.0-beta.0",
+  "description": "Hono integration for the Nimbus CQRS framework.",
+  "author": "Daniel Gördes <d.goerdes@overlap.at> (https://overlap.at)",
+  "homepage": "https://nimbus.overlap.at",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/overlap-dev/Nimbus"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/overlap-dev/Nimbus/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "hono": "^4.12.14",
+    "zod": "^4.3.6",
+    "@nimbus-cqrs/core": "^2.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "_generatedBy": "dnt@dev"
+}