@mdxui/terminal 2.0.0

package/src/__tests__/data/collections.test.ts

@@ -0,0 +1,1337 @@
+/**
+ * @mdxui/terminal SaaS Collections Tests (RED phase)
+ *
+ * TDD RED Phase: These tests define the contract for SaaS primitive collections
+ * that power the Developer Dashboard and SaaS app features.
+ *
+ * Collections tested:
+ * - Users: Basic user account information (id, name, email, role, createdAt)
+ * - APIKeys: API key management (id, key, name, permissions, expiresAt)
+ * - Webhooks: Webhook configuration (id, url, events, secret, active)
+ * - Teams: Team management (id, name, members)
+ * - Usage: Usage metrics tracking (id, metric, value, timestamp)
+ *
+ * NOTE: These tests are expected to FAIL until collections are implemented.
+ * Run: pnpm --filter @mdxui/terminal test -- --run src/__tests__/data/collections.test.ts
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { z } from 'zod'
+
+// ============================================================================
+// These imports WILL FAIL until src/data/saas-collections.ts is implemented
+// ============================================================================
+
+import {
+  UsersCollection,
+  APIKeysCollection,
+  WebhooksCollection,
+  TeamsCollection,
+  UsageCollection,
+} from '../../data/saas-collections'
+
+import {
+  UserSchema,
+  APIKeySchema,
+  WebhookSchema,
+  TeamSchema,
+  UsageSchema,
+  type User,
+  type APIKey,
+  type Webhook,
+  type Team,
+  type Usage,
+} from '../../data/saas-collections'
+
+// ============================================================================
+// Users Collection Tests
+// ============================================================================
+
+describe('Users Collection', () => {
+  let usersCollection: ReturnType<typeof UsersCollection>
+
+  beforeEach(() => {
+    usersCollection = UsersCollection()
+  })
+
+  describe('schema validation', () => {
+    it('validates a valid user object', () => {
+      const validUser: User = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date('2024-01-15'),
+      }
+
+      const result = UserSchema.safeParse(validUser)
+      expect(result.success).toBe(true)
+    })
+
+    it('requires id field', () => {
+      const invalidUser = {
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires name field', () => {
+      const invalidUser = {
+        id: 'user-1',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires valid email format', () => {
+      const invalidUser = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'not-an-email',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires role field as enum (admin, user, viewer)', () => {
+      const invalidUser = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'superadmin',
+        createdAt: new Date(),
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires createdAt as Date', () => {
+      const invalidUser = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: '2024-01-15',
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts all valid roles: admin, user, viewer', () => {
+      const roles = ['admin', 'user', 'viewer'] as const
+
+      roles.forEach((role) => {
+        const user: User = {
+          id: `user-${role}`,
+          name: 'Test User',
+          email: `${role}@example.com`,
+          role,
+          createdAt: new Date(),
+        }
+
+        const result = UserSchema.safeParse(user)
+        expect(result.success).toBe(true)
+      })
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('inserts a new user', async () => {
+      const newUser: User = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date('2024-01-15'),
+      }
+
+      const inserted = await usersCollection.insert(newUser)
+      expect(inserted.id).toBe('user-1')
+      expect(inserted.name).toBe('Alice Johnson')
+      expect(inserted.email).toBe('alice@example.com')
+    })
+
+    it('rejects duplicate user id on insert', async () => {
+      const user: User = {
+        id: 'user-1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      await usersCollection.insert(user)
+
+      const duplicate: User = {
+        id: 'user-1',
+        name: 'Different Name',
+        email: 'different@example.com',
+        role: 'user',
+        createdAt: new Date(),
+      }
+
+      await expect(usersCollection.insert(duplicate)).rejects.toThrow()
+    })
+
+    it('finds a single user by id', async () => {
+      const user: User = {
+        id: 'user-find-1',
+        name: 'Bob Smith',
+        email: 'bob@example.com',
+        role: 'user',
+        createdAt: new Date(),
+      }
+
+      await usersCollection.insert(user)
+      const found = await usersCollection.findOne({ id: 'user-find-1' })
+
+      expect(found).not.toBeNull()
+      expect(found?.name).toBe('Bob Smith')
+      expect(found?.email).toBe('bob@example.com')
+    })
+
+    it('finds multiple users with filtering', async () => {
+      const users: User[] = [
+        {
+          id: 'admin-1',
+          name: 'Admin User',
+          email: 'admin@example.com',
+          role: 'admin',
+          createdAt: new Date('2024-01-01'),
+        },
+        {
+          id: 'user-1',
+          name: 'Regular User',
+          email: 'user@example.com',
+          role: 'user',
+          createdAt: new Date('2024-01-15'),
+        },
+        {
+          id: 'user-2',
+          name: 'Another User',
+          email: 'another@example.com',
+          role: 'user',
+          createdAt: new Date('2024-02-01'),
+        },
+      ]
+
+      for (const user of users) {
+        await usersCollection.insert(user)
+      }
+
+      const allUsers = await usersCollection.findMany()
+      expect(allUsers).toHaveLength(3)
+
+      const adminUsers = await usersCollection.findMany({
+        where: { role: 'admin' },
+      })
+      expect(adminUsers).toHaveLength(1)
+      expect(adminUsers[0].name).toBe('Admin User')
+    })
+
+    it('updates user information', async () => {
+      const user: User = {
+        id: 'user-update-1',
+        name: 'Original Name',
+        email: 'original@example.com',
+        role: 'user',
+        createdAt: new Date(),
+      }
+
+      await usersCollection.insert(user)
+
+      const updated = await usersCollection.update(
+        { id: 'user-update-1' },
+        { name: 'Updated Name', role: 'admin' }
+      )
+
+      expect(updated).toHaveLength(1)
+      expect(updated[0].name).toBe('Updated Name')
+      expect(updated[0].role).toBe('admin')
+      expect(updated[0].email).toBe('original@example.com')
+    })
+
+    it('deletes a user', async () => {
+      const user: User = {
+        id: 'user-delete-1',
+        name: 'To Delete',
+        email: 'delete@example.com',
+        role: 'user',
+        createdAt: new Date(),
+      }
+
+      await usersCollection.insert(user)
+      await usersCollection.delete({ id: 'user-delete-1' })
+
+      const found = await usersCollection.findOne({ id: 'user-delete-1' })
+      expect(found).toBeNull()
+    })
+
+    it('sorts users by createdAt in descending order', async () => {
+      const users: User[] = [
+        {
+          id: 'user-old',
+          name: 'Old User',
+          email: 'old@example.com',
+          role: 'user',
+          createdAt: new Date('2024-01-01'),
+        },
+        {
+          id: 'user-new',
+          name: 'New User',
+          email: 'new@example.com',
+          role: 'user',
+          createdAt: new Date('2024-02-01'),
+        },
+      ]
+
+      for (const user of users) {
+        await usersCollection.insert(user)
+      }
+
+      const sorted = await usersCollection.findMany({
+        orderBy: { createdAt: 'desc' },
+      })
+
+      expect(sorted[0].name).toBe('New User')
+      expect(sorted[1].name).toBe('Old User')
+    })
+  })
+
+  describe('subscriptions', () => {
+    it('subscribes to collection changes', async () => {
+      let lastData: User[] | null = null
+
+      const unsubscribe = usersCollection.subscribe((data) => {
+        lastData = data
+      })
+
+      const user: User = {
+        id: 'user-sub-1',
+        name: 'Subscription Test',
+        email: 'sub@example.com',
+        role: 'user',
+        createdAt: new Date(),
+      }
+
+      await usersCollection.insert(user)
+
+      expect(lastData).not.toBeNull()
+      expect(lastData).toHaveLength(1)
+      expect(lastData![0].id).toBe('user-sub-1')
+
+      unsubscribe()
+    })
+  })
+})
+
+// ============================================================================
+// APIKeys Collection Tests
+// ============================================================================
+
+describe('APIKeys Collection', () => {
+  let apiKeysCollection: ReturnType<typeof APIKeysCollection>
+
+  beforeEach(() => {
+    apiKeysCollection = APIKeysCollection()
+  })
+
+  describe('schema validation', () => {
+    it('validates a valid API key object', () => {
+      const validAPIKey: APIKey = {
+        id: 'key-1',
+        key: 'sk_test_123456789abcdef',
+        name: 'Development Key',
+        permissions: ['read:api', 'write:webhooks'],
+        expiresAt: new Date('2025-12-31'),
+      }
+
+      const result = APIKeySchema.safeParse(validAPIKey)
+      expect(result.success).toBe(true)
+    })
+
+    it('requires id field', () => {
+      const invalidKey = {
+        key: 'sk_test_123456789abcdef',
+        name: 'Development Key',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires key field (secret key string)', () => {
+      const invalidKey = {
+        id: 'key-1',
+        name: 'Development Key',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires name field', () => {
+      const invalidKey = {
+        id: 'key-1',
+        key: 'sk_test_123456789abcdef',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires permissions as array of strings', () => {
+      const invalidKey = {
+        id: 'key-1',
+        key: 'sk_test_123456789abcdef',
+        name: 'Development Key',
+        permissions: 'read:api',
+        expiresAt: new Date(),
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires expiresAt as Date', () => {
+      const invalidKey = {
+        id: 'key-1',
+        key: 'sk_test_123456789abcdef',
+        name: 'Development Key',
+        permissions: ['read:api'],
+        expiresAt: '2025-12-31',
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts multiple permissions', () => {
+      const apiKey: APIKey = {
+        id: 'key-multi',
+        key: 'sk_test_abc',
+        name: 'Multi-Permission Key',
+        permissions: ['read:api', 'write:webhooks', 'admin:settings'],
+        expiresAt: new Date(),
+      }
+
+      const result = APIKeySchema.safeParse(apiKey)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('inserts a new API key', async () => {
+      const newKey: APIKey = {
+        id: 'key-insert-1',
+        key: 'sk_test_123456789abcdef',
+        name: 'Development Key',
+        permissions: ['read:api', 'write:webhooks'],
+        expiresAt: new Date('2025-12-31'),
+      }
+
+      const inserted = await apiKeysCollection.insert(newKey)
+      expect(inserted.id).toBe('key-insert-1')
+      expect(inserted.name).toBe('Development Key')
+      expect(inserted.permissions).toHaveLength(2)
+    })
+
+    it('finds API keys by id', async () => {
+      const key: APIKey = {
+        id: 'key-find-1',
+        key: 'sk_test_abc',
+        name: 'Find Test',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      await apiKeysCollection.insert(key)
+      const found = await apiKeysCollection.findOne({ id: 'key-find-1' })
+
+      expect(found).not.toBeNull()
+      expect(found?.name).toBe('Find Test')
+    })
+
+    it('finds multiple API keys with filtering', async () => {
+      const keys: APIKey[] = [
+        {
+          id: 'key-1',
+          key: 'sk_test_1',
+          name: 'Prod Key',
+          permissions: ['read:api', 'write:webhooks', 'admin:settings'],
+          expiresAt: new Date('2026-12-31'),
+        },
+        {
+          id: 'key-2',
+          key: 'sk_test_2',
+          name: 'Dev Key',
+          permissions: ['read:api'],
+          expiresAt: new Date('2025-12-31'),
+        },
+      ]
+
+      for (const key of keys) {
+        await apiKeysCollection.insert(key)
+      }
+
+      const allKeys = await apiKeysCollection.findMany()
+      expect(allKeys).toHaveLength(2)
+    })
+
+    it('updates API key name and permissions', async () => {
+      const key: APIKey = {
+        id: 'key-update-1',
+        key: 'sk_test_original',
+        name: 'Original Name',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      await apiKeysCollection.insert(key)
+
+      const updated = await apiKeysCollection.update(
+        { id: 'key-update-1' },
+        { name: 'Updated Name', permissions: ['read:api', 'write:webhooks'] }
+      )
+
+      expect(updated).toHaveLength(1)
+      expect(updated[0].name).toBe('Updated Name')
+      expect(updated[0].permissions).toHaveLength(2)
+      expect(updated[0].key).toBe('sk_test_original')
+    })
+
+    it('deletes an API key', async () => {
+      const key: APIKey = {
+        id: 'key-delete-1',
+        key: 'sk_test_delete',
+        name: 'To Delete',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      await apiKeysCollection.insert(key)
+      await apiKeysCollection.delete({ id: 'key-delete-1' })
+
+      const found = await apiKeysCollection.findOne({ id: 'key-delete-1' })
+      expect(found).toBeNull()
+    })
+
+    it('filters API keys by expiration', async () => {
+      const now = new Date()
+      const expired = new Date(now.getTime() - 86400000)
+      const future = new Date(now.getTime() + 86400000)
+
+      const keys: APIKey[] = [
+        {
+          id: 'key-expired',
+          key: 'sk_expired',
+          name: 'Expired Key',
+          permissions: [],
+          expiresAt: expired,
+        },
+        {
+          id: 'key-valid',
+          key: 'sk_valid',
+          name: 'Valid Key',
+          permissions: [],
+          expiresAt: future,
+        },
+      ]
+
+      for (const key of keys) {
+        await apiKeysCollection.insert(key)
+      }
+
+      const validKeys = await apiKeysCollection.findMany({
+        where: { expiresAt: { $gt: now } },
+      })
+
+      expect(validKeys).toHaveLength(1)
+      expect(validKeys[0].name).toBe('Valid Key')
+    })
+  })
+})
+
+// ============================================================================
+// Webhooks Collection Tests
+// ============================================================================
+
+describe('Webhooks Collection', () => {
+  let webhooksCollection: ReturnType<typeof WebhooksCollection>
+
+  beforeEach(() => {
+    webhooksCollection = WebhooksCollection()
+  })
+
+  describe('schema validation', () => {
+    it('validates a valid webhook object', () => {
+      const validWebhook: Webhook = {
+        id: 'webhook-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created', 'user.updated'],
+        secret: 'whsec_test_123456789abcdef',
+        active: true,
+      }
+
+      const result = WebhookSchema.safeParse(validWebhook)
+      expect(result.success).toBe(true)
+    })
+
+    it('requires valid URL format', () => {
+      const invalidWebhook = {
+        id: 'webhook-1',
+        url: 'not-a-url',
+        events: ['user.created'],
+        secret: 'whsec_test_123456789abcdef',
+        active: true,
+      }
+
+      const result = WebhookSchema.safeParse(invalidWebhook)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires events as non-empty array', () => {
+      const invalidWebhook = {
+        id: 'webhook-1',
+        url: 'https://example.com/webhook',
+        events: [],
+        secret: 'whsec_test_123456789abcdef',
+        active: true,
+      }
+
+      const result = WebhookSchema.safeParse(invalidWebhook)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires secret field', () => {
+      const invalidWebhook = {
+        id: 'webhook-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created'],
+        active: true,
+      }
+
+      const result = WebhookSchema.safeParse(invalidWebhook)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires active as boolean', () => {
+      const invalidWebhook = {
+        id: 'webhook-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created'],
+        secret: 'whsec_test_123456789abcdef',
+        active: 'yes',
+      }
+
+      const result = WebhookSchema.safeParse(invalidWebhook)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('inserts a new webhook', async () => {
+      const newWebhook: Webhook = {
+        id: 'webhook-insert-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created', 'user.updated'],
+        secret: 'whsec_test_123456789abcdef',
+        active: true,
+      }
+
+      const inserted = await webhooksCollection.insert(newWebhook)
+      expect(inserted.id).toBe('webhook-insert-1')
+      expect(inserted.url).toBe('https://example.com/webhook')
+      expect(inserted.events).toHaveLength(2)
+    })
+
+    it('finds webhooks by id', async () => {
+      const webhook: Webhook = {
+        id: 'webhook-find-1',
+        url: 'https://api.example.com/webhook',
+        events: ['api.call'],
+        secret: 'whsec_test_abc',
+        active: true,
+      }
+
+      await webhooksCollection.insert(webhook)
+      const found = await webhooksCollection.findOne({ id: 'webhook-find-1' })
+
+      expect(found).not.toBeNull()
+      expect(found?.url).toBe('https://api.example.com/webhook')
+    })
+
+    it('filters active webhooks', async () => {
+      const webhooks: Webhook[] = [
+        {
+          id: 'webhook-active',
+          url: 'https://active.example.com/webhook',
+          events: ['test'],
+          secret: 'whsec_active',
+          active: true,
+        },
+        {
+          id: 'webhook-inactive',
+          url: 'https://inactive.example.com/webhook',
+          events: ['test'],
+          secret: 'whsec_inactive',
+          active: false,
+        },
+      ]
+
+      for (const webhook of webhooks) {
+        await webhooksCollection.insert(webhook)
+      }
+
+      const activeWebhooks = await webhooksCollection.findMany({
+        where: { active: true },
+      })
+
+      expect(activeWebhooks).toHaveLength(1)
+      expect(activeWebhooks[0].id).toBe('webhook-active')
+    })
+
+    it('updates webhook url and events', async () => {
+      const webhook: Webhook = {
+        id: 'webhook-update-1',
+        url: 'https://old.example.com/webhook',
+        events: ['user.created'],
+        secret: 'whsec_test_old',
+        active: true,
+      }
+
+      await webhooksCollection.insert(webhook)
+
+      const updated = await webhooksCollection.update(
+        { id: 'webhook-update-1' },
+        {
+          url: 'https://new.example.com/webhook',
+          events: ['user.created', 'user.deleted'],
+        }
+      )
+
+      expect(updated).toHaveLength(1)
+      expect(updated[0].url).toBe('https://new.example.com/webhook')
+      expect(updated[0].events).toHaveLength(2)
+    })
+
+    it('disables a webhook', async () => {
+      const webhook: Webhook = {
+        id: 'webhook-disable-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created'],
+        secret: 'whsec_test_abc',
+        active: true,
+      }
+
+      await webhooksCollection.insert(webhook)
+
+      const updated = await webhooksCollection.update(
+        { id: 'webhook-disable-1' },
+        { active: false }
+      )
+
+      expect(updated[0].active).toBe(false)
+    })
+
+    it('deletes a webhook', async () => {
+      const webhook: Webhook = {
+        id: 'webhook-delete-1',
+        url: 'https://example.com/webhook',
+        events: ['test'],
+        secret: 'whsec_test_delete',
+        active: true,
+      }
+
+      await webhooksCollection.insert(webhook)
+      await webhooksCollection.delete({ id: 'webhook-delete-1' })
+
+      const found = await webhooksCollection.findOne({ id: 'webhook-delete-1' })
+      expect(found).toBeNull()
+    })
+  })
+})
+
+// ============================================================================
+// Teams Collection Tests
+// ============================================================================
+
+describe('Teams Collection', () => {
+  let teamsCollection: ReturnType<typeof TeamsCollection>
+
+  beforeEach(() => {
+    teamsCollection = TeamsCollection()
+  })
+
+  describe('schema validation', () => {
+    it('validates a valid team object', () => {
+      const validTeam: Team = {
+        id: 'team-1',
+        name: 'Engineering',
+        members: ['user-1', 'user-2', 'user-3'],
+      }
+
+      const result = TeamSchema.safeParse(validTeam)
+      expect(result.success).toBe(true)
+    })
+
+    it('requires id field', () => {
+      const invalidTeam = {
+        name: 'Engineering',
+        members: ['user-1'],
+      }
+
+      const result = TeamSchema.safeParse(invalidTeam)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires name field', () => {
+      const invalidTeam = {
+        id: 'team-1',
+        members: ['user-1'],
+      }
+
+      const result = TeamSchema.safeParse(invalidTeam)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires members as array of user IDs', () => {
+      const invalidTeam = {
+        id: 'team-1',
+        name: 'Engineering',
+        members: 'user-1',
+      }
+
+      const result = TeamSchema.safeParse(invalidTeam)
+      expect(result.success).toBe(false)
+    })
+
+    it('allows empty members array', () => {
+      const team: Team = {
+        id: 'team-empty',
+        name: 'Future Team',
+        members: [],
+      }
+
+      const result = TeamSchema.safeParse(team)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('inserts a new team', async () => {
+      const newTeam: Team = {
+        id: 'team-insert-1',
+        name: 'Product',
+        members: ['user-1', 'user-2'],
+      }
+
+      const inserted = await teamsCollection.insert(newTeam)
+      expect(inserted.id).toBe('team-insert-1')
+      expect(inserted.name).toBe('Product')
+      expect(inserted.members).toHaveLength(2)
+    })
+
+    it('finds teams by id', async () => {
+      const team: Team = {
+        id: 'team-find-1',
+        name: 'Design',
+        members: ['user-designer-1'],
+      }
+
+      await teamsCollection.insert(team)
+      const found = await teamsCollection.findOne({ id: 'team-find-1' })
+
+      expect(found).not.toBeNull()
+      expect(found?.name).toBe('Design')
+      expect(found?.members).toContain('user-designer-1')
+    })
+
+    it('finds all teams', async () => {
+      const teams: Team[] = [
+        { id: 'team-1', name: 'Engineering', members: ['user-1'] },
+        { id: 'team-2', name: 'Product', members: ['user-2'] },
+        { id: 'team-3', name: 'Design', members: ['user-3'] },
+      ]
+
+      for (const team of teams) {
+        await teamsCollection.insert(team)
+      }
+
+      const allTeams = await teamsCollection.findMany()
+      expect(allTeams).toHaveLength(3)
+    })
+
+    it('updates team name', async () => {
+      const team: Team = {
+        id: 'team-update-1',
+        name: 'Old Name',
+        members: ['user-1'],
+      }
+
+      await teamsCollection.insert(team)
+
+      const updated = await teamsCollection.update(
+        { id: 'team-update-1' },
+        { name: 'New Name' }
+      )
+
+      expect(updated).toHaveLength(1)
+      expect(updated[0].name).toBe('New Name')
+      expect(updated[0].members).toEqual(['user-1'])
+    })
+
+    it('adds a member to team', async () => {
+      const team: Team = {
+        id: 'team-members-1',
+        name: 'Engineering',
+        members: ['user-1', 'user-2'],
+      }
+
+      await teamsCollection.insert(team)
+
+      const updated = await teamsCollection.update(
+        { id: 'team-members-1' },
+        { members: ['user-1', 'user-2', 'user-3'] }
+      )
+
+      expect(updated[0].members).toHaveLength(3)
+      expect(updated[0].members).toContain('user-3')
+    })
+
+    it('removes a member from team', async () => {
+      const team: Team = {
+        id: 'team-remove-1',
+        name: 'Engineering',
+        members: ['user-1', 'user-2', 'user-3'],
+      }
+
+      await teamsCollection.insert(team)
+
+      const updated = await teamsCollection.update(
+        { id: 'team-remove-1' },
+        { members: ['user-1', 'user-3'] }
+      )
+
+      expect(updated[0].members).toHaveLength(2)
+      expect(updated[0].members).not.toContain('user-2')
+    })
+
+    it('deletes a team', async () => {
+      const team: Team = {
+        id: 'team-delete-1',
+        name: 'To Delete',
+        members: ['user-1'],
+      }
+
+      await teamsCollection.insert(team)
+      await teamsCollection.delete({ id: 'team-delete-1' })
+
+      const found = await teamsCollection.findOne({ id: 'team-delete-1' })
+      expect(found).toBeNull()
+    })
+  })
+})
+
+// ============================================================================
+// Usage Collection Tests
+// ============================================================================
+
+describe('Usage Collection', () => {
+  let usageCollection: ReturnType<typeof UsageCollection>
+
+  beforeEach(() => {
+    usageCollection = UsageCollection()
+  })
+
+  describe('schema validation', () => {
+    it('validates a valid usage object', () => {
+      const validUsage: Usage = {
+        id: 'usage-1',
+        metric: 'api_calls',
+        value: 1500,
+        timestamp: new Date('2024-01-15T10:30:00Z'),
+      }
+
+      const result = UsageSchema.safeParse(validUsage)
+      expect(result.success).toBe(true)
+    })
+
+    it('requires id field', () => {
+      const invalidUsage = {
+        metric: 'api_calls',
+        value: 1500,
+        timestamp: new Date(),
+      }
+
+      const result = UsageSchema.safeParse(invalidUsage)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires metric field', () => {
+      const invalidUsage = {
+        id: 'usage-1',
+        value: 1500,
+        timestamp: new Date(),
+      }
+
+      const result = UsageSchema.safeParse(invalidUsage)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires value as number', () => {
+      const invalidUsage = {
+        id: 'usage-1',
+        metric: 'api_calls',
+        value: '1500',
+        timestamp: new Date(),
+      }
+
+      const result = UsageSchema.safeParse(invalidUsage)
+      expect(result.success).toBe(false)
+    })
+
+    it('requires timestamp as Date', () => {
+      const invalidUsage = {
+        id: 'usage-1',
+        metric: 'api_calls',
+        value: 1500,
+        timestamp: '2024-01-15T10:30:00Z',
+      }
+
+      const result = UsageSchema.safeParse(invalidUsage)
+      expect(result.success).toBe(false)
+    })
+
+    it('allows positive and zero values', () => {
+      const validUsages: Usage[] = [
+        {
+          id: 'usage-positive',
+          metric: 'api_calls',
+          value: 1500,
+          timestamp: new Date(),
+        },
+        {
+          id: 'usage-zero',
+          metric: 'errors',
+          value: 0,
+          timestamp: new Date(),
+        },
+      ]
+
+      validUsages.forEach((usage) => {
+        const result = UsageSchema.safeParse(usage)
+        expect(result.success).toBe(true)
+      })
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('inserts a new usage record', async () => {
+      const newUsage: Usage = {
+        id: 'usage-insert-1',
+        metric: 'api_calls',
+        value: 2500,
+        timestamp: new Date('2024-01-15T10:00:00Z'),
+      }
+
+      const inserted = await usageCollection.insert(newUsage)
+      expect(inserted.id).toBe('usage-insert-1')
+      expect(inserted.metric).toBe('api_calls')
+      expect(inserted.value).toBe(2500)
+    })
+
+    it('finds usage records by id', async () => {
+      const usage: Usage = {
+        id: 'usage-find-1',
+        metric: 'bandwidth',
+        value: 5000,
+        timestamp: new Date(),
+      }
+
+      await usageCollection.insert(usage)
+      const found = await usageCollection.findOne({ id: 'usage-find-1' })
+
+      expect(found).not.toBeNull()
+      expect(found?.metric).toBe('bandwidth')
+      expect(found?.value).toBe(5000)
+    })
+
+    it('finds usage records by metric', async () => {
+      const usageRecords: Usage[] = [
+        {
+          id: 'usage-1',
+          metric: 'api_calls',
+          value: 1000,
+          timestamp: new Date('2024-01-01'),
+        },
+        {
+          id: 'usage-2',
+          metric: 'api_calls',
+          value: 1500,
+          timestamp: new Date('2024-01-02'),
+        },
+        {
+          id: 'usage-3',
+          metric: 'bandwidth',
+          value: 5000,
+          timestamp: new Date('2024-01-01'),
+        },
+      ]
+
+      for (const record of usageRecords) {
+        await usageCollection.insert(record)
+      }
+
+      const apiCalls = await usageCollection.findMany({
+        where: { metric: 'api_calls' },
+      })
+
+      expect(apiCalls).toHaveLength(2)
+      apiCalls.forEach((record) => {
+        expect(record.metric).toBe('api_calls')
+      })
+    })
+
+    it('sorts usage by timestamp descending', async () => {
+      const usageRecords: Usage[] = [
+        {
+          id: 'usage-old',
+          metric: 'api_calls',
+          value: 1000,
+          timestamp: new Date('2024-01-01T10:00:00Z'),
+        },
+        {
+          id: 'usage-new',
+          metric: 'api_calls',
+          value: 2000,
+          timestamp: new Date('2024-01-15T10:00:00Z'),
+        },
+      ]
+
+      for (const record of usageRecords) {
+        await usageCollection.insert(record)
+      }
+
+      const sorted = await usageCollection.findMany({
+        orderBy: { timestamp: 'desc' },
+      })
+
+      expect(sorted[0].id).toBe('usage-new')
+      expect(sorted[1].id).toBe('usage-old')
+    })
+
+    it('updates usage value', async () => {
+      const usage: Usage = {
+        id: 'usage-update-1',
+        metric: 'api_calls',
+        value: 1000,
+        timestamp: new Date(),
+      }
+
+      await usageCollection.insert(usage)
+
+      const updated = await usageCollection.update(
+        { id: 'usage-update-1' },
+        { value: 1500 }
+      )
+
+      expect(updated).toHaveLength(1)
+      expect(updated[0].value).toBe(1500)
+      expect(updated[0].metric).toBe('api_calls')
+    })
+
+    it('deletes a usage record', async () => {
+      const usage: Usage = {
+        id: 'usage-delete-1',
+        metric: 'api_calls',
+        value: 1000,
+        timestamp: new Date(),
+      }
+
+      await usageCollection.insert(usage)
+      await usageCollection.delete({ id: 'usage-delete-1' })
+
+      const found = await usageCollection.findOne({ id: 'usage-delete-1' })
+      expect(found).toBeNull()
+    })
+
+    it('filters by value range', async () => {
+      const usageRecords: Usage[] = [
+        {
+          id: 'usage-small',
+          metric: 'errors',
+          value: 10,
+          timestamp: new Date(),
+        },
+        {
+          id: 'usage-medium',
+          metric: 'errors',
+          value: 500,
+          timestamp: new Date(),
+        },
+        {
+          id: 'usage-large',
+          metric: 'errors',
+          value: 2000,
+          timestamp: new Date(),
+        },
+      ]
+
+      for (const record of usageRecords) {
+        await usageCollection.insert(record)
+      }
+
+      const highUsage = await usageCollection.findMany({
+        where: { value: { $gt: 100 } },
+      })
+
+      expect(highUsage).toHaveLength(2)
+      expect(highUsage.every((r) => r.value > 100)).toBe(true)
+    })
+  })
+
+  describe('subscriptions', () => {
+    it('subscribes to usage collection changes', async () => {
+      let lastData: Usage[] | null = null
+
+      const unsubscribe = usageCollection.subscribe((data) => {
+        lastData = data
+      })
+
+      const usage: Usage = {
+        id: 'usage-sub-1',
+        metric: 'api_calls',
+        value: 1000,
+        timestamp: new Date(),
+      }
+
+      await usageCollection.insert(usage)
+
+      expect(lastData).not.toBeNull()
+      expect(lastData).toHaveLength(1)
+      expect(lastData![0].id).toBe('usage-sub-1')
+
+      unsubscribe()
+    })
+  })
+})
+
+// ============================================================================
+// Cross-Collection Integration Tests
+// ============================================================================
+
+describe('SaaS Collections Integration', () => {
+  describe('type safety', () => {
+    it('enforces type consistency for User objects', () => {
+      const user: User = {
+        id: 'user-1',
+        name: 'Alice',
+        email: 'alice@example.com',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      expect(user.role).toMatch(/admin|user|viewer/)
+    })
+
+    it('enforces type consistency for APIKey objects', () => {
+      const key: APIKey = {
+        id: 'key-1',
+        key: 'sk_test_abc',
+        name: 'Test',
+        permissions: ['read:api'],
+        expiresAt: new Date(),
+      }
+
+      expect(Array.isArray(key.permissions)).toBe(true)
+    })
+
+    it('enforces type consistency for Webhook objects', () => {
+      const webhook: Webhook = {
+        id: 'webhook-1',
+        url: 'https://example.com/webhook',
+        events: ['user.created'],
+        secret: 'whsec_test_abc',
+        active: true,
+      }
+
+      expect(typeof webhook.active).toBe('boolean')
+    })
+
+    it('enforces type consistency for Team objects', () => {
+      const team: Team = {
+        id: 'team-1',
+        name: 'Engineering',
+        members: ['user-1', 'user-2'],
+      }
+
+      expect(Array.isArray(team.members)).toBe(true)
+    })
+
+    it('enforces type consistency for Usage objects', () => {
+      const usage: Usage = {
+        id: 'usage-1',
+        metric: 'api_calls',
+        value: 1500,
+        timestamp: new Date(),
+      }
+
+      expect(typeof usage.value).toBe('number')
+      expect(usage.timestamp instanceof Date).toBe(true)
+    })
+  })
+
+  describe('error handling', () => {
+    it('validates schema strictly with safeParse', () => {
+      const invalidUser = {
+        id: 'user-1',
+        name: 'Alice',
+        email: 'invalid-email',
+        role: 'admin',
+        createdAt: new Date(),
+      }
+
+      const result = UserSchema.safeParse(invalidUser)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.issues).toBeDefined()
+        expect(result.error.issues.length).toBeGreaterThan(0)
+      }
+    })
+
+    it('provides detailed error information', () => {
+      const invalidKey = {
+        id: 'key-1',
+        key: 'sk_test_abc',
+        name: 'Test',
+      }
+
+      const result = APIKeySchema.safeParse(invalidKey)
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.issues.length).toBeGreaterThanOrEqual(2)
+      }
+    })
+  })
+})