@dotdo/postgres 0.1.1 → 0.1.3

package/src/pglite/workers-pglite.ts

@@ -11,6 +11,11 @@
  * - Properly handles fsBundle as ArrayBuffer or Blob
  * - Provides query/exec/transaction interface compatible with PostgresDO
  *
+ * IMPORTANT: This module uses dynamic imports to ensure environment patches
+ * are applied BEFORE pglite.js is evaluated. The Emscripten-generated code
+ * checks `typeof WorkerGlobalScope` at module load time, which must happen
+ * AFTER we've patched the global environment.
+ *
  * @example
  * ```typescript
  * import { createWorkersPGLite } from './workers-pglite'
@@ -28,11 +33,14 @@
  * ```
  */
 
-import { PGlite, type PGliteOptions, type DebugLevel } from '@dotdo/pglite'
+// NOTE: We intentionally DO NOT import @dotdo/pglite at the top level.
+// The import must be done dynamically AFTER applying environment patches.
+// See the create() method for details.
+
+// Type imports are safe - they don't cause module evaluation
+import type { PGliteOptions, DebugLevel } from '@dotdo/pglite'
 
 // Type alias for backwards compatibility
-type PGliteWorkers = PGlite
-type PGliteWorkersOptions = PGliteOptions
 type QueryResult<T = unknown> = {
   rows: T[]
   fields: { name: string; dataTypeID: number }[]
@@ -91,24 +99,107 @@ export interface WorkersPGLiteLike {
   ready?: boolean
 }
 
+// Flag to track if patches have been applied
+let patchesApplied = false
+
 /**
- * Wrapper around PGliteWorkers that provides a compatible interface
+ * Apply Cloudflare Workers compatibility patches for Emscripten.
+ *
+ * CRITICAL: This must be called BEFORE importing @dotdo/pglite.
+ * The pglite.js module checks `typeof WorkerGlobalScope` at module load time
+ * to determine if it's running in a web worker. In Cloudflare Workers,
+ * WorkerGlobalScope exists but the environment is not a full web worker,
+ * causing Emscripten to use incompatible code paths.
+ *
+ * This function patches the global environment to make Emscripten think
+ * it's running in a regular web browser environment.
+ */
+function applyWorkersPatches(): void {
+  if (patchesApplied) {
+    return
+  }
+
+  const g = globalThis as Record<string, unknown>
+
+  // Create a minimal browser-like environment
+  // This helps Emscripten's ENVIRONMENT=web mode work in CF Workers
+  const mockLocation = {
+    href: 'https://localhost/',
+    pathname: '/',
+    protocol: 'https:',
+    host: 'localhost',
+    hostname: 'localhost',
+    port: '',
+    search: '',
+    hash: '',
+    origin: 'https://localhost',
+  }
+
+  g.window = {
+    sessionStorage: {},
+    localStorage: {},
+    location: mockLocation,
+    encodeURIComponent: encodeURIComponent,
+    decodeURIComponent: decodeURIComponent,
+    encodeURI: encodeURI,
+    decodeURI: decodeURI,
+    atob: atob,
+    btoa: btoa,
+    fetch: fetch,
+    URL: URL,
+    Blob: Blob,
+    crypto: crypto,
+  }
+
+  g.document = {
+    createElement: () => ({}),
+    currentScript: null,
+    location: mockLocation,
+  }
+
+  g.location = mockLocation
+  g.sessionStorage = {}
+
+  // CRITICAL: Disable WorkerGlobalScope to prevent Emscripten from detecting
+  // this as a worker and trying to use worker-specific APIs that CF Workers
+  // don't fully support
+  g.WorkerGlobalScope = undefined
+
+  patchesApplied = true
+}
+
+/**
+ * Wrapper around PGlite that provides a compatible interface
  * for PostgresDO and handles fsBundle conversion
  */
 export class WorkersPGLite implements WorkersPGLiteLike {
-  private pglite: PGliteWorkers
+  // Using 'any' here because PGlite type is not available at compile time
+  // due to dynamic import. The actual type is PGlite from @dotdo/pglite.
+  private pglite: any
   private _ready: boolean = false
 
-  private constructor(pglite: PGliteWorkers) {
+  private constructor(pglite: any) {
     this.pglite = pglite
     this._ready = true
   }
 
   /**
    * Create a new WorkersPGLite instance
+   *
+   * IMPORTANT: This method uses dynamic import to load @dotdo/pglite
+   * AFTER applying environment patches. This is necessary because
+   * pglite.js evaluates environment detection code at module load time.
    */
   static async create(options: WorkersPGLiteOptions): Promise<WorkersPGLite> {
-    // Convert fsBundle to ArrayBuffer if needed
+    // Step 1: Apply Cloudflare Workers compatibility patches FIRST
+    // This MUST happen before importing @dotdo/pglite
+    applyWorkersPatches()
+
+    // Step 2: Now dynamically import @dotdo/pglite
+    // The patches are already applied, so Emscripten will see the correct environment
+    const { PGlite } = await import('@dotdo/pglite')
+
+    // Step 3: Convert fsBundle to ArrayBuffer if needed
     let fsBundleBuffer: ArrayBuffer
 
     if (options.fsBundle instanceof ArrayBuffer) {
@@ -135,16 +226,48 @@ export class WorkersPGLite implements WorkersPGLiteLike {
       fsBundleBuffer = options.fsBundle as ArrayBuffer
     }
 
-    // Create PGliteWorkers instance
+    // Step 4: Create PGlite instance
     // fsBundle expects Blob | File, so wrap the ArrayBuffer in a Blob
-    const pgliteOptions: PGliteWorkersOptions = {
+    const pgliteOptions: PGliteOptions = {
       wasmModule: options.wasmModule,
       fsBundle: new Blob([fsBundleBuffer]),
       database: options.database ?? 'postgres',
       debug: options.debug ?? 0,
     }
 
-    const pglite = await PGlite.create(pgliteOptions)
+    console.log('[WorkersPGLite] Starting PGlite initialization...')
+    console.log('[WorkersPGLite] wasmModule type:', typeof options.wasmModule)
+    console.log('[WorkersPGLite] fsBundle size:', fsBundleBuffer.byteLength)
+    console.log('[WorkersPGLite] Patches applied before import:', patchesApplied)
+
+    // Environment debug info
+    const g = globalThis as Record<string, unknown>
+    console.log('[WorkersPGLite] ENV CHECK - window:', typeof g.window)
+    console.log('[WorkersPGLite] ENV CHECK - WorkerGlobalScope:', typeof g.WorkerGlobalScope)
+    console.log('[WorkersPGLite] ENV CHECK - document:', typeof g.document)
+    console.log('[WorkersPGLite] ENV CHECK - location:', typeof g.location)
+    console.log('[WorkersPGLite] ENV CHECK - process:', typeof g.process)
+
+    let pglite: InstanceType<typeof PGlite>
+    try {
+      console.log('[WorkersPGLite] Calling PGlite.create()...')
+      pglite = await PGlite.create(pgliteOptions)
+      console.log('[WorkersPGLite] PGlite created successfully')
+    } catch (error) {
+      console.error('[WorkersPGLite] PGlite.create failed:', error)
+      // Try to get more information about the error
+      if (error instanceof Error) {
+        console.error('[WorkersPGLite] Error name:', error.name)
+        console.error('[WorkersPGLite] Error message:', error.message)
+        console.error('[WorkersPGLite] Error stack:', error.stack)
+      }
+      throw error
+    }
+
+    // Note: We intentionally do NOT restore the original globals after initialization
+    // because pglite.js caches the environment detection results and may still need
+    // the mocked globals for subsequent operations.
+
     return new WorkersPGLite(pglite)
   }
 
@@ -174,7 +297,11 @@ export class WorkersPGLite implements WorkersPGLiteLike {
   }> {
     // Pass parameters directly to PGlite which uses the PostgreSQL
     // Extended Query protocol with proper prepared statement safety
-    const result = await this.pglite.query<T>(sql, params)
+    const result = await this.pglite.query(sql, params) as {
+      rows: T[]
+      fields?: { name: string; dataTypeID: number }[]
+      affectedRows?: number
+    }
 
     const queryResult: {
       rows: T[]
@@ -221,4 +348,6 @@ export function isWorkersPGLite(value: unknown): value is WorkersPGLite {
 }
 
 // Re-export types for convenience
-export type { PGliteWorkersOptions, QueryResult }
+export type { QueryResult }
+// PGliteWorkersOptions is now just WorkersPGLiteOptions
+export type PGliteWorkersOptions = WorkersPGLiteOptions

package/src/worker/auth.ts

@@ -737,9 +737,17 @@ const DEFAULT_CACHE_CONFIG: TokenCacheConfig = {
 
 /**
  * Global token validation cache instance.
+ * Lazy-initialized to avoid global scope async operations in Cloudflare Workers.
  * @internal
  */
-let tokenCache = new TokenCache(DEFAULT_CACHE_CONFIG)
+let tokenCache: TokenCache | null = null
+
+function getTokenCache(): TokenCache {
+  if (!tokenCache) {
+    tokenCache = new TokenCache(DEFAULT_CACHE_CONFIG)
+  }
+  return tokenCache
+}
 
 /**
  * Reconfigures the global token cache with new settings.
@@ -756,7 +764,9 @@ let tokenCache = new TokenCache(DEFAULT_CACHE_CONFIG)
  * ```
  */
 export function configureTokenCache(config: TokenCacheConfig): void {
-  tokenCache.dispose()
+  if (tokenCache) {
+    tokenCache.dispose()
+  }
   tokenCache = new TokenCache({
     ...DEFAULT_CACHE_CONFIG,
     ...config,
@@ -769,7 +779,7 @@ export function configureTokenCache(config: TokenCacheConfig): void {
  * @returns Cache stats including hits, misses, and size
  */
 export function getTokenCacheStats(): CacheStats {
-  return tokenCache.stats
+  return getTokenCache().stats
 }
 
 /**
@@ -779,7 +789,7 @@ export function getTokenCacheStats(): CacheStats {
  *           a thundering herd to the OAuth provider.
  */
 export function clearTokenCache(): void {
-  tokenCache.clear()
+  getTokenCache().clear()
 }
 
 export { extractBearerToken }
@@ -902,7 +912,8 @@ export function createAuthMiddleware(config: AuthConfig = {}): MiddlewareHandler
       )
     }
 
-    let validationResult = tokenCache.get(token)
+    const cache = getTokenCache()
+    let validationResult = cache.get(token)
 
     if (!validationResult) {
       validationResult = validateToken
@@ -910,7 +921,7 @@ export function createAuthMiddleware(config: AuthConfig = {}): MiddlewareHandler
         : await sharedValidateToken(token, { oauthUrl })
 
       if (validationResult.valid) {
-        tokenCache.set(token, validationResult, tokenCacheTTL)
+        cache.set(token, validationResult, tokenCacheTTL)
       }
     }