@go-go-scope/adapter-nestjs 2.0.0

package/README.md

@@ -0,0 +1,34 @@
+# @go-go-scope/adapter-nestjs
+
+NestJS adapter for go-go-scope - provides dependency injection integration with `@Task` decorator.
+
+## Installation
+
+```bash
+npm install @go-go-scope/adapter-nestjs @nestjs/common
+```
+
+## Usage
+
+```typescript
+import { Module } from '@nestjs/common'
+import { GoGoScopeModule, Task } from '@go-go-scope/adapter-nestjs'
+
+@Module({
+  imports: [GoGoScopeModule.forRoot({ metrics: true })],
+  providers: [UserService],
+})
+class AppModule {}
+
+@Injectable()
+class UserService {
+  @Task({ retry: 'exponential', timeout: 5000 })
+  async getUser(id: string) {
+    return fetchUser(id)
+  }
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,83 @@
+import * as go_go_scope from 'go-go-scope';
+import { Scope, scope } from 'go-go-scope';
+import { OnModuleDestroy } from '@nestjs/common';
+
+declare const GOGO_ROOT_SCOPE: unique symbol;
+declare const GOGO_REQUEST_SCOPE: unique symbol;
+declare const GOGO_MODULE_OPTIONS: unique symbol;
+interface GoGoScopeModuleOptions {
+    /** Root scope name */
+    name?: string;
+    /** Enable metrics collection */
+    metrics?: boolean;
+    /** Default timeout for all requests */
+    timeout?: number;
+}
+/**
+ * Service providing access to the root application scope
+ */
+declare class GoGoScopeService implements OnModuleDestroy {
+    readonly rootScope: Scope;
+    constructor(_options?: GoGoScopeModuleOptions);
+    /**
+     * Create a new child scope from the root
+     */
+    createScope(name: string, options?: Omit<Parameters<typeof scope>[0], "parent">): Scope;
+    /**
+     * Get current metrics from the root scope
+     */
+    getMetrics(): go_go_scope.ScopeMetrics | undefined;
+    onModuleDestroy(): Promise<void>;
+}
+/**
+ * Request-scoped service that provides a unique scope per HTTP request
+ */
+declare class GoGoRequestScopeService implements OnModuleDestroy {
+    readonly requestScope: Scope;
+    constructor(_scopeService: GoGoScopeService, _options?: GoGoScopeModuleOptions);
+    /**
+     * Get the underlying scope for advanced operations
+     */
+    getScope(): Scope;
+    onModuleDestroy(): Promise<void>;
+}
+/**
+ * Decorator to execute a method within a task
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   @Task({ retry: 'exponential', timeout: 5000 })
+ *   async getUser(id: string) {
+ *     return fetchUser(id)
+ *   }
+ * }
+ * ```
+ */
+declare function Task(options?: Parameters<Scope["task"]>[1]): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * NestJS module for go-go-scope integration
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   imports: [GoGoScopeModule.forRoot({ metrics: true })],
+ *   providers: [UserService],
+ * })
+ * class AppModule {}
+ * ```
+ */
+declare class GoGoScopeModule {
+    static forRoot(options?: GoGoScopeModuleOptions): {
+        module: typeof GoGoScopeModule;
+        providers: (typeof GoGoScopeService | typeof GoGoRequestScopeService | {
+            provide: symbol;
+            useValue: GoGoScopeModuleOptions;
+        })[];
+        exports: (typeof GoGoScopeService | typeof GoGoRequestScopeService)[];
+    };
+}
+
+export { GOGO_MODULE_OPTIONS, GOGO_REQUEST_SCOPE, GOGO_ROOT_SCOPE, GoGoRequestScopeService, GoGoScopeModule, GoGoScopeService, Task };
+export type { GoGoScopeModuleOptions };

package/dist/index.mjs

@@ -0,0 +1,118 @@
+import { Injectable, Optional, Inject, Scope, Module } from '@nestjs/common';
+import { scope } from 'go-go-scope';
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+const GOGO_ROOT_SCOPE = Symbol("GOGO_ROOT_SCOPE");
+const GOGO_REQUEST_SCOPE = Symbol("GOGO_REQUEST_SCOPE");
+const GOGO_MODULE_OPTIONS = Symbol("GOGO_MODULE_OPTIONS");
+let GoGoScopeService = class {
+  rootScope;
+  constructor(_options = {}) {
+    this.rootScope = scope({
+      name: _options.name ?? "nestjs-app",
+      metrics: _options.metrics,
+      timeout: _options.timeout
+    });
+  }
+  /**
+   * Create a new child scope from the root
+   */
+  createScope(name, options) {
+    return scope({
+      parent: this.rootScope,
+      name,
+      ...options
+    });
+  }
+  /**
+   * Get current metrics from the root scope
+   */
+  getMetrics() {
+    return this.rootScope.metrics();
+  }
+  async onModuleDestroy() {
+    await this.rootScope[Symbol.asyncDispose]().catch(() => {
+    });
+  }
+};
+GoGoScopeService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject(GOGO_MODULE_OPTIONS))
+], GoGoScopeService);
+let GoGoRequestScopeService = class {
+  requestScope;
+  constructor(_scopeService, _options = {}) {
+    this.requestScope = scope({
+      parent: _scopeService.rootScope,
+      name: `request-${Date.now()}`,
+      timeout: _options.timeout
+    });
+  }
+  /**
+   * Get the underlying scope for advanced operations
+   */
+  getScope() {
+    return this.requestScope;
+  }
+  async onModuleDestroy() {
+    await this.requestScope[Symbol.asyncDispose]().catch(() => {
+    });
+  }
+};
+GoGoRequestScopeService = __decorateClass([
+  Injectable({ scope: Scope.REQUEST }),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(GOGO_MODULE_OPTIONS))
+], GoGoRequestScopeService);
+function Task(options) {
+  return (_target, _propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const scopeService = this.goGoRequestScopeService;
+      const rootScopeService = this.goGoScopeService;
+      const taskScope = scopeService?.getScope() ?? rootScopeService?.rootScope;
+      if (!taskScope) {
+        throw new Error(
+          "No scope available. Ensure GoGoScopeModule is imported."
+        );
+      }
+      const [err, result] = await taskScope.task(
+        () => originalMethod.apply(this, args),
+        options ?? {}
+      );
+      if (err) throw err;
+      return result;
+    };
+    return descriptor;
+  };
+}
+let GoGoScopeModule = class {
+  static forRoot(options = {}) {
+    return {
+      module: GoGoScopeModule,
+      providers: [
+        {
+          provide: GOGO_MODULE_OPTIONS,
+          useValue: options
+        },
+        GoGoScopeService,
+        GoGoRequestScopeService
+      ],
+      exports: [GoGoScopeService, GoGoRequestScopeService]
+    };
+  }
+};
+GoGoScopeModule = __decorateClass([
+  Module({})
+], GoGoScopeModule);
+
+export { GOGO_MODULE_OPTIONS, GOGO_REQUEST_SCOPE, GOGO_ROOT_SCOPE, GoGoRequestScopeService, GoGoScopeModule, GoGoScopeService, Task };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@go-go-scope/adapter-nestjs",
+  "version": "2.0.0",
+  "description": "NestJS adapter for go-go-scope - DI integration with @Task decorator",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "lint": "biome check --write src/",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "nestjs",
+    "adapter",
+    "go-go-scope",
+    "structured-concurrency",
+    "decorator"
+  ],
+  "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-nestjs"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "go-go-scope": "workspace:*"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.14"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@nestjs/common": "^11.1.14",
+    "@types/node": "^24",
+    "pkgroll": "^2.26.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}