@deessejs/collections 0.0.1

package/tests/integration/hooks.test.ts

@@ -0,0 +1,329 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { Pool } from 'pg'
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { collection } from '../../src/collection'
+import { field } from '../../src/field'
+import { f } from '../../src'
+import { buildTable } from '../../src/schema'
+import { createCollectionOperations } from '../../src/operations/collection-operations'
+
+// Skip all tests if no DATABASE_URL is provided
+const dbUrl = process.env.DATABASE_URL
+const itIfDb = dbUrl ? it : it.skip
+
+describe('hooks integration with real database', () => {
+  let pool: any
+  let db: any
+
+  const testTableName = `test_users_${Date.now()}`
+
+  beforeAll(async () => {
+    if (!dbUrl) {
+      console.log('DATABASE_URL not set, skipping integration tests')
+      return
+    }
+
+    try {
+      // Use pg Pool for PostgreSQL
+      pool = new Pool({ connectionString: dbUrl })
+      db = drizzle(pool)
+
+      // Create test table
+      await pool.query(`
+        CREATE TABLE ${testTableName} (
+          id SERIAL PRIMARY KEY,
+          name TEXT NOT NULL,
+          email TEXT,
+          active BOOLEAN DEFAULT true,
+          created_at TIMESTAMP DEFAULT NOW()
+        )
+      `)
+
+      console.log(`Table ${testTableName} created`)
+    } catch (error) {
+      console.error('Failed to setup test table:', error)
+      throw error
+    }
+  }, 60000)
+
+  afterAll(async () => {
+    if (pool) {
+      try {
+        await pool.query(`DROP TABLE IF EXISTS ${testTableName}`)
+        await pool.end()
+      } catch (error) {
+        console.error('Failed to cleanup test table:', error)
+      }
+    }
+  }, 60000)
+
+  itIfDb('executes hooks in correct order for create', async () => {
+    const executionOrder: string[] = []
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() }),
+        email: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeOperation: [async () => { executionOrder.push('beforeOperation') }],
+        beforeCreate: [async () => { executionOrder.push('beforeCreate') }],
+        afterCreate: [async () => { executionOrder.push('afterCreate') }],
+        afterOperation: [async () => { executionOrder.push('afterOperation') }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    await operations.create({
+      data: { name: 'John', email: 'john@example.com' },
+      returning: true
+    })
+
+    expect(executionOrder).toEqual([
+      'beforeOperation',
+      'beforeCreate',
+      'afterCreate',
+      'afterOperation'
+    ])
+  })
+
+  itIfDb('passes correct context to create hooks', async () => {
+    let receivedContext: any = null
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeCreate: [async (context) => { receivedContext = context }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    await operations.create({
+      data: { name: 'Jane' }
+    })
+
+    expect(receivedContext.collection).toBe(testTableName)
+    expect(receivedContext.operation).toBe('create')
+    expect(receivedContext.data.name).toBe('Jane')
+    expect(receivedContext.db).toBeDefined()
+  })
+
+  itIfDb('hooks can modify data before create', async () => {
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() }),
+        email: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeCreate: [async (context) => {
+          context.data.email = 'modified@example.com'
+        }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    const result = await operations.create({
+      data: { name: 'Test', email: 'original@example.com' },
+      returning: true
+    })
+
+    expect(result?.email).toBe('modified@example.com')
+  })
+
+  itIfDb('executes hooks in correct order for update', async () => {
+    const executionOrder: string[] = []
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeOperation: [async () => { executionOrder.push('beforeOperation') }],
+        beforeUpdate: [async () => { executionOrder.push('beforeUpdate') }],
+        afterUpdate: [async () => { executionOrder.push('afterUpdate') }],
+        afterOperation: [async () => { executionOrder.push('afterOperation') }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    const created = await operations.create({
+      data: { name: 'Original' },
+      returning: true
+    })
+
+    executionOrder.length = 0
+
+    await operations.update({
+      where: { id: created?.id },
+      data: { name: 'Updated' }
+    })
+
+    expect(executionOrder).toEqual([
+      'beforeOperation',
+      'beforeUpdate',
+      'afterUpdate',
+      'afterOperation'
+    ])
+  })
+
+  itIfDb('passes previousData to update hooks', async () => {
+    let previousData: any = null
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeUpdate: [async (context) => { previousData = context.previousData }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    const created = await operations.create({
+      data: { name: 'Original' },
+      returning: true
+    })
+
+    await operations.update({
+      where: { id: created?.id },
+      data: { name: 'Updated' }
+    })
+
+    expect(previousData?.name).toBe('Original')
+  })
+
+  itIfDb('executes hooks in correct order for delete', async () => {
+    const executionOrder: string[] = []
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeOperation: [async () => { executionOrder.push('beforeOperation') }],
+        beforeDelete: [async () => { executionOrder.push('beforeDelete') }],
+        afterDelete: [async () => { executionOrder.push('afterDelete') }],
+        afterOperation: [async () => { executionOrder.push('afterOperation') }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    const created = await operations.create({
+      data: { name: 'ToDelete' },
+      returning: true
+    })
+
+    executionOrder.length = 0
+
+    await operations.delete({
+      where: { id: created?.id }
+    })
+
+    expect(executionOrder).toEqual([
+      'beforeOperation',
+      'beforeDelete',
+      'afterDelete',
+      'afterOperation'
+    ])
+  })
+
+  itIfDb('executes hooks for read operations', async () => {
+    const executionOrder: string[] = []
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeOperation: [async () => { executionOrder.push('beforeOperation') }],
+        beforeRead: [async () => { executionOrder.push('beforeRead') }],
+        afterRead: [async () => { executionOrder.push('afterRead') }],
+        afterOperation: [async () => { executionOrder.push('afterOperation') }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    await operations.findMany()
+
+    expect(executionOrder).toEqual([
+      'beforeOperation',
+      'beforeRead',
+      'afterRead',
+      'afterOperation'
+    ])
+  })
+
+  itIfDb('throws error when beforeOperation hook throws', async () => {
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeOperation: [async () => { throw new Error('Hook error') }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    await expect(operations.findMany()).rejects.toThrow('Hook error')
+  })
+
+  itIfDb('createMany executes hooks for each item', async () => {
+    const executionOrder: string[] = []
+
+    const users = collection({
+      slug: testTableName,
+      fields: {
+        name: field({ fieldType: f.text() })
+      },
+      hooks: {
+        beforeCreate: [async (context) => {
+          executionOrder.push(`before-${context.data.name}`)
+        }],
+        afterCreate: [async (context) => {
+          executionOrder.push(`after-${context.data.name}`)
+        }]
+      }
+    })
+
+    const table = buildTable(users)
+    const operations = createCollectionOperations(users, testTableName, db, table, users.hooks)
+
+    await operations.createMany({
+      data: [
+        { name: 'Alice' },
+        { name: 'Bob' }
+      ]
+    })
+
+    expect(executionOrder).toContain('before-Alice')
+    expect(executionOrder).toContain('before-Bob')
+    expect(executionOrder).toContain('after-Alice')
+    expect(executionOrder).toContain('after-Bob')
+  })
+})

package/tests/metadata.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest'
+import { defineConfig, collection, field, f } from '../src'
+import { testAdapter, testCollections } from './fixtures'
+
+describe('Collection Metadata', () => {
+  describe('collections return metadata (slug, name, fields)', () => {
+    it('collections.users has slug property', () => {
+      const users = collection({
+        slug: 'users',
+        name: 'Users',
+        fields: {
+          name: field({ fieldType: f.text() }),
+          email: field({ fieldType: f.email() })
+        }
+      })
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [users]
+      })
+
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.users.name).toBe('Users')
+      expect(config.collections.users.fields).toBeDefined()
+    })
+
+    it('collections.users has optional name property', () => {
+      const users = collection({
+        slug: 'users',
+        fields: { name: field({ fieldType: f.text() }) }
+      })
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [users]
+      })
+
+      expect(config.collections.users.name).toBeUndefined()
+    })
+
+    it('collections.users has fields property', () => {
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() }),
+          email: field({ fieldType: f.email() })
+        }
+      })
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [users]
+      })
+
+      expect(config.collections.users.fields.name).toBeDefined()
+      expect(config.collections.users.fields.email).toBeDefined()
+    })
+
+    it('preserves collection slug and name', () => {
+      const users = collection({
+        slug: 'users',
+        name: 'Users',
+        fields: { name: field({ fieldType: f.text() }) }
+      })
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [users]
+      })
+
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.users.name).toBe('Users')
+    })
+  })
+
+  describe('collections do NOT have operations', () => {
+    it('collections does NOT have findMany, create, update, delete', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      expect(config.collections.users.findMany).toBeUndefined()
+      expect(config.collections.users.create).toBeUndefined()
+      expect(config.collections.users.update).toBeUndefined()
+      expect(config.collections.users.delete).toBeUndefined()
+    })
+  })
+
+  describe('multiple collections metadata', () => {
+    it('config.collections has correct keys for multiple collections', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users, testCollections.posts, testCollections.comments]
+      })
+
+      expect(config.collections.users).toBeDefined()
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.posts).toBeDefined()
+      expect(config.collections.posts.slug).toBe('posts')
+      expect(config.collections.comments).toBeDefined()
+      expect(config.collections.comments.slug).toBe('comments')
+    })
+
+    it('can access different collections metadata', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users, testCollections.posts]
+      })
+
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.posts.slug).toBe('posts')
+    })
+  })
+
+  describe('$meta collections tracking', () => {
+    it('$meta.collections is array of slugs', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users, testCollections.posts]
+      })
+
+      expect(config.$meta.collections).toContain('users')
+      expect(config.$meta.collections).toContain('posts')
+      expect(config.$meta.collections).toHaveLength(2)
+    })
+
+    it('$meta.plugins is array of plugin names', () => {
+      const mockPlugin = {
+        name: 'test-plugin',
+        collections: {}
+      }
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users],
+        plugins: [mockPlugin]
+      })
+
+      expect(config.$meta.plugins).toContain('test-plugin')
+    })
+
+    it('tracks plugin collections correctly', () => {
+      const mockPlugin1 = {
+        name: 'plugin-1',
+        collections: {
+          plugin1Table: collection({
+            slug: 'plugin1Table',
+            fields: { data: field({ fieldType: f.text() }) }
+          })
+        }
+      }
+
+      const mockPlugin2 = {
+        name: 'plugin-2',
+        collections: {
+          plugin2Table: collection({
+            slug: 'plugin2Table',
+            fields: { value: field({ fieldType: f.text() }) }
+          })
+        }
+      }
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users],
+        plugins: [mockPlugin1, mockPlugin2]
+      })
+
+      expect(config.$meta.collections).toHaveLength(3)
+      expect(config.$meta.plugins).toHaveLength(2)
+      expect(config.$meta.plugins).toContain('plugin-1')
+      expect(config.$meta.plugins).toContain('plugin-2')
+    })
+
+    it('works with empty collections array', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: []
+      })
+
+      expect(Object.keys(config.collections)).toHaveLength(0)
+      expect(config.$meta.collections).toHaveLength(0)
+    })
+  })
+})
+
+describe('DB Instance', () => {
+  describe('db is Drizzle instance', () => {
+    it('db is defined', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      expect(config.db).toBeDefined()
+      expect(config.db).not.toBeNull()
+    })
+  })
+})

