@stacksjs/bun-router 0.0.4 → 0.0.6

package/src/query-builder-integration.ts

@@ -0,0 +1,137 @@
+import type { Model, QueryBuilderModelResolver } from './model-binding'
+
+/**
+ * Integration layer for bun-query-builder with model binding
+ */
+export class QueryBuilderIntegration {
+  private queryBuilder: any
+  private resolvers = new Map<string, QueryBuilderModelResolver>()
+
+  constructor(queryBuilder: any) {
+    this.queryBuilder = queryBuilder
+  }
+
+  /**
+   * Register a model resolver and inject the query builder
+   */
+  registerResolver<TModel extends Model>(
+    name: string,
+    resolver: QueryBuilderModelResolver<TModel>,
+  ): void {
+    // Inject the query builder instance
+    resolver.queryBuilder = this.queryBuilder
+    this.resolvers.set(name, resolver)
+  }
+
+  /**
+   * Get a registered resolver
+   */
+  getResolver<TModel extends Model>(name: string): QueryBuilderModelResolver<TModel> | undefined {
+    return this.resolvers.get(name) as QueryBuilderModelResolver<TModel> | undefined
+  }
+
+  /**
+   * Resolve a model by name and ID
+   */
+  async resolveModel<TModel extends Model>(
+    name: string,
+    id: string | number,
+    keyName?: string,
+    context: Record<string, Model> = {},
+  ): Promise<TModel | null> {
+    const resolver = this.getResolver<TModel>(name)
+    if (!resolver) {
+      throw new Error(`No resolver registered for model: ${name}`)
+    }
+
+    // Apply constraints if available
+    if (resolver.applyConstraints) {
+      const query = this.queryBuilder
+        .select()
+        .from(resolver.table)
+        .where(keyName || resolver.getRouteKeyName?.() || 'id', '=', id)
+
+      const constrainedQuery = resolver.applyConstraints(query, context)
+      return await constrainedQuery.first() || null
+    }
+
+    // Use the resolver's find method
+    return await resolver.find(id, keyName)
+  }
+
+  /**
+   * Resolve a model or throw an error
+   */
+  async resolveModelOrFail<TModel extends Model>(
+    name: string,
+    id: string | number,
+    keyName?: string,
+    context: Record<string, Model> = {},
+  ): Promise<TModel> {
+    const model = await this.resolveModel<TModel>(name, id, keyName, context)
+    if (!model) {
+      throw new Error(`${name} not found with ${keyName || 'id'}: ${id}`)
+    }
+    return model
+  }
+}
+
+/**
+ * Create a query builder integration instance
+ */
+export function createQueryBuilderIntegration(queryBuilder: any): QueryBuilderIntegration {
+  return new QueryBuilderIntegration(queryBuilder)
+}
+
+/**
+ * Helper to create a basic model resolver using the query builder
+ */
+export function createBasicResolver<TModel extends Model>(
+  tableName: string,
+  options: {
+    keyName?: string
+    transform?: (row: any) => TModel
+  } = {},
+): QueryBuilderModelResolver<TModel> {
+  const { keyName = 'id', transform } = options
+
+  return {
+    table: tableName,
+    queryBuilder: undefined, // Will be injected
+
+    async find(id: string | number, searchKey = keyName): Promise<TModel | null> {
+      if (!this.queryBuilder) {
+        throw new Error(`Query builder not initialized for table: ${tableName}`)
+      }
+
+      try {
+        const result = await this.queryBuilder
+          .select()
+          .from(this.table)
+          .where(searchKey, '=', id)
+          .first()
+
+        if (!result)
+          return null
+
+        return transform ? transform(result) : result as TModel
+      }
+      catch (error) {
+        console.error(`Error finding ${tableName}:`, error)
+        return null
+      }
+    },
+
+    async findOrFail(id: string | number, searchKey = keyName): Promise<TModel> {
+      const model = await this.find(id, searchKey)
+      if (!model) {
+        throw new Error(`${tableName} not found with ${searchKey}: ${id}`)
+      }
+      return model
+    },
+
+    getRouteKeyName(): string {
+      return keyName
+    },
+  }
+}

package/src/request/context.ts

@@ -0,0 +1,62 @@
+/**
+ * Request Context
+ *
+ * AsyncLocalStorage-backed access to the current request. The Router wires
+ * `runWithRequest()` automatically around handler/middleware invocation and
+ * calls `setCurrentRequest()` once the request has been enhanced with route
+ * params. User code reaches the active request via `request()` or
+ * `getCurrentRequest()` without having to thread it through call stacks.
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks'
+import type { EnhancedRequest } from '../types'
+
+interface RequestContextStore {
+  current: EnhancedRequest | null
+}
+
+const storage: AsyncLocalStorage<RequestContextStore> = new AsyncLocalStorage<RequestContextStore>()
+
+/**
+ * Run `fn` inside an AsyncLocalStorage scope where `request()` and
+ * `getCurrentRequest()` resolve to `initial`. The Router calls this around
+ * each request automatically.
+ */
+export function runWithRequest<T>(initial: EnhancedRequest | Request, fn: () => T | Promise<T>): T | Promise<T> {
+  return storage.run({ current: initial as EnhancedRequest }, fn)
+}
+
+/**
+ * Update the request stored in the current context. The Router calls this
+ * after enhancing the request with matched route params, so subsequent
+ * `request()` calls see the enhanced object.
+ */
+export function setCurrentRequest(req: EnhancedRequest): void {
+  const store = storage.getStore()
+  if (store)
+    store.current = req
+}
+
+/**
+ * Returns the active request, or `undefined` when called outside a request
+ * scope. Prefer `request()` when the request is required.
+ */
+export function getCurrentRequest(): EnhancedRequest | undefined {
+  return storage.getStore()?.current ?? undefined
+}
+
+/**
+ * Returns the active request. Throws when called outside a request scope —
+ * typically that means it was called before the Router established context
+ * (e.g. during module initialization) or inside a fire-and-forget callback
+ * that escaped the AsyncLocalStorage frame.
+ */
+export function request(): EnhancedRequest {
+  const req = getCurrentRequest()
+  if (!req) {
+    throw new Error(
+      'request() called outside a request scope. It can only be invoked from within a route handler or middleware.',
+    )
+  }
+  return req
+}