@a-company/sentinel 0.2.0

package/dist/adapters/express.d.ts

@@ -0,0 +1,44 @@
+import { X as Sentinel } from '../sdk-B27_vK1g.js';
+
+/**
+ * Sentinel Express Adapter
+ *
+ * Express error-handling middleware that auto-captures errors
+ * with route-derived symbolic context.
+ *
+ * Usage:
+ *   import { Sentinel } from '@a-company/sentinel';
+ *   import { createExpressErrorHandler } from '@a-company/sentinel/express';
+ *
+ *   const sentinel = new Sentinel({ project: 'my-app' });
+ *   app.use(createExpressErrorHandler(sentinel));
+ */
+
+type ErrorRequestHandler = (err: Error, req: any, res: any, next: (err?: any) => void) => void;
+/**
+ * Route-to-symbol mapping configuration.
+ * Maps route prefixes to component symbols.
+ *
+ * Example:
+ *   { '/api/checkout': '#checkout', '/api/auth': '#auth-service' }
+ */
+type RouteSymbolMap = Record<string, string>;
+interface ExpressAdapterOptions {
+    /** Map route prefixes to component symbols */
+    routeMap?: RouteSymbolMap;
+    /** Whether to set X-Sentinel-Incident response header (default: true) */
+    setHeader?: boolean;
+}
+/**
+ * Create Express error-handling middleware.
+ *
+ * Automatically captures unhandled errors with:
+ * - Route-derived component symbol (auto-detected or from routeMap)
+ * - Request metadata (method, path)
+ *
+ * @param sentinel - Sentinel SDK instance
+ * @param options - Adapter options
+ */
+declare function createExpressErrorHandler(sentinel: Sentinel, options?: ExpressAdapterOptions): ErrorRequestHandler;
+
+export { type ExpressAdapterOptions, type RouteSymbolMap, createExpressErrorHandler };

package/dist/adapters/express.js

@@ -0,0 +1,30 @@
+// src/adapters/express.ts
+function createExpressErrorHandler(sentinel, options = {}) {
+  const { routeMap = {}, setHeader = true } = options;
+  return (err, req, res, next) => {
+    const context = {};
+    const path = req.path || req.url || "";
+    let matched = false;
+    for (const [prefix, symbol] of Object.entries(routeMap)) {
+      if (path.startsWith(prefix)) {
+        context.component = symbol;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const routeParts = path.split("/").filter(Boolean);
+      if (routeParts.length >= 2) {
+        context.component = `#${routeParts[1]}`;
+      }
+    }
+    const incidentId = sentinel.capture(err, context);
+    if (setHeader && res.setHeader && !res.headersSent) {
+      res.setHeader("X-Sentinel-Incident", incidentId);
+    }
+    next(err);
+  };
+}
+export {
+  createExpressErrorHandler
+};

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,23 @@
+import { X as Sentinel } from '../sdk-B27_vK1g.js';
+
+/**
+ * Sentinel Fastify Adapter
+ *
+ * Fastify plugin that auto-captures errors with symbolic context.
+ *
+ * Usage:
+ *   import { Sentinel } from '@a-company/sentinel';
+ *   import { createFastifyPlugin } from '@a-company/sentinel/fastify';
+ *
+ *   const sentinel = new Sentinel({ project: 'my-app' });
+ *   fastify.register(createFastifyPlugin(sentinel));
+ */
+
+/**
+ * Create a Fastify plugin that captures errors with symbolic context.
+ *
+ * @param sentinel - Sentinel SDK instance
+ */
+declare function createFastifyPlugin(sentinel: Sentinel): (fastify: any) => Promise<void>;
+
+export { createFastifyPlugin };

package/dist/adapters/fastify.js

@@ -0,0 +1,18 @@
+// src/adapters/fastify.ts
+function createFastifyPlugin(sentinel) {
+  return async function sentinelPlugin(fastify) {
+    fastify.setErrorHandler(async (error, request, reply) => {
+      const context = {};
+      const url = request.url || "";
+      const routeParts = url.split("?")[0].split("/").filter(Boolean);
+      if (routeParts.length >= 2) {
+        context.component = `#${routeParts[1]}`;
+      }
+      sentinel.capture(error, context);
+      reply.status(500).send({ error: "Internal Server Error" });
+    });
+  };
+}
+export {
+  createFastifyPlugin
+};

package/dist/adapters/hono.d.ts

@@ -0,0 +1,23 @@
+import { X as Sentinel } from '../sdk-B27_vK1g.js';
+
+/**
+ * Sentinel Hono Adapter
+ *
+ * Hono middleware that auto-captures errors with symbolic context.
+ *
+ * Usage:
+ *   import { Sentinel } from '@a-company/sentinel';
+ *   import { createHonoMiddleware } from '@a-company/sentinel/hono';
+ *
+ *   const sentinel = new Sentinel({ project: 'my-app' });
+ *   app.use('*', createHonoMiddleware(sentinel));
+ */
+
+/**
+ * Create Hono middleware that captures errors with symbolic context.
+ *
+ * @param sentinel - Sentinel SDK instance
+ */
+declare function createHonoMiddleware(sentinel: Sentinel): (c: any, next: () => Promise<void>) => Promise<void>;
+
+export { createHonoMiddleware };

package/dist/adapters/hono.js

@@ -0,0 +1,26 @@
+// src/adapters/hono.ts
+function createHonoMiddleware(sentinel) {
+  return async (c, next) => {
+    try {
+      await next();
+    } catch (error) {
+      if (error instanceof Error) {
+        const context = {};
+        const url = c.req?.url || "";
+        try {
+          const pathname = new URL(url, "http://localhost").pathname;
+          const routeParts = pathname.split("/").filter(Boolean);
+          if (routeParts.length >= 2) {
+            context.component = `#${routeParts[1]}`;
+          }
+        } catch {
+        }
+        sentinel.capture(error, context);
+      }
+      throw error;
+    }
+  };
+}
+export {
+  createHonoMiddleware
+};