package/tests/schema.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { buildSchema, buildTable } from '../src'
+import { collection } from '../src/collection'
+import { field } from '../src/field'
+import { f } from '../src'
+
+describe('buildSchema', () => {
+  it('builds a table from a collection', () => {
+    const users = collection({
+      slug: 'users',
+      fields: {
+        name: field({ fieldType: f.text() }),
+        email: field({ fieldType: f.text() })
+      }
+    })
+
+    const table = buildTable(users)
+
+    expect(table).toBeDefined()
+  })
+
+  it('builds schema from multiple collections', () => {
+    const users = collection({
+      slug: 'users',
+      fields: {
+        name: field({ fieldType: f.text() })
+      }
+    })
+
+    const posts = collection({
+      slug: 'posts',
+      fields: {
+        title: field({ fieldType: f.text() })
+      }
+    })
+
+    const schema = buildSchema([users, posts])
+
+    expect(schema.users).toBeDefined()
+    expect(schema.posts).toBeDefined()
+  })
+
+  it('handles different field types', () => {
+    const items = collection({
+      slug: 'items',
+      fields: {
+        name: field({ fieldType: f.text() }),
+        count: field({ fieldType: f.number() }),
+        active: field({ fieldType: f.boolean() }),
+        createdAt: field({ fieldType: f.timestamp() })
+      }
+    })
+
+    const schema = buildSchema([items])
+
+    expect(schema.items).toBeDefined()
+  })
+})

