test(deno): add integration tests for deno

.github/workflows/ci.yml

@@ -53,7 +53,7 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         node: ['20']
-        deno: ['2.x']
+        deno: ['1.x', '2.x']
 
     runs-on: ${{ matrix.os }}
 
@@ -78,12 +78,22 @@ jobs:
         run: |
           supabase start
 
-      - name: Run tests
+      - name: Build
         run: |
           npm clean-install
+          npm run build
+
+      - name: Run tests
+        if: ${{ matrix.deno == '2.x' }}
+        run: |
           npm run test:integration || npm run test:integration
           npm run test:integration:browser
 
+      - name: Run Deno tests
+        run: |
+          cd test/deno
+          npm test || npm test
+
       - name: Stop Supabase
         run: |
           supabase stop

package.json

@@ -31,7 +31,7 @@
     "test": "run-s test:types test:run",
     "test:all": "run-s test:types test:run test:integration test:integration:browser",
     "test:run": "jest --runInBand --detectOpenHandles",
-    "test:coverage": "jest --runInBand --coverage --testPathIgnorePatterns=\"test/integration.*\"",
+    "test:coverage": "jest --runInBand --coverage --testPathIgnorePatterns=\"test/integration.*|test/deno.*\"",
     "test:integration": "jest --runInBand --detectOpenHandles test/integration.test.ts",
     "test:integration:browser": "deno test --allow-all test/integration.browser.test.ts",
     "test:db": "cd infra/db && docker-compose down && docker-compose up -d && sleep 5",
@@ -54,7 +54,7 @@
     "@sebbo2002/semantic-release-jsr": "^1.0.0",
     "@solana/wallet-standard-features": "^1.3.0",
     "@types/jest": "^29.2.5",
-    "husky": "^4.3.0",
+    "husky": "^4.3.8",
     "jest": "^29.3.1",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.5.1",

supabase/.temp/cli-latest

@@ -1 +1 @@
-v2.22.12
+v2.24.3

test/deno/.gitignore

@@ -0,0 +1 @@
+deno.json

test/deno/integration.test.ts

@@ -0,0 +1,147 @@
+import { assertEquals, assertExists } from 'https://deno.land/[email protected]/assert/mod.ts'
+import { createClient, SupabaseClient } from '../../dist/module/index.js'
+import type { RealtimeChannel } from '../../dist/module/index.js'
+
+// These tests assume that a local Supabase server is already running
+// Start a local Supabase instance with 'supabase start' before running these tests
+
+// TODO: Remove sanitizeOps and sanitizeResources once the issue is fixed
+Deno.test(
+  'Supabase Integration Tests',
+  { sanitizeOps: false, sanitizeResources: false },
+  async (t) => {
+    // Default local dev credentials from Supabase CLI
+    const SUPABASE_URL = 'http://127.0.0.1:54321'
+    const ANON_KEY =
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0'
+
+    const supabase = createClient(SUPABASE_URL, ANON_KEY, {
+      realtime: { heartbeatIntervalMs: 500 },
+    })
+
+    // Cleanup function to be called after all tests
+    const cleanup = async () => {
+      await supabase.auth.signOut()
+      await supabase.auth.stopAutoRefresh()
+      await supabase.removeAllChannels()
+      // Give some time for cleanup to complete
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+    }
+
+    try {
+      await t.step('should connect to Supabase instance', () => {
+        assertExists(supabase)
+        assertEquals(supabase instanceof SupabaseClient, true)
+      })
+
+      await t.step('PostgREST - should query data from public schema', async () => {
+        const { data, error } = await supabase.from('todos').select('*').limit(5)
+
+        // The default schema includes a 'todos' table, but it might be empty
+        assertEquals(error, null)
+        assertEquals(Array.isArray(data), true)
+      })
+
+      await t.step('PostgREST - should create and delete a todo', async () => {
+        // Create a new todo
+        const { data: createdTodo, error: createError } = await supabase
+          .from('todos')
+          .insert({ task: 'Integration Test Todo', is_complete: false })
+          .select()
+          .single()
+
+        assertEquals(createError, null)
+        assertExists(createdTodo)
+        assertEquals(createdTodo!.task, 'Integration Test Todo')
+        assertEquals(createdTodo!.is_complete, false)
+
+        // Delete the created todo
+        const { error: deleteError } = await supabase
+          .from('todos')
+          .delete()
+          .eq('id', createdTodo!.id)
+
+        assertEquals(deleteError, null)
+
+        // Verify the todo was deleted
+        const { data: fetchedTodo, error: fetchError } = await supabase
+          .from('todos')
+          .select('*')
+          .eq('id', createdTodo!.id)
+          .single()
+
+        assertExists(fetchError)
+        assertEquals(fetchedTodo, null)
+      })
+
+      await t.step('Authentication - should sign up a user', async () => {
+        const email = `test-${Date.now()}@example.com`
+        const password = 'password123'
+
+        const { data, error } = await supabase.auth.signUp({
+          email,
+          password,
+        })
+
+        assertEquals(error, null)
+        assertExists(data.user)
+        assertEquals(data.user!.email, email)
+      })
+
+      await t.step('Realtime - is able to connect and broadcast', async () => {
+        const channelName = `channel-${crypto.randomUUID()}`
+        let channel: RealtimeChannel
+        const email = `test-${Date.now()}@example.com`
+        const password = 'password123'
+
+        // Sign up and create channel
+        await supabase.auth.signUp({ email, password })
+        const config = { broadcast: { self: true }, private: true }
+        channel = supabase.channel(channelName, { config })
+        await supabase.realtime.setAuth()
+
+        const testMessage = { message: 'test' }
+        let receivedMessage: any
+        let subscribed = false
+        let attempts = 0
+
+        channel
+          .on('broadcast', { event: '*' }, (payload: unknown) => (receivedMessage = payload))
+          .subscribe((status: string) => {
+            if (status == 'SUBSCRIBED') subscribed = true
+          })
+
+        // Wait for subscription
+        while (!subscribed) {
+          if (attempts > 50) throw new Error('Timeout waiting for subscription')
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          attempts++
+        }
+
+        attempts = 0
+
+        channel.send({
+          type: 'broadcast',
+          event: 'test-event',
+          payload: testMessage,
+        })
+
+        // Wait on message
+        while (!receivedMessage) {
+          if (attempts > 50) throw new Error('Timeout waiting for message')
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          attempts++
+        }
+
+        assertExists(receivedMessage)
+        assertEquals(supabase.realtime.getChannels().length, 1)
+
+        // Cleanup channel
+        await channel.unsubscribe()
+      })
+    } finally {
+      // Ensure cleanup runs even if tests fail
+      await cleanup()
+    }
+  }
+)

test/deno/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "test-deno",
+  "private": true,
+  "scripts": {
+    "test": "npm run setup-deps && deno test --allow-all --unstable-sloppy-imports integration.test.ts",
+    "setup-deps": "node setup-deps.js"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "file:../../"
+  }
+}