@go-go-scope/adapter-remix 2.5.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/dist/index.d.mts

@@ -0,0 +1,119 @@
+import { LoaderFunctionArgs, ActionFunctionArgs } from '@remix-run/server-runtime';
+import { Scope } from 'go-go-scope';
+
+/**
+ * Remix adapter for go-go-scope
+ *
+ * Provides structured concurrency for Remix loaders and actions
+ * with automatic cleanup.
+ *
+ * @example
+ * ```typescript
+ * // app/routes/users.tsx
+ * import { withScopeLoader, withScopeAction } from '@go-go-scope/adapter-remix'
+ * import { json } from '@remix-run/node'
+ *
+ * export const loader = withScopeLoader(async ({ request, scope }) => {
+ *   const [err, users] = await scope.task(() => fetchUsers())
+ *   if (err) throw new Response(err.message, { status: 500 })
+ *   return json({ users })
+ * })
+ *
+ * export const action = withScopeAction(async ({ request, scope }) => {
+ *   const formData = await request.formData()
+ *   const [err, result] = await scope.task(() => createUser(formData))
+ *   if (err) return json({ error: err.message }, { status: 400 })
+ *   return json({ result })
+ * })
+ * ```
+ */
+
+/**
+ * Remix context with scope
+ */
+interface RemixContext<T extends Record<string, unknown> = Record<string, never>> {
+    /** The scope for this request */
+    scope: Scope<T>;
+    /** Request signal for cancellation */
+    signal: AbortSignal;
+}
+/**
+ * Options for scope configuration
+ */
+interface RemixScopeOptions<T extends Record<string, unknown> = Record<string, never>> {
+    /** Scope timeout in milliseconds */
+    timeout?: number;
+    /** Initial services to provide */
+    services?: T;
+}
+/**
+ * Wrap a Remix loader with scope
+ *
+ * @example
+ * ```typescript
+ * // app/routes/users.tsx
+ * import { withScopeLoader } from '@go-go-scope/adapter-remix'
+ * import { json } from '@remix-run/node'
+ *
+ * export const loader = withScopeLoader(async ({ request, scope }) => {
+ *   const url = new URL(request.url)
+ *   const page = url.searchParams.get('page') || '1'
+ *
+ *   const [err, users] = await scope.task(() => fetchUsers(page))
+ *   if (err) throw new Response(err.message, { status: 500 })
+ *
+ *   return json({ users })
+ * })
+ * ```
+ */
+declare function withScopeLoader<T extends Record<string, unknown>, R>(loader: (args: LoaderFunctionArgs & RemixContext<T>) => Promise<R> | R, options?: RemixScopeOptions<T>): (args: LoaderFunctionArgs) => Promise<R>;
+/**
+ * Wrap a Remix action with scope
+ *
+ * @example
+ * ```typescript
+ * // app/routes/users.tsx
+ * import { withScopeAction } from '@go-go-scope/adapter-remix'
+ * import { json } from '@remix-run/node'
+ *
+ * export const action = withScopeAction(async ({ request, scope }) => {
+ *   const formData = await request.formData()
+ *
+ *   const [err, result] = await scope.task(() => createUser(formData))
+ *   if (err) return json({ error: err.message }, { status: 400 })
+ *
+ *   return json({ result })
+ * })
+ * ```
+ */
+declare function withScopeAction<T extends Record<string, unknown>, R>(action: (args: ActionFunctionArgs & RemixContext<T>) => Promise<R> | R, options?: RemixScopeOptions<T>): (args: ActionFunctionArgs) => Promise<R>;
+/**
+ * Create reusable scope configuration for loaders/actions
+ *
+ * @example
+ * ```typescript
+ * // app/lib/scope.ts
+ * import { createRemixScope } from '@go-go-scope/adapter-remix'
+ * import { db } from './db'
+ *
+ * export const remixScope = createRemixScope({
+ *   timeout: 10000,
+ *   services: { db }
+ * })
+ *
+ * // app/routes/users.tsx
+ * import { remixScope } from '~/lib/scope'
+ *
+ * export const loader = remixScope.loader(async ({ request, scope }) => {
+ *   const db = scope.use('db')
+ *   // ...
+ * })
+ * ```
+ */
+declare function createRemixScope<T extends Record<string, unknown>>(config: RemixScopeOptions<T>): {
+    loader: <R>(loader: (args: LoaderFunctionArgs & RemixContext<T>) => Promise<R> | R) => (args: LoaderFunctionArgs) => Promise<R>;
+    action: <R>(action: (args: ActionFunctionArgs & RemixContext<T>) => Promise<R> | R) => (args: ActionFunctionArgs) => Promise<R>;
+};
+
+export { createRemixScope, withScopeAction, withScopeLoader };
+export type { RemixContext, RemixScopeOptions };

package/dist/index.mjs

@@ -0,0 +1,109 @@
+import { scope } from 'go-go-scope';
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+function withScopeLoader(loader, options = {}) {
+  return async (args) => {
+    var _stack = [];
+    try {
+      const s = __using(_stack, scope({
+        timeout: options.timeout,
+        signal: args.signal,
+        name: `remix-loader-${args.request.method}-${new URL(args.request.url).pathname}`
+      }), true);
+      if (options.services) {
+        for (const [key, value] of Object.entries(options.services)) {
+          s.provide(key, value);
+        }
+      }
+      const context = {
+        scope: s,
+        signal: s.signal
+      };
+      return await loader({ ...args, ...context });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  };
+}
+function withScopeAction(action, options = {}) {
+  return async (args) => {
+    var _stack = [];
+    try {
+      const s = __using(_stack, scope({
+        timeout: options.timeout,
+        signal: args.signal,
+        name: `remix-action-${args.request.method}-${new URL(args.request.url).pathname}`
+      }), true);
+      if (options.services) {
+        for (const [key, value] of Object.entries(options.services)) {
+          s.provide(key, value);
+        }
+      }
+      const context = {
+        scope: s,
+        signal: s.signal
+      };
+      return await action({ ...args, ...context });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  };
+}
+function createRemixScope(config) {
+  return {
+    loader: (loader) => withScopeLoader(loader, config),
+    action: (action) => withScopeAction(action, config)
+  };
+}
+
+export { createRemixScope, withScopeAction, withScopeLoader };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@go-go-scope/adapter-remix",
+  "version": "2.5.0",
+  "description": "Remix adapter for go-go-scope",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "structured-concurrency",
+    "remix",
+    "loader",
+    "action",
+    "typescript"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "peerDependencies": {
+    "go-go-scope": "^2.4.0",
+    "@remix-run/server-runtime": "^2.0.0"
+  },
+  "devDependencies": {
+    "@remix-run/server-runtime": "^2.0.0",
+    "@types/node": "^22.13.15",
+    "pkgroll": "^2.6.1",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1",
+    "go-go-scope": "2.5.0"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check --fix src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}