package/tests/type-inference.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest'
+import { defineConfig, collection, field, f } from '../src'
+import { testAdapter, testCollections } from './fixtures'
+
+describe('Type Inference', () => {
+  describe('collection slug inference', () => {
+    it('infers users and posts as collection keys', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users, testCollections.posts]
+      })
+
+      // Type test: config.collections should have users and posts keys
+      const _users = config.collections.users
+      const _posts = config.collections.posts
+
+      expect(_users).toBeDefined()
+      expect(_posts).toBeDefined()
+    })
+
+    it('infers single collection slug', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      const _users = config.collections.users
+      expect(_users).toBeDefined()
+    })
+
+    it('infers $meta.collections as array of slugs', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users, testCollections.posts]
+      })
+
+      // Type test: $meta.collections should be string[]
+      const _meta: string[] = config.$meta.collections
+      expect(_meta).toContain('users')
+      expect(_meta).toContain('posts')
+    })
+  })
+
+  describe('collections have metadata only', () => {
+    it('collections have slug property', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      // Collections have metadata
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.users.fields).toBeDefined()
+    })
+
+    it('collections do NOT have operations', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      // Operations should not exist on collections
+      expect(config.collections.users.findMany).toBeUndefined()
+      expect(config.collections.users.create).toBeUndefined()
+    })
+  })
+
+  describe('db is Drizzle instance', () => {
+    it('db is defined', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [testCollections.users]
+      })
+
+      expect(config.db).toBeDefined()
+    })
+  })
+
+  describe('empty collections', () => {
+    it('works with empty collections array', () => {
+      const config = defineConfig({
+        database: testAdapter,
+        collections: []
+      })
+
+      // Type test: collections should be empty object
+      expect(Object.keys(config.collections)).toHaveLength(0)
+    })
+  })
+
+  describe('collection metadata type', () => {
+    it('preserves collection slug and name', () => {
+      const users = collection({
+        slug: 'users',
+        name: 'Users',
+        fields: { name: field({ fieldType: f.text() }) }
+      })
+
+      const config = defineConfig({
+        database: testAdapter,
+        collections: [users]
+      })
+
+      expect(config.collections.users.slug).toBe('users')
+      expect(config.collections.users.name).toBe('Users')
+    })
+  })
+})