@dotdo/postgres 0.1.0

package/src/extensions/pgmq-lite.test.ts

@@ -0,0 +1,727 @@
+/**
+ * PGMQ-Lite Tests
+ *
+ * Tests for the pure SQL message queue implementation including:
+ * - Schema management
+ * - Queue CRUD operations
+ * - Message operations (send, read, delete, archive)
+ * - Dead letter queue support
+ * - Transactional outbox pattern
+ * - Maintenance operations
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  PGMQLite,
+  type QueueMessage,
+  type CreateQueueOptions,
+} from './pgmq-lite'
+
+// ============================================================================
+// Schema Management Tests
+// ============================================================================
+
+describe('PGMQ-Lite Schema Management', () => {
+  describe('createSchemaSQL', () => {
+    it('should generate SQL to create pgmq_lite schema', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE SCHEMA IF NOT EXISTS pgmq_lite')
+    })
+
+    it('should create meta table', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.meta')
+      expect(sql).toContain('queue_name TEXT PRIMARY KEY')
+      expect(sql).toContain('is_paused BOOLEAN')
+      expect(sql).toContain('max_delivery_attempts INTEGER')
+    })
+
+    it('should create archive table', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.archive')
+      expect(sql).toContain('archived_at TIMESTAMPTZ')
+    })
+
+    it('should create dlq table', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.dlq')
+      expect(sql).toContain('error_reason TEXT')
+    })
+
+    it('should create outbox table', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.outbox')
+      expect(sql).toContain('target_queue TEXT')
+      expect(sql).toContain('routing_key TEXT')
+      expect(sql).toContain("status TEXT DEFAULT 'pending'")
+    })
+
+    it('should create outbox index for processing', () => {
+      const sql = PGMQLite.createSchemaSQL()
+      expect(sql).toContain('CREATE INDEX IF NOT EXISTS pgmq_lite_outbox_status_idx')
+      expect(sql).toContain("WHERE status = 'pending'")
+    })
+  })
+
+  describe('dropSchemaSQL', () => {
+    it('should generate SQL to drop schema with cascade', () => {
+      const sql = PGMQLite.dropSchemaSQL()
+      expect(sql).toBe('DROP SCHEMA IF EXISTS pgmq_lite CASCADE;')
+    })
+  })
+})
+
+// ============================================================================
+// Queue Management Tests
+// ============================================================================
+
+describe('PGMQ-Lite Queue Management', () => {
+  describe('createQueueSQL', () => {
+    it('should create queue table with required columns', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue')
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.q_test_queue')
+      expect(sql).toContain('msg_id BIGSERIAL PRIMARY KEY')
+      expect(sql).toContain('read_ct INTEGER DEFAULT 0')
+      expect(sql).toContain('enqueued_at TIMESTAMPTZ')
+      expect(sql).toContain('vt TIMESTAMPTZ')
+      expect(sql).toContain('message JSONB NOT NULL')
+    })
+
+    it('should create visibility timeout index', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue')
+      expect(sql).toContain('CREATE INDEX IF NOT EXISTS pgmq_lite_q_test_queue_vt_idx')
+      expect(sql).toContain('WHERE vt <= NOW()')
+    })
+
+    it('should register queue in meta table', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue')
+      expect(sql).toContain('INSERT INTO pgmq_lite.meta')
+      expect(sql).toContain("'test_queue'")
+      expect(sql).toContain('ON CONFLICT (queue_name) DO NOTHING')
+    })
+
+    it('should create DLQ table when enableDLQ is true', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue', { enableDLQ: true })
+      expect(sql).toContain('CREATE TABLE IF NOT EXISTS pgmq_lite.q_test_queue_dlq')
+      expect(sql).toContain('original_msg_id BIGINT')
+      expect(sql).toContain('error_reason TEXT')
+    })
+
+    it('should not create DLQ table by default', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue')
+      expect(sql).not.toContain('q_test_queue_dlq')
+    })
+
+    it('should set custom max_delivery_attempts', () => {
+      const sql = PGMQLite.createQueueSQL('test_queue', { maxDeliveryAttempts: 10 })
+      expect(sql).toContain('10')
+    })
+
+    it('should escape queue names with special characters', () => {
+      const sql = PGMQLite.createQueueSQL("test'queue")
+      expect(sql).toContain("test''queue")
+    })
+  })
+
+  describe('dropQueueSQL', () => {
+    it('should drop queue and DLQ tables', () => {
+      const sql = PGMQLite.dropQueueSQL('test_queue')
+      expect(sql).toContain('DROP TABLE IF EXISTS pgmq_lite.q_test_queue')
+      expect(sql).toContain('DROP TABLE IF EXISTS pgmq_lite.q_test_queue_dlq')
+    })
+
+    it('should remove from meta table', () => {
+      const sql = PGMQLite.dropQueueSQL('test_queue')
+      expect(sql).toContain("DELETE FROM pgmq_lite.meta WHERE queue_name = 'test_queue'")
+    })
+
+    it('should clean up archive and dlq entries', () => {
+      const sql = PGMQLite.dropQueueSQL('test_queue')
+      expect(sql).toContain("DELETE FROM pgmq_lite.archive WHERE queue_name = 'test_queue'")
+      expect(sql).toContain("DELETE FROM pgmq_lite.dlq WHERE queue_name = 'test_queue'")
+    })
+  })
+
+  describe('listQueuesSQL', () => {
+    it('should select from meta table', () => {
+      const sql = PGMQLite.listQueuesSQL()
+      expect(sql).toContain('SELECT queue_name, is_paused, created_at')
+      expect(sql).toContain('FROM pgmq_lite.meta')
+      expect(sql).toContain('ORDER BY created_at')
+    })
+  })
+
+  describe('queueDepthSQL', () => {
+    it('should count visible messages', () => {
+      const sql = PGMQLite.queueDepthSQL('test_queue')
+      expect(sql).toContain('SELECT COUNT(*) as depth')
+      expect(sql).toContain('FROM pgmq_lite.q_test_queue')
+      expect(sql).toContain('WHERE vt <= NOW()')
+    })
+  })
+
+  describe('pauseQueueSQL', () => {
+    it('should set is_paused to true', () => {
+      const sql = PGMQLite.pauseQueueSQL('test_queue')
+      expect(sql).toContain('UPDATE pgmq_lite.meta SET is_paused = TRUE')
+      expect(sql).toContain("WHERE queue_name = 'test_queue'")
+    })
+  })
+
+  describe('resumeQueueSQL', () => {
+    it('should set is_paused to false', () => {
+      const sql = PGMQLite.resumeQueueSQL('test_queue')
+      expect(sql).toContain('UPDATE pgmq_lite.meta SET is_paused = FALSE')
+      expect(sql).toContain("WHERE queue_name = 'test_queue'")
+    })
+  })
+})
+
+// ============================================================================
+// Message Operations Tests
+// ============================================================================
+
+describe('PGMQ-Lite Message Operations', () => {
+  describe('sendSQL', () => {
+    it('should insert message with JSON payload', () => {
+      const sql = PGMQLite.sendSQL('test_queue', { task: 'process', data: 123 })
+      expect(sql).toContain('INSERT INTO pgmq_lite.q_test_queue')
+      expect(sql).toContain('(message, vt)')
+      expect(sql).toContain('::jsonb')
+      expect(sql).toContain('RETURNING msg_id, read_ct, enqueued_at, vt, message')
+    })
+
+    it('should use NOW() for immediate visibility', () => {
+      const sql = PGMQLite.sendSQL('test_queue', { task: 'test' })
+      expect(sql).toContain("VALUES ('{\"task\":\"test\"}'::jsonb, NOW())")
+    })
+
+    it('should support delayed visibility', () => {
+      const sql = PGMQLite.sendSQL('test_queue', { task: 'test' }, 60)
+      expect(sql).toContain("NOW() + INTERVAL '60 seconds'")
+    })
+
+    it('should handle string payloads', () => {
+      const sql = PGMQLite.sendSQL('test_queue', 'simple message')
+      expect(sql).toContain('"simple message"')
+    })
+
+    it('should handle array payloads', () => {
+      const sql = PGMQLite.sendSQL('test_queue', [1, 2, 3])
+      expect(sql).toContain('[1,2,3]')
+    })
+
+    it('should escape single quotes in message', () => {
+      const sql = PGMQLite.sendSQL('test_queue', { text: "it's a test" })
+      expect(sql).toContain("it''s a test")
+    })
+  })
+
+  describe('sendBatchSQL', () => {
+    it('should insert multiple messages', () => {
+      const messages = [
+        { task: 'task1' },
+        { task: 'task2' },
+        { task: 'task3' },
+      ]
+      const sql = PGMQLite.sendBatchSQL('test_queue', messages)
+      expect(sql).toContain('VALUES')
+      expect(sql).toContain('task1')
+      expect(sql).toContain('task2')
+      expect(sql).toContain('task3')
+      expect(sql).toContain('RETURNING msg_id, read_ct, enqueued_at, vt, message')
+    })
+
+    it('should support delayed batch messages', () => {
+      const messages = [{ a: 1 }, { b: 2 }]
+      const sql = PGMQLite.sendBatchSQL('test_queue', messages, 30)
+      expect(sql).toContain("NOW() + INTERVAL '30 seconds'")
+    })
+  })
+
+  describe('readSQL', () => {
+    it('should select and update with FOR UPDATE SKIP LOCKED', () => {
+      const sql = PGMQLite.readSQL('test_queue', 30, 1)
+      expect(sql).toContain('WITH readable AS')
+      expect(sql).toContain('WHERE vt <= NOW()')
+      expect(sql).toContain('FOR UPDATE SKIP LOCKED')
+    })
+
+    it('should update visibility timeout', () => {
+      const sql = PGMQLite.readSQL('test_queue', 30, 1)
+      expect(sql).toContain("vt = NOW() + INTERVAL '30 seconds'")
+    })
+
+    it('should increment read count', () => {
+      const sql = PGMQLite.readSQL('test_queue', 30, 1)
+      expect(sql).toContain('read_ct = q.read_ct + 1')
+    })
+
+    it('should respect limit parameter', () => {
+      const sql = PGMQLite.readSQL('test_queue', 30, 5)
+      expect(sql).toContain('LIMIT 5')
+    })
+
+    it('should use default visibility timeout', () => {
+      const sql = PGMQLite.readSQL('test_queue')
+      expect(sql).toContain("INTERVAL '30 seconds'")
+    })
+
+    it('should use default limit of 1', () => {
+      const sql = PGMQLite.readSQL('test_queue')
+      expect(sql).toMatch(/LIMIT\s+1\s/)
+    })
+
+    it('should return all message fields', () => {
+      const sql = PGMQLite.readSQL('test_queue')
+      expect(sql).toContain('RETURNING q.msg_id, q.read_ct, q.enqueued_at, q.vt, q.message')
+    })
+  })
+
+  describe('popSQL', () => {
+    it('should delete and return message atomically', () => {
+      const sql = PGMQLite.popSQL('test_queue')
+      expect(sql).toContain('WITH popped AS')
+      expect(sql).toContain('DELETE FROM pgmq_lite.q_test_queue')
+      expect(sql).toContain('RETURNING msg_id, read_ct, enqueued_at, vt, message')
+    })
+
+    it('should select only visible messages', () => {
+      const sql = PGMQLite.popSQL('test_queue')
+      expect(sql).toContain('WHERE vt <= NOW()')
+    })
+
+    it('should use FOR UPDATE SKIP LOCKED', () => {
+      const sql = PGMQLite.popSQL('test_queue')
+      expect(sql).toContain('FOR UPDATE SKIP LOCKED')
+    })
+
+    it('should limit to 1 message', () => {
+      const sql = PGMQLite.popSQL('test_queue')
+      expect(sql).toContain('LIMIT 1')
+    })
+  })
+
+  describe('deleteSQL', () => {
+    it('should delete by message ID', () => {
+      const sql = PGMQLite.deleteSQL('test_queue', 123)
+      expect(sql).toContain('DELETE FROM pgmq_lite.q_test_queue')
+      expect(sql).toContain('WHERE msg_id = 123')
+      expect(sql).toContain('RETURNING msg_id')
+    })
+
+    it('should handle bigint IDs', () => {
+      const sql = PGMQLite.deleteSQL('test_queue', BigInt('9007199254740993'))
+      expect(sql).toContain('9007199254740993')
+    })
+
+    it('should handle string IDs', () => {
+      const sql = PGMQLite.deleteSQL('test_queue', '456')
+      expect(sql).toContain('WHERE msg_id = 456')
+    })
+  })
+
+  describe('deleteBatchSQL', () => {
+    it('should delete multiple messages', () => {
+      const sql = PGMQLite.deleteBatchSQL('test_queue', [1, 2, 3])
+      expect(sql).toContain('WHERE msg_id IN (1, 2, 3)')
+      expect(sql).toContain('RETURNING msg_id')
+    })
+  })
+
+  describe('archiveSQL', () => {
+    it('should move message to archive table', () => {
+      const sql = PGMQLite.archiveSQL('test_queue', 123)
+      expect(sql).toContain('WITH archived AS')
+      expect(sql).toContain('DELETE FROM pgmq_lite.q_test_queue')
+      expect(sql).toContain('INSERT INTO pgmq_lite.archive')
+    })
+
+    it('should preserve message data', () => {
+      const sql = PGMQLite.archiveSQL('test_queue', 123)
+      expect(sql).toContain('msg_id, read_ct, enqueued_at, message')
+    })
+
+    it('should include queue name in archive', () => {
+      const sql = PGMQLite.archiveSQL('test_queue', 123)
+      expect(sql).toContain("'test_queue'")
+    })
+  })
+
+  describe('setVisibilityTimeoutSQL', () => {
+    it('should update visibility timeout', () => {
+      const sql = PGMQLite.setVisibilityTimeoutSQL('test_queue', 123, 60)
+      expect(sql).toContain('UPDATE pgmq_lite.q_test_queue')
+      expect(sql).toContain("vt = NOW() + INTERVAL '60 seconds'")
+      expect(sql).toContain('WHERE msg_id = 123')
+      expect(sql).toContain('RETURNING msg_id, vt')
+    })
+  })
+
+  describe('releaseSQL', () => {
+    it('should set visibility timeout to NOW()', () => {
+      const sql = PGMQLite.releaseSQL('test_queue', 123)
+      expect(sql).toContain('vt = NOW()')
+      expect(sql).toContain('WHERE msg_id = 123')
+    })
+  })
+})
+
+// ============================================================================
+// Dead Letter Queue Tests
+// ============================================================================
+
+describe('PGMQ-Lite Dead Letter Queue', () => {
+  describe('moveToDLQSQL', () => {
+    it('should move message to DLQ', () => {
+      const sql = PGMQLite.moveToDLQSQL('test_queue', 123)
+      expect(sql).toContain('WITH moved AS')
+      expect(sql).toContain('DELETE FROM pgmq_lite.q_test_queue')
+      expect(sql).toContain('INSERT INTO pgmq_lite.dlq')
+    })
+
+    it('should include error reason when provided', () => {
+      const sql = PGMQLite.moveToDLQSQL('test_queue', 123, 'Processing failed')
+      expect(sql).toContain("'Processing failed'")
+    })
+
+    it('should use NULL for error reason when not provided', () => {
+      const sql = PGMQLite.moveToDLQSQL('test_queue', 123)
+      expect(sql).toContain('NULL')
+    })
+
+    it('should escape error reason', () => {
+      const sql = PGMQLite.moveToDLQSQL('test_queue', 123, "Error: can't process")
+      expect(sql).toContain("can''t process")
+    })
+  })
+
+  describe('readDLQSQL', () => {
+    it('should read from DLQ for specific queue', () => {
+      const sql = PGMQLite.readDLQSQL('test_queue', 10)
+      expect(sql).toContain('FROM pgmq_lite.dlq')
+      expect(sql).toContain("WHERE queue_name = 'test_queue'")
+      expect(sql).toContain('ORDER BY moved_at DESC')
+      expect(sql).toContain('LIMIT 10')
+    })
+
+    it('should read from DLQ for all queues when queue not specified', () => {
+      const sql = PGMQLite.readDLQSQL(undefined, 10)
+      expect(sql).not.toContain('WHERE queue_name')
+      expect(sql).toContain('ORDER BY moved_at DESC')
+    })
+
+    it('should include all DLQ fields', () => {
+      const sql = PGMQLite.readDLQSQL('test_queue')
+      expect(sql).toContain('msg_id')
+      expect(sql).toContain('queue_name')
+      expect(sql).toContain('read_ct')
+      expect(sql).toContain('enqueued_at')
+      expect(sql).toContain('moved_at')
+      expect(sql).toContain('message')
+      expect(sql).toContain('error_reason')
+    })
+  })
+
+  describe('requeueFromDLQSQL', () => {
+    it('should move message back to original queue', () => {
+      const sql = PGMQLite.requeueFromDLQSQL('test_queue', 123)
+      expect(sql).toContain('WITH requeued AS')
+      expect(sql).toContain('DELETE FROM pgmq_lite.dlq')
+      expect(sql).toContain("WHERE msg_id = 123 AND queue_name = 'test_queue'")
+      expect(sql).toContain('INSERT INTO pgmq_lite.q_test_queue')
+    })
+
+    it('should set new visibility timeout', () => {
+      const sql = PGMQLite.requeueFromDLQSQL('test_queue', 123)
+      expect(sql).toContain('message, NOW()')
+    })
+  })
+})
+
+// ============================================================================
+// Transactional Outbox Tests
+// ============================================================================
+
+describe('PGMQ-Lite Transactional Outbox', () => {
+  describe('outboxAddSQL', () => {
+    it('should insert into outbox table', () => {
+      const sql = PGMQLite.outboxAddSQL('target_queue', { event: 'created' })
+      expect(sql).toContain('INSERT INTO pgmq_lite.outbox')
+      expect(sql).toContain("'target_queue'")
+      expect(sql).toContain('event')
+      expect(sql).toContain('created')
+    })
+
+    it('should include routing key when provided', () => {
+      const sql = PGMQLite.outboxAddSQL('target_queue', { data: 1 }, 'user.created')
+      expect(sql).toContain("'user.created'")
+    })
+
+    it('should use NULL for routing key when not provided', () => {
+      const sql = PGMQLite.outboxAddSQL('target_queue', { data: 1 })
+      expect(sql).toContain('NULL')
+    })
+
+    it('should return outbox entry', () => {
+      const sql = PGMQLite.outboxAddSQL('target_queue', { data: 1 })
+      expect(sql).toContain('RETURNING id, target_queue, routing_key, message, created_at, status')
+    })
+  })
+
+  describe('outboxProcessSQL', () => {
+    it('should select pending messages', () => {
+      const sql = PGMQLite.outboxProcessSQL(100)
+      expect(sql).toContain("WHERE status = 'pending'")
+      expect(sql).toContain('ORDER BY created_at ASC')
+      expect(sql).toContain('LIMIT 100')
+    })
+
+    it('should use FOR UPDATE SKIP LOCKED', () => {
+      const sql = PGMQLite.outboxProcessSQL(100)
+      expect(sql).toContain('FOR UPDATE SKIP LOCKED')
+    })
+
+    it('should update status to processing', () => {
+      const sql = PGMQLite.outboxProcessSQL(100)
+      expect(sql).toContain("SET status = 'processing'")
+    })
+  })
+
+  describe('outboxCompleteSQL', () => {
+    it('should mark messages as completed', () => {
+      const sql = PGMQLite.outboxCompleteSQL([1, 2, 3])
+      expect(sql).toContain("SET status = 'completed'")
+      expect(sql).toContain('processed_at = NOW()')
+      expect(sql).toContain('WHERE id IN (1, 2, 3)')
+    })
+  })
+
+  describe('outboxFailSQL', () => {
+    it('should mark messages as failed', () => {
+      const sql = PGMQLite.outboxFailSQL([1, 2])
+      expect(sql).toContain("SET status = 'failed'")
+      expect(sql).toContain('WHERE id IN (1, 2)')
+    })
+  })
+
+  describe('outboxRetryFailedSQL', () => {
+    it('should reset failed messages to pending', () => {
+      const sql = PGMQLite.outboxRetryFailedSQL()
+      expect(sql).toContain("SET status = 'pending'")
+      expect(sql).toContain("WHERE status = 'failed'")
+      expect(sql).toContain('processed_at = NULL')
+    })
+  })
+
+  describe('outboxCleanupSQL', () => {
+    it('should delete completed messages older than specified hours', () => {
+      const sql = PGMQLite.outboxCleanupSQL(24)
+      expect(sql).toContain('DELETE FROM pgmq_lite.outbox')
+      expect(sql).toContain("WHERE status = 'completed'")
+      expect(sql).toContain("INTERVAL '24 hours'")
+    })
+
+    it('should use default 24 hours', () => {
+      const sql = PGMQLite.outboxCleanupSQL()
+      expect(sql).toContain("INTERVAL '24 hours'")
+    })
+  })
+})
+
+// ============================================================================
+// Maintenance Operations Tests
+// ============================================================================
+
+describe('PGMQ-Lite Maintenance Operations', () => {
+  describe('purgeQueueSQL', () => {
+    it('should delete all messages from queue', () => {
+      const sql = PGMQLite.purgeQueueSQL('test_queue')
+      expect(sql).toBe('DELETE FROM pgmq_lite.q_test_queue RETURNING msg_id;')
+    })
+  })
+
+  describe('queueStatsSQL', () => {
+    it('should return comprehensive queue statistics', () => {
+      const sql = PGMQLite.queueStatsSQL('test_queue')
+      expect(sql).toContain("'test_queue' as queue_name")
+      expect(sql).toContain('COUNT(*) as total_messages')
+      expect(sql).toContain('COUNT(*) FILTER (WHERE vt <= NOW()) as visible_messages')
+      expect(sql).toContain('COUNT(*) FILTER (WHERE vt > NOW()) as invisible_messages')
+      expect(sql).toContain('MIN(enqueued_at) as oldest_message_at')
+      expect(sql).toContain('MAX(enqueued_at) as newest_message_at')
+      expect(sql).toContain('AVG(read_ct)::NUMERIC(10,2) as avg_read_count')
+    })
+  })
+
+  describe('cleanupArchiveSQL', () => {
+    it('should delete old archived messages for specific queue', () => {
+      const sql = PGMQLite.cleanupArchiveSQL('test_queue', 30)
+      expect(sql).toContain('DELETE FROM pgmq_lite.archive')
+      expect(sql).toContain("WHERE queue_name = 'test_queue'")
+      expect(sql).toContain("INTERVAL '30 days'")
+    })
+
+    it('should delete old archived messages for all queues', () => {
+      const sql = PGMQLite.cleanupArchiveSQL(undefined, 30)
+      expect(sql).toContain('DELETE FROM pgmq_lite.archive')
+      expect(sql).not.toContain('WHERE queue_name')
+      expect(sql).toContain('RETURNING msg_id, queue_name')
+    })
+
+    it('should use default 30 days', () => {
+      const sql = PGMQLite.cleanupArchiveSQL()
+      expect(sql).toContain("INTERVAL '30 days'")
+    })
+  })
+})
+
+// ============================================================================
+// Module Exports Tests
+// ============================================================================
+
+describe('PGMQ-Lite Module', () => {
+  it('should have correct name property', () => {
+    expect(PGMQLite.name).toBe('pgmq_lite')
+  })
+
+  it('should have correct displayName property', () => {
+    expect(PGMQLite.displayName).toBe('PGMQ-Lite')
+  })
+
+  it('should have description', () => {
+    expect(PGMQLite.description).toBeDefined()
+    expect(PGMQLite.description.length).toBeGreaterThan(0)
+  })
+
+  it('should export all expected methods', () => {
+    // Schema management
+    expect(typeof PGMQLite.createSchemaSQL).toBe('function')
+    expect(typeof PGMQLite.dropSchemaSQL).toBe('function')
+
+    // Queue management
+    expect(typeof PGMQLite.createQueueSQL).toBe('function')
+    expect(typeof PGMQLite.dropQueueSQL).toBe('function')
+    expect(typeof PGMQLite.listQueuesSQL).toBe('function')
+    expect(typeof PGMQLite.queueDepthSQL).toBe('function')
+    expect(typeof PGMQLite.pauseQueueSQL).toBe('function')
+    expect(typeof PGMQLite.resumeQueueSQL).toBe('function')
+
+    // Message operations
+    expect(typeof PGMQLite.sendSQL).toBe('function')
+    expect(typeof PGMQLite.sendBatchSQL).toBe('function')
+    expect(typeof PGMQLite.readSQL).toBe('function')
+    expect(typeof PGMQLite.popSQL).toBe('function')
+    expect(typeof PGMQLite.deleteSQL).toBe('function')
+    expect(typeof PGMQLite.deleteBatchSQL).toBe('function')
+    expect(typeof PGMQLite.archiveSQL).toBe('function')
+    expect(typeof PGMQLite.setVisibilityTimeoutSQL).toBe('function')
+    expect(typeof PGMQLite.releaseSQL).toBe('function')
+
+    // DLQ operations
+    expect(typeof PGMQLite.moveToDLQSQL).toBe('function')
+    expect(typeof PGMQLite.readDLQSQL).toBe('function')
+    expect(typeof PGMQLite.requeueFromDLQSQL).toBe('function')
+
+    // Outbox operations
+    expect(typeof PGMQLite.outboxAddSQL).toBe('function')
+    expect(typeof PGMQLite.outboxProcessSQL).toBe('function')
+    expect(typeof PGMQLite.outboxCompleteSQL).toBe('function')
+    expect(typeof PGMQLite.outboxFailSQL).toBe('function')
+    expect(typeof PGMQLite.outboxRetryFailedSQL).toBe('function')
+    expect(typeof PGMQLite.outboxCleanupSQL).toBe('function')
+
+    // Maintenance operations
+    expect(typeof PGMQLite.purgeQueueSQL).toBe('function')
+    expect(typeof PGMQLite.queueStatsSQL).toBe('function')
+    expect(typeof PGMQLite.cleanupArchiveSQL).toBe('function')
+  })
+})
+
+// ============================================================================
+// Integration Scenarios Tests
+// ============================================================================
+
+describe('PGMQ-Lite Integration Scenarios', () => {
+  describe('Basic queue workflow', () => {
+    it('should support standard produce/consume pattern', () => {
+      // Create schema and queue
+      const schemaSQL = PGMQLite.createSchemaSQL()
+      const queueSQL = PGMQLite.createQueueSQL('orders')
+
+      // Send message
+      const sendSQL = PGMQLite.sendSQL('orders', { orderId: '123', status: 'pending' })
+
+      // Read message
+      const readSQL = PGMQLite.readSQL('orders', 60, 1)
+
+      // Delete after processing
+      const deleteSQL = PGMQLite.deleteSQL('orders', 1)
+
+      // All SQL should be valid
+      expect(schemaSQL).toContain('CREATE SCHEMA')
+      expect(queueSQL).toContain('CREATE TABLE')
+      expect(sendSQL).toContain('INSERT')
+      expect(readSQL).toContain('UPDATE')
+      expect(deleteSQL).toContain('DELETE')
+    })
+  })
+
+  describe('Transactional outbox pattern', () => {
+    it('should support reliable message delivery with business transaction', () => {
+      // Add to outbox (within business transaction)
+      const outboxSQL = PGMQLite.outboxAddSQL('notifications', {
+        type: 'order_created',
+        orderId: '123',
+      })
+
+      // Process outbox (separate worker)
+      const processSQL = PGMQLite.outboxProcessSQL(100)
+
+      // After sending to target queue
+      const completeSQL = PGMQLite.outboxCompleteSQL([1, 2, 3])
+
+      expect(outboxSQL).toContain('INSERT INTO pgmq_lite.outbox')
+      expect(processSQL).toContain("status = 'pending'")
+      expect(completeSQL).toContain("status = 'completed'")
+    })
+  })
+
+  describe('Dead letter queue pattern', () => {
+    it('should support failed message handling', () => {
+      // Create queue with DLQ
+      const queueSQL = PGMQLite.createQueueSQL('processing', { enableDLQ: true })
+
+      // Move to DLQ after max retries
+      const moveToDLQSQL = PGMQLite.moveToDLQSQL('processing', 123, 'Max retries exceeded')
+
+      // Read from DLQ for investigation
+      const readDLQSQL = PGMQLite.readDLQSQL('processing', 10)
+
+      // Requeue after fixing issue
+      const requeueSQL = PGMQLite.requeueFromDLQSQL('processing', 123)
+
+      expect(queueSQL).toContain('q_processing_dlq')
+      expect(moveToDLQSQL).toContain('INSERT INTO pgmq_lite.dlq')
+      expect(readDLQSQL).toContain('FROM pgmq_lite.dlq')
+      expect(requeueSQL).toContain('DELETE FROM pgmq_lite.dlq')
+    })
+  })
+
+  describe('Message visibility and retry pattern', () => {
+    it('should support visibility timeout for processing', () => {
+      // Read with 30 second visibility timeout
+      const readSQL = PGMQLite.readSQL('tasks', 30, 1)
+
+      // Extend visibility if processing takes longer
+      const extendSQL = PGMQLite.setVisibilityTimeoutSQL('tasks', 1, 60)
+
+      // Release message back if can\'t process
+      const releaseSQL = PGMQLite.releaseSQL('tasks', 1)
+
+      expect(readSQL).toContain("INTERVAL '30 seconds'")
+      expect(extendSQL).toContain("INTERVAL '60 seconds'")
+      expect(releaseSQL).toContain('vt = NOW()')
+    })
+  })
+})