@deessejs/collections 0.0.1

package/src/operations/index.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export * from './collection-operations'

package/src/operations/types.ts

@@ -0,0 +1,141 @@
+/**
+ * Extract field names from a collection's fields
+ */
+export type CollectionFieldNames<T extends Record<string, { fieldType: { schema: unknown } }>> = keyof T
+
+/**
+ * Extract field schema type from a field definition
+ */
+export type FieldSchema<T extends { fieldType: { schema: unknown } }> = T['fieldType']['schema']
+
+/**
+ * Where condition operators
+ */
+export type WhereOperator<T> =
+  | { eq: T }
+  | { neq: T }
+  | { gt: T }
+  | { gte: T }
+  | { lt: T }
+  | { lte: T }
+  | { in: T[] }
+  | { notIn: T[] }
+  | { contains: T }
+  | { startsWith: T }
+  | { endsWith: T }
+  | { isNull: boolean }
+  | { not: T }
+
+/**
+ * Where condition value
+ */
+export type WhereValue<T> = T | WhereOperator<T>
+
+/**
+ * Where conditions
+ */
+export type WhereConditions<T = Record<string, unknown>> = T
+
+/**
+ * Order by direction
+ */
+export type OrderByDirection = 'asc' | 'desc'
+
+/**
+ * Order by clause
+ */
+export type OrderByClause<T = Record<string, unknown>> = T
+
+/**
+ * Select clause - fields to return
+ */
+export type SelectClause<T = Record<string, unknown>> = Partial<Record<keyof T, boolean>>
+
+/**
+ * Find many options
+ */
+export type FindManyOptions<T = Record<string, unknown>> = {
+  where?: WhereConditions<T>
+  orderBy?: OrderByClause<T> | OrderByClause<T>[]
+  limit?: number
+  offset?: number
+  select?: SelectClause<T>
+}
+
+/**
+ * Find unique options
+ */
+export type FindUniqueOptions<T = Record<string, unknown>> = {
+  where: WhereConditions<T>
+  select?: SelectClause<T>
+}
+
+/**
+ * Find first options
+ */
+export type FindFirstOptions<T = Record<string, unknown>> = {
+  where: WhereConditions<T>
+  orderBy?: OrderByClause<T> | OrderByClause<T>[]
+  select?: SelectClause<T>
+}
+
+/**
+ * Create options
+ */
+export type CreateOptions<T> = {
+  data: T
+  returning?: boolean
+}
+
+/**
+ * Create many options
+ */
+export type CreateManyOptions<T> = {
+  data: T[]
+}
+
+/**
+ * Update options
+ */
+export type UpdateOptions<T, TFields = Record<string, unknown>> = {
+  where: WhereConditions<TFields>
+  data: Partial<T>
+  returning?: boolean
+}
+
+/**
+ * Update many options
+ */
+export type UpdateManyOptions<T, TFields = Record<string, unknown>> = {
+  where: WhereConditions<TFields>
+  data: Partial<T>
+}
+
+/**
+ * Delete options
+ */
+export type DeleteOptions<TFields = Record<string, unknown>> = {
+  where: WhereConditions<TFields>
+  returning?: boolean
+}
+
+/**
+ * Delete many options
+ */
+export type DeleteManyOptions<TFields = Record<string, unknown>> = {
+  where: WhereConditions<TFields>
+}
+
+/**
+ * Count options
+ */
+export type CountOptions<TFields = Record<string, unknown>> = {
+  where?: WhereConditions<TFields>
+}
+
+/**
+ * Exists options
+ */
+export type ExistsOptions<TFields = Record<string, unknown>> = {
+  where: WhereConditions<TFields>
+}

package/src/schema.ts

