@go-go-scope/adapter-solid-start 2.7.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,122 @@
+import { FetchEvent } from '@solidjs/start/server';
+import { Scope } from 'go-go-scope';
+
+/**
+ * SolidStart adapter for go-go-scope
+ * Provides request-scoped structured concurrency for SolidStart applications
+ */
+
+declare module "@solidjs/start/server" {
+    interface FetchEvent {
+        scope: Scope;
+        request: Request;
+        respondWith(response: Response | Promise<Response>): Promise<void>;
+    }
+}
+interface SolidStartGoGoScopeOptions {
+    /** Root scope name */
+    name?: string;
+    /** Default timeout for all requests in ms */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * SolidStart middleware for go-go-scope integration
+ *
+ * @example
+ * ```typescript
+ * // src/middleware.ts
+ * import { createMiddleware } from '@solidjs/start/middleware'
+ * import { solidStartGoGoScope } from '@go-go-scope/adapter-solid-start'
+ *
+ * export default createMiddleware({
+ *   onRequest: [
+ *     solidStartGoGoScope({
+ *       name: 'my-solid-app',
+ *       timeout: 30000
+ *     })
+ *   ]
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/users/[id].ts
+ * import { json } from '@solidjs/router'
+ * import { getScope } from '@go-go-scope/adapter-solid-start'
+ * import type { APIEvent } from '@solidjs/start/server'
+ *
+ * export const GET = async (event: APIEvent) => {
+ *   const s = getScope(event)
+ *   const id = event.params.id
+ *
+ *   const [err, user] = await s.task(
+ *     () => fetchUser(id),
+ *     { retry: 'exponential', timeout: 5000 }
+ *   )
+ *
+ *   if (err) {
+ *     return json({ error: err.message }, { status: 500 })
+ *   }
+ *   return json(user)
+ * }
+ * ```
+ */
+declare function solidStartGoGoScope(options?: SolidStartGoGoScopeOptions): (event: FetchEvent) => Promise<void>;
+/**
+ * Helper to get the current scope from the fetch event
+ *
+ * @example
+ * ```typescript
+ * const GET = async (event: APIEvent) => {
+ *   const s = getScope(event)
+ *   const [err, data] = await s.task(() => fetchData())
+ *   // ...
+ * }
+ * ```
+ */
+declare function getScope(event: {
+    scope?: Scope<any>;
+}): Scope<any>;
+/**
+ * Helper to create an API handler with automatic scope integration
+ *
+ * @example
+ * ```typescript
+ * import { defineScopedHandler } from '@go-go-scope/adapter-solid-start'
+ * import type { APIEvent } from '@solidjs/start/server'
+ *
+ * export const GET = defineScopedHandler(async (event, scope) => {
+ *   const [err, users] = await scope.task(() => fetchUsers())
+ *   if (err) return json({ error: err.message }, { status: 500 })
+ *   return json(users)
+ * })
+ * ```
+ */
+declare function defineScopedHandler<T>(handler: (event: FetchEvent, scope: Scope<any>) => Promise<T>): (event: FetchEvent) => Promise<T>;
+/**
+ * Server function wrapper with scope access
+ * For use with SolidStart's createServerData$, createServerAction$, etc.
+ *
+ * @example
+ * ```typescript
+ * // src/lib/users.ts
+ * import { createServerAction$ } from '@solidjs/router'
+ * import { withScope } from '@go-go-scope/adapter-solid-start'
+ *
+ * export const createUser = withScope(async (scope, formData: FormData) => {
+ *   const name = formData.get('name') as string
+ *   const [err, user] = await scope.task(() => db.insert('users', { name }))
+ *   if (err) throw err
+ *   return user
+ * })
+ *
+ * // Usage in component
+ * const [, createUserAction] = createServerAction$(createUser)
+ * ```
+ */
+declare function withScope<TArgs extends unknown[], TReturn>(fn: (scope: Scope<any>, ...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+
+export { defineScopedHandler, getScope, solidStartGoGoScope, withScope };
+export type { SolidStartGoGoScopeOptions };

package/dist/index.mjs

@@ -0,0 +1,60 @@
+import { scope } from 'go-go-scope';
+
+function solidStartGoGoScope(options = {}) {
+  const { name = "solid-start-app", timeout, debug = false } = options;
+  const rootScope = scope({ name });
+  if (debug) {
+    console.log(`[go-go-scope] Root scope created: ${name}`);
+  }
+  return async (event) => {
+    const scopeOptions = {
+      parent: rootScope,
+      name: `request-${event.request.url}`
+    };
+    if (timeout) scopeOptions.timeout = timeout;
+    event.scope = scope(scopeOptions);
+    if (debug) {
+      console.log(`[go-go-scope] Request scope created: ${scopeOptions.name}`);
+    }
+    const originalRespondWith = event.respondWith.bind(event);
+    event.respondWith = async (response) => {
+      try {
+        return await originalRespondWith(response);
+      } finally {
+        await event.scope[Symbol.asyncDispose]().catch(() => {
+        });
+        if (debug) {
+          console.log(`[go-go-scope] Request scope disposed`);
+        }
+      }
+    };
+  };
+}
+function getScope(event) {
+  const s = event.scope;
+  if (!s) {
+    throw new Error(
+      "No scope found in event. Make sure the solidStartGoGoScope middleware is registered."
+    );
+  }
+  return s;
+}
+function defineScopedHandler(handler) {
+  return async (event) => {
+    const s = getScope(event);
+    return handler(event, s);
+  };
+}
+function withScope(fn) {
+  return async (...args) => {
+    const s = scope({ name: "solid-start-server-fn" });
+    try {
+      return await fn(s, ...args);
+    } finally {
+      await s[Symbol.asyncDispose]().catch(() => {
+      });
+    }
+  };
+}
+
+export { defineScopedHandler, getScope, solidStartGoGoScope, withScope };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@go-go-scope/adapter-solid-start",
+  "version": "2.7.0",
+  "description": "SolidStart adapter for go-go-scope - Request-scoped structured concurrency for SolidStart applications",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "keywords": [
+    "go-go-scope",
+    "solid",
+    "solidjs",
+    "solid-start",
+    "structured-concurrency"
+  ],
+  "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-solid-start"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "go-go-scope": "2.7.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@solidjs/start": "^1.0.0",
+    "@types/node": "^24",
+    "pkgroll": "^2.26.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@solidjs/start": "^1.0.0",
+    "@solidjs/router": "^0.13.0"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "test": "vitest run --passWithNoTests",
+    "lint": "biome check --write src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}