@go-go-scope/adapter-hapi 2.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thelinuxlich (Alisson Cavalcante Agiani)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# @go-go-scope/adapter-hapi
+
+Hapi adapter for go-go-scope - request-scoped structured concurrency with automatic cleanup.
+
+## Installation
+
+```bash
+npm install @go-go-scope/adapter-hapi @hapi/hapi
+```
+
+## Usage
+
+### Basic
+
+```typescript
+import Hapi from '@hapi/hapi'
+import { hapiGoGoScope, getScope, getRootScope, closeHapiScope } from '@go-go-scope/adapter-hapi'
+
+const server = Hapi.server({ port: 3000 })
+
+// Register plugin
+await server.register({
+  plugin: hapiGoGoScope,
+  options: { name: 'my-api', metrics: true }
+})
+
+// Use scope in routes
+server.route({
+  method: 'GET',
+  path: '/users/{id}',
+  handler: async (request) => {
+    const [err, user] = await request.scope.task(
+      () => fetchUser(request.params.id),
+      { retry: 'exponential', timeout: 5000 }
+    )
+    
+    if (err) {
+      return { error: err.message }
+    }
+    
+    return user
+  }
+})
+
+await server.start()
+console.log('Server running at:', server.info.uri)
+```
+
+### Options
+
+```typescript
+await server.register({
+  plugin: hapiGoGoScope,
+  options: {
+    name: 'my-api',      // Root scope name
+    metrics: true,        // Enable metrics collection
+    timeout: 30000      // Default request timeout
+  }
+})
+```
+
+### Accessing Root Scope
+
+```typescript
+// From server instance
+const rootScope = getRootScope(server)
+const metrics = rootScope.metrics()
+console.log('App metrics:', metrics)
+
+// Or directly from request
+server.route({
+  method: 'GET',
+  path: '/health',
+  handler: async (request) => {
+    const rootScope = request.rootScope
+    return { status: 'ok', metrics: rootScope.metrics() }
+  }
+})
+```
+
+### Graceful Shutdown
+
+```typescript
+process.on('SIGTERM', async () => {
+  await closeHapiScope(server)
+  await server.stop()
+})
+```
+
+## API
+
+### `hapiGoGoScope`
+
+Hapi plugin that provides request-scoped structured concurrency.
+
+**Options:**
+- `name`: Root scope name (default: 'hapi-app')
+- `metrics`: Enable metrics collection (default: false)
+- `timeout`: Default request timeout in ms
+
+### `getScope(request)`
+
+Get the request-scoped scope from Hapi request.
+
+### `getRootScope(server)`
+
+Get the root application scope from Hapi server.
+
+### `closeHapiScope(server)`
+
+Gracefully shutdown the root scope (for use in SIGTERM handlers).
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,81 @@
+import { Server, Request, Plugin } from '@hapi/hapi';
+import { Scope } from 'go-go-scope';
+
+/**
+ * Hapi adapter for go-go-scope
+ * Provides request-scoped structured concurrency for Hapi applications
+ */
+
+declare module "@hapi/hapi" {
+    interface Request {
+        scope: Scope<Record<string, unknown>>;
+        rootScope: Scope<Record<string, unknown>>;
+    }
+    interface Server {
+        rootScope: Scope<Record<string, unknown>>;
+    }
+}
+interface HapiGoGoScopeOptions {
+    /** Root scope name */
+    name?: string;
+    /** Enable metrics collection */
+    metrics?: boolean;
+    /** Default timeout for all requests */
+    timeout?: number;
+}
+/**
+ * Hapi plugin for go-go-scope integration
+ *
+ * @example
+ * ```typescript
+ * import Hapi from '@hapi/hapi'
+ * import { hapiGoGoScope } from '@go-go-scope/adapter-hapi'
+ *
+ * const server = Hapi.server({ port: 3000 })
+ * await server.register({
+ *   plugin: hapiGoGoScope,
+ *   options: { name: 'my-api', metrics: true }
+ * })
+ *
+ * server.route({
+ *   method: 'GET',
+ *   path: '/users/{id}',
+ *   handler: async (request) => {
+ *     const [err, user] = await request.scope.task(
+ *       () => fetchUser(request.params.id),
+ *       { retry: 'exponential' }
+ *     )
+ *
+ *     if (err) {
+ *       return { error: err.message }
+ *     }
+ *     return user
+ *   }
+ * })
+ * ```
+ */
+declare const hapiGoGoScope: Plugin<HapiGoGoScopeOptions>;
+/**
+ * Get the request-scoped scope from Hapi request
+ */
+declare function getScope(request: Request): Scope<Record<string, unknown>>;
+/**
+ * Get the root application scope from Hapi server
+ */
+declare function getRootScope(server: Server): Scope<Record<string, unknown>>;
+/**
+ * Graceful shutdown helper for Hapi applications
+ * Disposes the root scope when the server is closing
+ *
+ * @example
+ * ```typescript
+ * process.on('SIGTERM', async () => {
+ *   await closeHapiScope(server)
+ *   await server.stop()
+ * })
+ * ```
+ */
+declare function closeHapiScope(server: Server): Promise<void>;
+
+export { closeHapiScope, getRootScope, getScope, hapiGoGoScope };
+export type { HapiGoGoScopeOptions };