@@ -0,0 +1,62 @@
+import { pgTable, serial, text, timestamp, uuid, varchar, boolean, integer } from 'drizzle-orm/pg-core'
+
+import type { Collection } from './collection'
+
+/**
+ * Build Drizzle table from collection definition
+ */
+export const buildTable = (collection: Collection) => {
+  // Build columns object
+  const columns: Record<string, unknown> = {
+    // Add default id column
+    id: serial('id').primaryKey()
+  }
+
+  // Build columns from fields
+  for (const [fieldName, fieldDef] of Object.entries(collection.fields)) {
+    // Skip the id field if explicitly defined in fields
+    if (fieldName === 'id') continue
+
+    const fieldType = fieldDef.fieldType as { name?: string; type?: string }
+    const fieldTypeName = fieldType.name || fieldType.type || 'text'
+
+    switch (fieldTypeName) {
+      case 'text':
+        columns[fieldName] = text(fieldName)
+        break
+      case 'varchar':
+        columns[fieldName] = varchar(fieldName, { length: 255 })
+        break
+      case 'number':
+      case 'integer':
+        columns[fieldName] = integer(fieldName)
+        break
+      case 'boolean':
+        columns[fieldName] = boolean(fieldName)
+        break
+      case 'timestamp':
+        columns[fieldName] = timestamp(fieldName)
+        break
+      case 'uuid':
+        columns[fieldName] = uuid(fieldName)
+        break
+      default:
+        columns[fieldName] = text(fieldName)
+    }
+  }
+
+  return pgTable(collection.slug, columns as Record<string, ReturnType<typeof text>>)
+}
+
+/**
+ * Build all tables from collections
+ */
+export const buildSchema = (collections: Collection[]) => {
+  const tables: Record<string, ReturnType<typeof pgTable>> = {}
+
+  for (const coll of collections) {
+    tables[coll.slug] = buildTable(coll)
+  }
+
+  return tables
+}

package/tests/adapter.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest'
+import { pgAdapter, type PgAdapter, type DatabaseAdapter } from '../src'
+import { testAdapter } from './fixtures'
+
+describe('pgAdapter', () => {
+  it('creates a postgres adapter with url', () => {
+    const adapter = pgAdapter({ url: 'postgres://user:pass@localhost:5432/db' })
+
+    expect(adapter.type).toBe('postgres')
+    expect(adapter.config.url).toBe('postgres://user:pass@localhost:5432/db')
+  })
+
+  it('creates adapter with default migrations path', () => {
+    const adapter = pgAdapter({ url: 'postgres://localhost:5432/db' })
+
+    expect(adapter.config.migrationsPath).toBe('./migrations')
+  })
+
+  it('creates adapter with custom migrations path', () => {
+    const adapter = pgAdapter({
+      url: 'postgres://localhost:5432/db',
+      migrationsPath: './custom-migrations'
+    })
+
+    expect(adapter.config.migrationsPath).toBe('./custom-migrations')
+  })
+
+  it('has correct type', () => {
+    const _typeCheck: PgAdapter = testAdapter
+    const _dbTypeCheck: DatabaseAdapter = testAdapter
+
+    expect(_typeCheck).toBeDefined()
+    expect(_dbTypeCheck).toBeDefined()
+  })
+})

package/tests/collection.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'vitest'
+import { collection } from '../src/collection'
+import { field } from '../src/field'
+import { f } from '../src'
+
+describe('collection', () => {
+  describe('basic creation', () => {
+    it('creates a basic collection', () => {
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() }),
+          email: field({ fieldType: f.text() })
+        }
+      })
+
+      expect(users.slug).toBe('users')
+      expect(users.name).toBeUndefined()
+      expect(Object.keys(users.fields)).toContain('name')
+      expect(Object.keys(users.fields)).toContain('email')
+    })
+
+    it('creates a collection with name', () => {
+      const users = collection({
+        slug: 'users',
+        name: 'Users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        }
+      })
+
+      expect(users.slug).toBe('users')
+      expect(users.name).toBe('Users')
+    })
+
+    it('creates a collection with various field types', () => {
+      const posts = collection({
+        slug: 'posts',
+        fields: {
+          title: field({ fieldType: f.text() }),
+          views: field({ fieldType: f.number() }),
+          published: field({ fieldType: f.boolean() }),
+          createdAt: field({ fieldType: f.date() }),
+          updatedAt: field({ fieldType: f.timestamp() }),
+          metadata: field({ fieldType: f.json() }),
+          tags: field({ fieldType: f.array(f.text()) }),
+          author: field({ fieldType: f.relation({ collection: 'users' }) })
+        }
+      })
+
+      expect(posts.slug).toBe('posts')
+      expect(Object.keys(posts.fields)).toHaveLength(8)
+    })
+  })
+
+  describe('hooks', () => {
+    it('creates a collection with all hook types', () => {
+      const mockHook = async () => {}
+
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        },
+        hooks: {
+          beforeOperation: [mockHook],
+          afterOperation: [mockHook],
+          beforeCreate: [mockHook],
+          afterCreate: [mockHook],
+          beforeUpdate: [mockHook],
+          afterUpdate: [mockHook],
+          beforeDelete: [mockHook],
+          afterDelete: [mockHook],
+          beforeRead: [mockHook],
+          afterRead: [mockHook]
+        }
+      })
+
+      expect(users.hooks?.beforeOperation).toHaveLength(1)
+      expect(users.hooks?.afterOperation).toHaveLength(1)
+      expect(users.hooks?.beforeCreate).toHaveLength(1)
+      expect(users.hooks?.afterCreate).toHaveLength(1)
+      expect(users.hooks?.beforeUpdate).toHaveLength(1)
+      expect(users.hooks?.afterUpdate).toHaveLength(1)
+      expect(users.hooks?.beforeDelete).toHaveLength(1)
+      expect(users.hooks?.afterDelete).toHaveLength(1)
+      expect(users.hooks?.beforeRead).toHaveLength(1)
+      expect(users.hooks?.afterRead).toHaveLength(1)
+    })
+
+    it('creates a collection without hooks', () => {
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        }
+      })
+
+      expect(users.hooks).toBeUndefined()
+    })
+
+    it('creates a collection with multiple hooks per event', () => {
+      const hook1 = async () => {}
+      const hook2 = async () => {}
+
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        },
+        hooks: {
+          beforeCreate: [hook1, hook2]
+        }
+      })
+
+      expect(users.hooks?.beforeCreate).toHaveLength(2)
+    })
+
+    it('creates a collection with only beforeOperation and afterOperation hooks', () => {
+      const mockHook = async () => {}
+
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        },
+        hooks: {
+          beforeOperation: [mockHook],
+          afterOperation: [mockHook]
+        }
+      })
+
+      expect(users.hooks?.beforeOperation).toHaveLength(1)
+      expect(users.hooks?.afterOperation).toHaveLength(1)
+      expect(users.hooks?.beforeCreate).toBeUndefined()
+    })
+
+    it('creates a collection with only read hooks', () => {
+      const mockHook = async () => {}
+
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text() })
+        },
+        hooks: {
+          beforeRead: [mockHook],
+          afterRead: [mockHook]
+        }
+      })
+
+      expect(users.hooks?.beforeRead).toHaveLength(1)
+      expect(users.hooks?.afterRead).toHaveLength(1)
+      expect(users.hooks?.beforeCreate).toBeUndefined()
+    })
+  })
+
+  describe('field options', () => {
+    it('creates a collection with field options', () => {
+      const users = collection({
+        slug: 'users',
+        fields: {
+          name: field({ fieldType: f.text(), required: true, label: 'Name' }),
+          email: field({ fieldType: f.text(), unique: true, indexed: true }),
+          age: field({ fieldType: f.number(), default: 18 }),
+          bio: field({ fieldType: f.text(), description: 'User biography' })
+        }
+      })
+
+      expect(users.fields.name.required).toBe(true)
+      expect(users.fields.name.label).toBe('Name')
+      expect(users.fields.email.unique).toBe(true)
+      expect(users.fields.email.indexed).toBe(true)
+      expect(users.fields.age.default).toBe(18)
+      expect(users.fields.bio.description).toBe('User biography')
+    })
+
+    it('creates a collection with enum field', () => {
+      const posts = collection({
+        slug: 'posts',
+        fields: {
+          status: field({ fieldType: f.select(['draft', 'published', 'archived']) })
+        }
+      })
+
+      expect(posts.fields.status).toBeDefined()
+    })
+
+    it('creates a collection with relations', () => {
+      const posts = collection({
+        slug: 'posts',
+        fields: {
+          author: field({ fieldType: f.relation({ collection: 'users' }) }),
+          category: field({ fieldType: f.relation({ collection: 'categories', singular: true }) }),
+          tags: field({ fieldType: f.relation({ collection: 'tags', many: true }) })
+        }
+      })
+
+      expect(posts.fields.author).toBeDefined()
+      expect(posts.fields.category).toBeDefined()
+      expect(posts.fields.tags).toBeDefined()
+    })
+  })
+
+})