package/dist/index.mjs

@@ -0,0 +1,60 @@
+import { scope } from 'go-go-scope';
+
+const hapiGoGoScope = {
+  name: "hapi-go-go-scope",
+  version: "2.1.0",
+  register: async (server, options) => {
+    const { name = "hapi-app", metrics = false, timeout } = options;
+    const rootScope = scope({ name, metrics });
+    server.rootScope = rootScope;
+    server.decorate("request", "scope", null);
+    server.decorate("request", "rootScope", rootScope);
+    server.ext("onRequest", (request, h) => {
+      const scopeOptions = {
+        parent: rootScope,
+        // biome-ignore lint/suspicious/noExplicitAny: Hapi request info access
+        name: `request-${request.id || request.info.id}`
+      };
+      if (timeout) scopeOptions.timeout = timeout;
+      request.scope = scope(scopeOptions);
+      return h.continue;
+    });
+    server.ext("onPostResponse", async (request, h) => {
+      const requestScope = request.scope;
+      if (requestScope) {
+        await requestScope[Symbol.asyncDispose]().catch(() => {
+        });
+      }
+      return h.continue;
+    });
+    server.ext("onPostStop", async () => {
+      await rootScope[Symbol.asyncDispose]().catch(() => {
+      });
+    });
+  }
+};
+function getScope(request) {
+  const requestScope = request.scope;
+  if (!requestScope) {
+    throw new Error(
+      "Scope not available. Ensure hapiGoGoScope plugin is registered."
+    );
+  }
+  return requestScope;
+}
+function getRootScope(server) {
+  if (!server.rootScope) {
+    throw new Error(
+      "Root scope not available. Ensure hapiGoGoScope plugin is registered."
+    );
+  }
+  return server.rootScope;
+}
+async function closeHapiScope(server) {
+  if (server.rootScope) {
+    await server.rootScope[Symbol.asyncDispose]().catch(() => {
+    });
+  }
+}
+
+export { closeHapiScope, getRootScope, getScope, hapiGoGoScope };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@go-go-scope/adapter-hapi",
+  "version": "2.2.0",
+  "description": "Hapi adapter for go-go-scope - request-scoped structured concurrency",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "keywords": [
+    "hapi",
+    "adapter",
+    "go-go-scope",
+    "structured-concurrency",
+    "plugin"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "author": "thelinuxlich",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thelinuxlich/go-go-scope.git",
+    "directory": "packages/adapter-hapi"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "go-go-scope": "2.2.0"
+  },
+  "peerDependencies": {
+    "@hapi/hapi": "^21.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@hapi/hapi": "^21.4.6",
+    "@types/node": "^24",
+    "pkgroll": "^2.26.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "lint": "biome check --write src/",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}