package/tests/config.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { defineConfig } from '../src'
+import { collection } from '../src/collection'
+import { field } from '../src/field'
+import { f } from '../src'
+import { testAdapter, testCollections } from './fixtures'
+
+describe('defineConfig', () => {
+  it('creates a config with a single collection', () => {
+    const config = defineConfig({
+      database: testAdapter,
+      collections: [testCollections.users]
+    })
+
+    expect(config.collections.users).toBeDefined()
+  })
+
+  it('creates a config with multiple collections', () => {
+    const config = defineConfig({
+      database: testAdapter,
+      collections: [testCollections.users, testCollections.posts]
+    })
+
+    expect(config.collections.users).toBeDefined()
+    expect(config.collections.posts).toBeDefined()
+  })
+
+  it('creates a config with plugins', () => {
+    const mockPlugin = {
+      name: 'test-plugin',
+      collections: {
+        settings: collection({
+          slug: 'settings',
+          fields: { key: field({ fieldType: f.text() }) }
+        })
+      }
+    }
+
+    const config = defineConfig({
+      database: testAdapter,
+      collections: [testCollections.users],
+      plugins: [mockPlugin]
+    })
+
+    expect(config.collections.users).toBeDefined()
+    expect(config.collections.settings).toBeDefined()
+  })
+
+  it('returns drizzle instance for db', () => {
+    const config = defineConfig({
+      database: testAdapter,
+      collections: [testCollections.users]
+    })
+
+    expect(config.db).not.toBeNull()
+    expect(config.db).toBeDefined()
+  })
+})

package/tests/field-type.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect } from 'vitest'
+import { fieldType } from '../src/field-type'
+import { field } from '../src/field'
+import { f } from '../src'
+import { z } from 'zod'
+
+describe('fieldType', () => {
+  it('creates a basic field type', () => {
+    const textField = fieldType({
+      schema: z.string(),
+      database: { type: 'text' }
+    })
+
+    const instance = textField()
+
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({ type: 'text' })
+  })
+
+  it('creates field type without database config', () => {
+    const textField = fieldType({
+      schema: z.string()
+    })
+
+    const instance = textField()
+
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({})
+  })
+})
+
+describe('field', () => {
+  it('creates a basic field', () => {
+    const myField = field({ fieldType: f.text() })
+
+    expect(myField.required).toBe(false)
+    expect(myField.unique).toBe(false)
+    expect(myField.indexed).toBe(false)
+  })
+
+  it('creates a field with options', () => {
+    const myField = field({
+      fieldType: f.text(),
+      required: true,
+      unique: true,
+      indexed: true,
+      default: 'default value',
+      label: 'Name',
+      description: 'User name'
+    })
+
+    expect(myField.required).toBe(true)
+    expect(myField.unique).toBe(true)
+    expect(myField.indexed).toBe(true)
+    expect(myField.default).toBe('default value')
+    expect(myField.label).toBe('Name')
+    expect(myField.description).toBe('User name')
+  })
+
+  it('works with different field types', () => {
+    const textField = field({ fieldType: f.text() })
+    const numberField = field({ fieldType: f.number() })
+    const booleanField = field({ fieldType: f.boolean() })
+    const dateField = field({ fieldType: f.date() })
+    const timestampField = field({ fieldType: f.timestamp() })
+
+    expect(textField.fieldType.schema).toBeInstanceOf(z.ZodString)
+    expect(numberField.fieldType.schema).toBeInstanceOf(z.ZodNumber)
+    expect(booleanField.fieldType.schema).toBeInstanceOf(z.ZodBoolean)
+    expect(dateField.fieldType.schema).toBeInstanceOf(z.ZodDate)
+    expect(timestampField.fieldType.schema).toBeInstanceOf(z.ZodDate)
+  })
+})
+
+describe('built-in field types', () => {
+  it('text field type', () => {
+    const instance = f.text()
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({ type: 'text' })
+  })
+
+  it('email field type', () => {
+    const emailField = fieldType({
+      schema: z.string().email(),
+      database: { type: 'text' }
+    })
+    const instance = emailField()
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+  })
+
+  it('f.email() creates email field type', () => {
+    const instance = f.email()
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({ type: 'text' })
+  })
+
+  it('f.url() creates url field type', () => {
+    const instance = f.url()
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({ type: 'text' })
+  })
+
+  it('number field type', () => {
+    const instance = f.number()
+    expect(instance.schema).toBeInstanceOf(z.ZodNumber)
+  })
+
+  it('boolean field type', () => {
+    const instance = f.boolean()
+    expect(instance.schema).toBeInstanceOf(z.ZodBoolean)
+  })
+
+  it('date field type', () => {
+    const instance = f.date()
+    expect(instance.schema).toBeInstanceOf(z.ZodDate)
+  })
+
+  it('timestamp field type', () => {
+    const instance = f.timestamp()
+    expect(instance.schema).toBeInstanceOf(z.ZodDate)
+  })
+
+  it('enum field type', () => {
+    const status = f.select(['draft', 'published', 'archived'])
+    expect(status.schema).toBeInstanceOf(z.ZodEnum)
+  })
+
+  it('json field type', () => {
+    const instance = f.json()
+    expect(instance.schema).toBeInstanceOf(z.ZodAny)
+  })
+
+  it('array field type', () => {
+    const instance = f.array(z.string())
+    expect(instance.schema).toBeInstanceOf(z.ZodArray)
+  })
+
+  it('relation field type - one-to-many', () => {
+    const instance = f.relation({ collection: 'users' })
+    expect(instance.schema).toBeInstanceOf(z.ZodString)
+    expect(instance.database).toEqual({
+      type: 'integer',
+      references: 'users',
+      through: undefined,
+      many: false,
+      singular: false
+    })
+  })
+
+  it('relation field type - one-to-one', () => {
+    const instance = f.relation({ collection: 'profiles', singular: true })
+    expect(instance.database.singular).toBe(true)
+  })
+
+  it('relation field type - many-to-many', () => {
+    const instance = f.relation({ collection: 'tags', many: true })
+    expect(instance.schema).toBeInstanceOf(z.ZodArray)
+    expect(instance.database.many).toBe(true)
+  })
+})
+
+describe('field with built-in types', () => {
+  it('creates a field with text type', () => {
+    const myField = field({ fieldType: f.text() })
+    expect(myField.fieldType.schema).toBeInstanceOf(z.ZodString)
+  })
+
+  it('creates a field with number type', () => {
+    const myField = field({ fieldType: f.number() })
+    expect(myField.fieldType.schema).toBeInstanceOf(z.ZodNumber)
+  })
+
+  it('creates a field with relation type', () => {
+    const myField = field({
+      fieldType: f.relation({ collection: 'users' }),
+      required: true
+    })
+    expect(myField.required).toBe(true)
+    expect(myField.fieldType.database.references).toBe('users')
+  })
+})