@bairock/lenz 0.0.5 → 0.0.6

package/dist/engine/CodeGenerator.js

@@ -185,11 +185,11 @@ class CodeGenerator {
             });
         }
         // Generate JavaScript file
-        let result = `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-// This file provides JavaScript-compatible exports for TypeScript types.
-// TypeScript projects should use the .d.ts files for full type information.
-
+        let result = `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+// This file provides JavaScript-compatible exports for TypeScript types.
+// TypeScript projects should use the .d.ts files for full type information.
+
 `;
         // Add imports (convert import type to import and add .js extensions)
         const importLines = lines.filter(line => line.includes('import '));
@@ -281,203 +281,203 @@ class CodeGenerator {
         return result;
     }
     generateIndex(clientName) {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-export { ${clientName} } from './client'
-export * from './types'
-export * from './enums'
-
-import { ${clientName} } from './client'
-
-/**
- * Default export for the Lenz client
- */
-const lenz = new ${clientName}()
-export default lenz
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+export { ${clientName} } from './client'
+export * from './types'
+export * from './enums'
+
+import { ${clientName} } from './client'
+
+/**
+ * Default export for the Lenz client
+ */
+const lenz = new ${clientName}()
+export default lenz
 `;
     }
     generateClient(clientName, models) {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { MongoClient, Db, ObjectId } from 'mongodb'
-import type { LenzConfig } from './types'
-import { QueryBuilder } from './runtime/query'
-import { RelationResolver } from './runtime/relations'
-
-${models.map(model => `
-import { ${model.name}Delegate } from './models/${model.name}'`).join('\n')}
-
-export class ${clientName} {
-  private mongoClient: MongoClient | null = null
-  private db: Db | null = null
-  private config: LenzConfig
-  private supportsTransactions: boolean = false
-
-  // Model delegates
-${models.map(model => `  public ${this.toCamelCase(model.name)}: ${model.name}Delegate`).join('\n')}
-
-  constructor(config: LenzConfig = {}) {
-    this.config = {
-      url: config.url || process.env.MONGODB_URI || 'mongodb://localhost:27017',
-      database: config.database || 'myapp',
-      autoCreateCollections: config.autoCreateCollections ?? true,
-      log: config.log || [],
-      ...config
-    }
-
-    // Initialize model delegates
-${models.map(model => `    this.${this.toCamelCase(model.name)} = new ${model.name}Delegate(this)`).join('\n')}
-  }
-
-  async $connect(): Promise<void> {
-    if (this.mongoClient) {
-      return
-    }
-
-    this.mongoClient = new MongoClient(this.config.url, {
-      maxPoolSize: this.config.maxPoolSize || 10,
-      connectTimeoutMS: this.config.connectTimeoutMS || 10000,
-      socketTimeoutMS: this.config.socketTimeoutMS || 45000
-    })
-
-    await this.mongoClient.connect()
-    this.db = this.mongoClient.db(this.config.database)
-
-    // Test connection
-    await this.db.command({ ping: 1 })
-
-    // Check if MongoDB supports transactions (requires replica set)
-    try {
-      const serverInfo = await this.db.admin().serverInfo()
-      this.supportsTransactions = serverInfo.repl?.replSetName !== undefined
-
-      if (!this.supportsTransactions) {
-        console.warn('⚠️  MongoDB is running in standalone mode. Transactions will not work.')
-        console.warn('   Consider setting up a replica set for transaction support.')
-        console.warn('   Example: mongod --replSet rs0 --port 27017')
-      }
-    } catch (error) {
-      console.warn('⚠️  Could not determine MongoDB deployment type:', error.message)
-      this.supportsTransactions = false
-    }
-
-    // Initialize collections and indexes
-    await this.initializeCollections()
-
-    if (this.config.log?.includes('info')) {
-      console.log('✅ Connected to MongoDB')
-    }
-  }
-
-  async $disconnect(): Promise<void> {
-    if (this.mongoClient) {
-      await this.mongoClient.close()
-      this.mongoClient = null
-      this.db = null
-
-      if (this.config.log?.includes('info')) {
-        console.log('👋 Disconnected from MongoDB')
-      }
-    }
-  }
-
-  async $transaction<T>(callback: (tx: any) => Promise<T>): Promise<T> {
-    if (!this.mongoClient) {
-      throw new Error('Not connected to database')
-    }
-
-    // Check if transactions are supported
-    if (!this.supportsTransactions) {
-      throw new Error(
-        'Transactions are not supported in standalone MongoDB. ' +
-        'Set up a replica set or use alternative consistency patterns. ' +
-        'During development: mongod --replSet rs0 --port 27017'
-      )
-    }
-
-    const session = this.mongoClient.startSession()
-
-    try {
-      session.startTransaction()
-      const result = await callback(session)
-      await session.commitTransaction()
-      return result
-    } catch (error) {
-      await session.abortTransaction()
-      throw error
-    } finally {
-      session.endSession()
-    }
-  }
-
-  /**
-   * Check if the connected MongoDB deployment supports transactions
-   * Returns false if not connected or if running in standalone mode
-   */
-  $supportsTransactions(): boolean {
-    return this.supportsTransactions
-  }
-
-  private async initializeCollections(): Promise<void> {
-    if (!this.db || !this.config.autoCreateCollections) return
-
-    const models = ${JSON.stringify(this.getModelsForRuntime(models), null, 2)}
-
-    for (const model of models) {
-      // Skip embedded models with empty collection names
-      if (!model.collectionName) {
-        continue
-      }
-
-      const collections = await this.db.listCollections({ name: model.collectionName }).toArray()
-
-      if (collections.length === 0) {
-        await this.db.createCollection(model.collectionName)
-
-        // Create indexes
-        if (model.indexes.length > 0) {
-          const indexes = model.indexes.map(index => ({
-            key: index.fields.reduce((acc, field) => {
-              acc[field] = 1
-              return acc
-            }, {}),
-            unique: index.unique,
-            sparse: index.sparse || false
-          }))
-
-          try {
-            await this.db.collection(model.collectionName).createIndexes(indexes)
-          } catch (error) {
-            console.warn(\`Failed to create indexes for \${model.name}:\`, error)
-          }
-        }
-      }
-    }
-  }
-
-  $isConnected(): boolean {
-    return this.mongoClient !== null
-  }
-
-  get $db(): Db {
-    if (!this.db) {
-      throw new Error('Database not connected. Call $connect() first.')
-    }
-    return this.db
-  }
-
-  get $mongo(): { client: MongoClient; ObjectId: any } {
-    if (!this.mongoClient) {
-      throw new Error('Database not connected. Call $connect() first.')
-    }
-    return {
-      client: this.mongoClient,
-      ObjectId: ObjectId
-    }
-  }
-}
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { MongoClient, Db, ObjectId } from 'mongodb'
+import type { LenzConfig } from './types'
+import { QueryBuilder } from './runtime/query'
+import { RelationResolver } from './runtime/relations'
+
+${models.map(model => `
+import { ${model.name}Delegate } from './models/${model.name}'`).join('\n')}
+
+export class ${clientName} {
+  private mongoClient: MongoClient | null = null
+  private db: Db | null = null
+  private config: LenzConfig
+  private supportsTransactions: boolean = false
+
+  // Model delegates
+${models.map(model => `  public ${this.toCamelCase(model.name)}: ${model.name}Delegate`).join('\n')}
+
+  constructor(config: LenzConfig = {}) {
+    this.config = {
+      url: config.url || process.env.MONGODB_URI || 'mongodb://localhost:27017',
+      database: config.database || 'myapp',
+      autoCreateCollections: config.autoCreateCollections ?? true,
+      log: config.log || [],
+      ...config
+    }
+
+    // Initialize model delegates
+${models.map(model => `    this.${this.toCamelCase(model.name)} = new ${model.name}Delegate(this)`).join('\n')}
+  }
+
+  async $connect(): Promise<void> {
+    if (this.mongoClient) {
+      return
+    }
+
+    this.mongoClient = new MongoClient(this.config.url, {
+      maxPoolSize: this.config.maxPoolSize || 10,
+      connectTimeoutMS: this.config.connectTimeoutMS || 10000,
+      socketTimeoutMS: this.config.socketTimeoutMS || 45000
+    })
+
+    await this.mongoClient.connect()
+    this.db = this.mongoClient.db(this.config.database)
+
+    // Test connection
+    await this.db.command({ ping: 1 })
+
+    // Check if MongoDB supports transactions (requires replica set)
+    try {
+      const serverInfo = await this.db.admin().serverInfo()
+      this.supportsTransactions = serverInfo.repl?.replSetName !== undefined
+
+      if (!this.supportsTransactions) {
+        console.warn('⚠️  MongoDB is running in standalone mode. Transactions will not work.')
+        console.warn('   Consider setting up a replica set for transaction support.')
+        console.warn('   Example: mongod --replSet rs0 --port 27017')
+      }
+    } catch (error) {
+      console.warn('⚠️  Could not determine MongoDB deployment type:', error.message)
+      this.supportsTransactions = false
+    }
+
+    // Initialize collections and indexes
+    await this.initializeCollections()
+
+    if (this.config.log?.includes('info')) {
+      console.log('✅ Connected to MongoDB')
+    }
+  }
+
+  async $disconnect(): Promise<void> {
+    if (this.mongoClient) {
+      await this.mongoClient.close()
+      this.mongoClient = null
+      this.db = null
+
+      if (this.config.log?.includes('info')) {
+        console.log('👋 Disconnected from MongoDB')
+      }
+    }
+  }
+
+  async $transaction<T>(callback: (tx: any) => Promise<T>): Promise<T> {
+    if (!this.mongoClient) {
+      throw new Error('Not connected to database')
+    }
+
+    // Check if transactions are supported
+    if (!this.supportsTransactions) {
+      throw new Error(
+        'Transactions are not supported in standalone MongoDB. ' +
+        'Set up a replica set or use alternative consistency patterns. ' +
+        'During development: mongod --replSet rs0 --port 27017'
+      )
+    }
+
+    const session = this.mongoClient.startSession()
+
+    try {
+      session.startTransaction()
+      const result = await callback(session)
+      await session.commitTransaction()
+      return result
+    } catch (error) {
+      await session.abortTransaction()
+      throw error
+    } finally {
+      session.endSession()
+    }
+  }
+
+  /**
+   * Check if the connected MongoDB deployment supports transactions
+   * Returns false if not connected or if running in standalone mode
+   */
+  $supportsTransactions(): boolean {
+    return this.supportsTransactions
+  }
+
+  private async initializeCollections(): Promise<void> {
+    if (!this.db || !this.config.autoCreateCollections) return
+
+    const models = ${JSON.stringify(this.getModelsForRuntime(models), null, 2)}
+
+    for (const model of models) {
+      // Skip embedded models with empty collection names
+      if (!model.collectionName) {
+        continue
+      }
+
+      const collections = await this.db.listCollections({ name: model.collectionName }).toArray()
+
+      if (collections.length === 0) {
+        await this.db.createCollection(model.collectionName)
+
+        // Create indexes
+        if (model.indexes.length > 0) {
+          const indexes = model.indexes.map(index => ({
+            key: index.fields.reduce((acc, field) => {
+              acc[field] = 1
+              return acc
+            }, {}),
+            unique: index.unique,
+            sparse: index.sparse || false
+          }))
+
+          try {
+            await this.db.collection(model.collectionName).createIndexes(indexes)
+          } catch (error) {
+            console.warn(\`Failed to create indexes for \${model.name}:\`, error)
+          }
+        }
+      }
+    }
+  }
+
+  $isConnected(): boolean {
+    return this.mongoClient !== null
+  }
+
+  get $db(): Db {
+    if (!this.db) {
+      throw new Error('Database not connected. Call $connect() first.')
+    }
+    return this.db
+  }
+
+  get $mongo(): { client: MongoClient; ObjectId: any } {
+    if (!this.mongoClient) {
+      throw new Error('Database not connected. Call $connect() first.')
+    }
+    return {
+      client: this.mongoClient,
+      ObjectId: ObjectId
+    }
+  }
+}
 `;
     }
     getModelsForRuntime(models) {
@@ -492,193 +492,193 @@ ${models.map(model => `    this.${this.toCamelCase(model.name)} = new ${model.na
         }));
     }
     generateTypes(models, enums) {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { ObjectId } from 'mongodb'
-
-// Base types
-export type ScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'DateTime' | 'Date' | 'Json' | 'ObjectId'
-export type RelationType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany'
-
-// Enum types
-${enums.map(e => `
-export enum ${e.name} {
-  ${e.values.map(v => `${v} = '${v}'`).join(',\n  ')}
-}`).join('\n\n')}
-
-// Model types
-${models.map(model => this.generateModelType(model)).join('\n\n')}
-
-// Pagination types
-export interface PageInfo {
-  hasNextPage: boolean
-  hasPreviousPage: boolean
-  startCursor?: string
-  endCursor?: string
-}
-
-export interface Connection<T> {
-  edges: Array<Edge<T>>
-  pageInfo: PageInfo
-  totalCount: number
-}
-
-export interface Edge<T> {
-  node: T
-  cursor: string
-}
-
-// Operation types
-export interface WhereInput<T = any> {
-  id?: string | ObjectId
-  AND?: WhereInput<T>[]
-  OR?: WhereInput<T>[]
-  NOT?: WhereInput<T>[]
-  [key: string]: any
-}
-
-export interface OrderByInput {
-  [key: string]: 'asc' | 'desc' | 1 | -1
-}
-
-export interface SelectInput {
-  [key: string]: boolean | SelectInput
-}
-
-export interface IncludeInput {
-  [key: string]: boolean | IncludeInput
-}
-
-export interface QueryOptions<T = any> {
-  where?: WhereInput<T>
-  select?: SelectInput
-  include?: IncludeInput
-  skip?: number
-  take?: number
-  orderBy?: OrderByInput | OrderByInput[]
-  distinct?: string | string[]
-  /** Cursor for pagination */
-  cursor?: string | ObjectId
-}
-
-export interface CreateInput<T = any> {
-  data: Partial<T>
-  select?: SelectInput
-  include?: IncludeInput
-}
-
-export interface UpdateInput<T = any> {
-  where: WhereInput<T>
-  data: Partial<T>
-  select?: SelectInput
-  include?: IncludeInput
-}
-
-export interface DeleteInput<T = any> {
-  where: WhereInput<T>
-  select?: SelectInput
-  include?: IncludeInput
-}
-
-export interface UpsertInput<T = any> {
-  where: WhereInput<T>
-  create: Partial<T>
-  update: Partial<T>
-  select?: SelectInput
-  include?: IncludeInput
-}
-
-// Pagination specific interfaces
-export interface OffsetPaginationArgs<T = any> extends QueryOptions<T> {
-  page?: number
-  perPage?: number
-}
-
-export interface CursorPaginationArgs<T = any> extends QueryOptions<T> {
-  cursor?: string | ObjectId
-  take?: number
-}
-
-export interface PaginatedResult<T> {
-  data: T[]
-  meta: {
-    total: number
-    page: number
-    perPage: number
-    totalPages: number
-    hasNextPage: boolean
-    hasPreviousPage: boolean
-  }
-}
-
-export interface CursorPaginatedResult<T> {
-  edges: Array<{
-    node: T
-    cursor: string
-  }>
-  pageInfo: {
-    hasNextPage: boolean
-    hasPreviousPage: boolean
-    startCursor?: string
-    endCursor?: string
-  }
-  totalCount: number
-}
-
-// Config types
-export interface LenzConfig {
-  url?: string
-  database?: string
-  schemaPath?: string
-  log?: ('query' | 'error' | 'warn' | 'info')[]
-  autoCreateCollections?: boolean
-  maxPoolSize?: number
-  connectTimeoutMS?: number
-  socketTimeoutMS?: number
-}
-
-// Utility types
-export type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends Array<infer U>
-    ? Array<DeepPartial<U>>
-    : T[P] extends ReadonlyArray<infer U>
-    ? ReadonlyArray<DeepPartial<U>>
-    : DeepPartial<T[P]> | T[P]
-}
-
-export type WithId<T> = T & { id: string }
-export type OptionalId<T> = Omit<T, 'id'> & { id?: string }
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { ObjectId } from 'mongodb'
+
+// Base types
+export type ScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'DateTime' | 'Date' | 'Json' | 'ObjectId'
+export type RelationType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany'
+
+// Enum types
+${enums.map(e => `
+export enum ${e.name} {
+  ${e.values.map(v => `${v} = '${v}'`).join(',\n  ')}
+}`).join('\n\n')}
+
+// Model types
+${models.map(model => this.generateModelType(model)).join('\n\n')}
+
+// Pagination types
+export interface PageInfo {
+  hasNextPage: boolean
+  hasPreviousPage: boolean
+  startCursor?: string
+  endCursor?: string
+}
+
+export interface Connection<T> {
+  edges: Array<Edge<T>>
+  pageInfo: PageInfo
+  totalCount: number
+}
+
+export interface Edge<T> {
+  node: T
+  cursor: string
+}
+
+// Operation types
+export interface WhereInput<T = any> {
+  id?: string | ObjectId
+  AND?: WhereInput<T>[]
+  OR?: WhereInput<T>[]
+  NOT?: WhereInput<T>[]
+  [key: string]: any
+}
+
+export interface OrderByInput {
+  [key: string]: 'asc' | 'desc' | 1 | -1
+}
+
+export interface SelectInput {
+  [key: string]: boolean | SelectInput
+}
+
+export interface IncludeInput {
+  [key: string]: boolean | IncludeInput
+}
+
+export interface QueryOptions<T = any> {
+  where?: WhereInput<T>
+  select?: SelectInput
+  include?: IncludeInput
+  skip?: number
+  take?: number
+  orderBy?: OrderByInput | OrderByInput[]
+  distinct?: string | string[]
+  /** Cursor for pagination */
+  cursor?: string | ObjectId
+}
+
+export interface CreateInput<T = any> {
+  data: Partial<T>
+  select?: SelectInput
+  include?: IncludeInput
+}
+
+export interface UpdateInput<T = any> {
+  where: WhereInput<T>
+  data: Partial<T>
+  select?: SelectInput
+  include?: IncludeInput
+}
+
+export interface DeleteInput<T = any> {
+  where: WhereInput<T>
+  select?: SelectInput
+  include?: IncludeInput
+}
+
+export interface UpsertInput<T = any> {
+  where: WhereInput<T>
+  create: Partial<T>
+  update: Partial<T>
+  select?: SelectInput
+  include?: IncludeInput
+}
+
+// Pagination specific interfaces
+export interface OffsetPaginationArgs<T = any> extends QueryOptions<T> {
+  page?: number
+  perPage?: number
+}
+
+export interface CursorPaginationArgs<T = any> extends QueryOptions<T> {
+  cursor?: string | ObjectId
+  take?: number
+}
+
+export interface PaginatedResult<T> {
+  data: T[]
+  meta: {
+    total: number
+    page: number
+    perPage: number
+    totalPages: number
+    hasNextPage: boolean
+    hasPreviousPage: boolean
+  }
+}
+
+export interface CursorPaginatedResult<T> {
+  edges: Array<{
+    node: T
+    cursor: string
+  }>
+  pageInfo: {
+    hasNextPage: boolean
+    hasPreviousPage: boolean
+    startCursor?: string
+    endCursor?: string
+  }
+  totalCount: number
+}
+
+// Config types
+export interface LenzConfig {
+  url?: string
+  database?: string
+  schemaPath?: string
+  log?: ('query' | 'error' | 'warn' | 'info')[]
+  autoCreateCollections?: boolean
+  maxPoolSize?: number
+  connectTimeoutMS?: number
+  socketTimeoutMS?: number
+}
+
+// Utility types
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Array<DeepPartial<U>>
+    : T[P] extends ReadonlyArray<infer U>
+    ? ReadonlyArray<DeepPartial<U>>
+    : DeepPartial<T[P]> | T[P]
+}
+
+export type WithId<T> = T & { id: string }
+export type OptionalId<T> = Omit<T, 'id'> & { id?: string }
 `;
     }
     generateModelType(model) {
-        return `export interface ${model.name} {
-  id: string
+        return `export interface ${model.name} {
+  id: string
 ${model.fields.filter(f => !f.isId).map(field => {
             const tsType = this.mapToTSType(field.type, field.isArray);
             return `  ${field.name}${field.isRequired ? '' : '?'}: ${tsType}`;
-        }).join('\n')}
-}
-
-export interface ${model.name}CreateInput {
+        }).join('\n')}
+}
+
+export interface ${model.name}CreateInput {
 ${model.fields.filter(f => !f.isId && !f.directives.includes('@generated')).map(field => {
             const tsType = this.mapToTSType(field.type, field.isArray);
             return `  ${field.name}${field.isRequired ? '' : '?'}: ${tsType}`;
-        }).join('\n')}
-}
-
-export interface ${model.name}UpdateInput {
+        }).join('\n')}
+}
+
+export interface ${model.name}UpdateInput {
 ${model.fields.filter(f => !f.isId).map(field => {
             const tsType = this.mapToTSType(field.type, field.isArray);
             return `  ${field.name}?: ${tsType}`;
-        }).join('\n')}
-}
-
-export type ${model.name}WhereInput = WhereInput<${model.name}>
-export type ${model.name}QueryOptions = QueryOptions<${model.name}>
-export type ${model.name}CreateArgs = CreateInput<${model.name}>
-export type ${model.name}UpdateArgs = UpdateInput<${model.name}>
-export type ${model.name}DeleteArgs = DeleteInput<${model.name}>
+        }).join('\n')}
+}
+
+export type ${model.name}WhereInput = WhereInput<${model.name}>
+export type ${model.name}QueryOptions = QueryOptions<${model.name}>
+export type ${model.name}CreateArgs = CreateInput<${model.name}>
+export type ${model.name}UpdateArgs = UpdateInput<${model.name}>
+export type ${model.name}DeleteArgs = DeleteInput<${model.name}>
 export type ${model.name}UpsertArgs = UpsertInput<${model.name}>`;
     }
     mapToTSType(type, isArray) {
@@ -692,493 +692,493 @@ export type ${model.name}UpsertArgs = UpsertInput<${model.name}>`;
         if (enums.length === 0) {
             return '// No enums defined in schema\n\nexport {}';
         }
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-${enums.map(e => `
-export const ${e.name} = {
-${e.values.map(v => `  ${v}: '${v}',`).join('\n')}
-} as const
-
-export type ${e.name} = typeof ${e.name}[keyof typeof ${e.name}]
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+${enums.map(e => `
+export const ${e.name} = {
+${e.values.map(v => `  ${v}: '${v}',`).join('\n')}
+} as const
+
+export type ${e.name} = typeof ${e.name}[keyof typeof ${e.name}]
 `).join('\n')}`;
     }
     generateRuntimePagination() {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { ObjectId } from 'mongodb'
-
-/**
- * Pagination helper for Lenz ORM
- * Implements both offset-based and cursor-based pagination
- * Similar to Prisma's pagination patterns
- */
-export class PaginationHelper {
-  /**
-   * Create a cursor from a document
-   * Uses the document's _id by default
-   */
-  static createCursor(doc: any): string {
-    if (!doc) throw new Error('Cannot create cursor from null document')
-
-    // Use _id if available, otherwise id
-    const id = doc._id || doc.id
-    if (!id) throw new Error('Document must have an id to create cursor')
-
-    // Base64 encode for cursor
-    return Buffer.from(id.toString()).toString('base64')
-  }
-
-  /**
-   * Parse cursor to get the id
-   */
-  static parseCursor(cursor: string): string {
-    try {
-      return Buffer.from(cursor, 'base64').toString('utf8')
-    } catch (error) {
-      throw new Error('Invalid cursor format')
-    }
-  }
-
-  /**
-   * Build MongoDB filter for cursor-based pagination
-   * Assumes ordering by _id unless specified otherwise
-   */
-  static buildCursorFilter(
-    cursor: string,
-    orderBy: any = { _id: 'asc' },
-    direction: 'forward' | 'backward' = 'forward'
-  ): any {
-    const cursorId = this.parseCursor(cursor)
-
-    // For simplicity, we'll handle single field ordering
-    const orderField = Object.keys(orderBy)[0] || '_id'
-    const orderDirection = orderBy[orderField] || 'asc'
-
-    const isAscending = orderDirection === 'asc' || orderDirection === 1
-    const isForward = direction === 'forward'
-
-    // Build comparison operator based on direction and order
-    let operator: string
-    if (isForward) {
-      operator = isAscending ? '$gt' : '$lt'
-    } else {
-      operator = isAscending ? '$lt' : '$gt'
-    }
-
-    return {
-      [orderField]: { [operator]: new ObjectId(cursorId) }
-    }
-  }
-
-  /**
-   * Calculate skip for offset pagination
-   */
-  static calculateSkip(page: number, perPage: number): number {
-    if (page < 1) throw new Error('Page must be greater than 0')
-    return (page - 1) * perPage
-  }
-
-  /**
-   * Calculate total pages
-   */
-  static calculateTotalPages(total: number, perPage: number): number {
-    return Math.ceil(total / perPage)
-  }
-
-  /**
-   * Get pagination metadata
-   */
-  static getPaginationMeta(
-    total: number,
-    page: number,
-    perPage: number,
-    dataLength: number
-  ): {
-    total: number
-    page: number
-    perPage: number
-    totalPages: number
-    hasNextPage: boolean
-    hasPreviousPage: boolean
-  } {
-    const totalPages = this.calculateTotalPages(total, perPage)
-
-    return {
-      total,
-      page,
-      perPage,
-      totalPages,
-      hasNextPage: page < totalPages,
-      hasPreviousPage: page > 1
-    }
-  }
-
-  /**
-   * Format results for GraphQL-style connection
-   */
-  static toConnection<T>(
-    data: T[],
-    totalCount: number,
-    hasNextPage: boolean,
-    hasPreviousPage: boolean,
-    createCursor: (item: T) => string = (item: any) => this.createCursor(item)
-  ): {
-    edges: Array<{ node: T; cursor: string }>
-    pageInfo: {
-      hasNextPage: boolean
-      hasPreviousPage: boolean
-      startCursor?: string
-      endCursor?: string
-    }
-    totalCount: number
-  } {
-    const edges = data.map(item => ({
-      node: item,
-      cursor: createCursor(item)
-    }))
-
-    return {
-      edges,
-      pageInfo: {
-        hasNextPage,
-        hasPreviousPage,
-        startCursor: edges[0]?.cursor,
-        endCursor: edges[edges.length - 1]?.cursor
-      },
-      totalCount
-    }
-  }
-
-  /**
-   * Simple offset pagination
-   */
-  static paginate<T>(
-    data: T[],
-    page: number = 1,
-    perPage: number = 10
-  ): {
-    data: T[]
-    meta: {
-      page: number
-      perPage: number
-      total: number
-      totalPages: number
-      hasNextPage: boolean
-      hasPreviousPage: boolean
-    }
-  } {
-    const startIndex = (page - 1) * perPage
-    const endIndex = startIndex + perPage
-    const paginatedData = data.slice(startIndex, endIndex)
-    const total = data.length
-    const totalPages = Math.ceil(total / perPage)
-
-    return {
-      data: paginatedData,
-      meta: {
-        page,
-        perPage,
-        total,
-        totalPages,
-        hasNextPage: page < totalPages,
-        hasPreviousPage: page > 1
-      }
-    }
-  }
-}
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { ObjectId } from 'mongodb'
+
+/**
+ * Pagination helper for Lenz ORM
+ * Implements both offset-based and cursor-based pagination
+ * Similar to Prisma's pagination patterns
+ */
+export class PaginationHelper {
+  /**
+   * Create a cursor from a document
+   * Uses the document's _id by default
+   */
+  static createCursor(doc: any): string {
+    if (!doc) throw new Error('Cannot create cursor from null document')
+
+    // Use _id if available, otherwise id
+    const id = doc._id || doc.id
+    if (!id) throw new Error('Document must have an id to create cursor')
+
+    // Base64 encode for cursor
+    return Buffer.from(id.toString()).toString('base64')
+  }
+
+  /**
+   * Parse cursor to get the id
+   */
+  static parseCursor(cursor: string): string {
+    try {
+      return Buffer.from(cursor, 'base64').toString('utf8')
+    } catch (error) {
+      throw new Error('Invalid cursor format')
+    }
+  }
+
+  /**
+   * Build MongoDB filter for cursor-based pagination
+   * Assumes ordering by _id unless specified otherwise
+   */
+  static buildCursorFilter(
+    cursor: string,
+    orderBy: any = { _id: 'asc' },
+    direction: 'forward' | 'backward' = 'forward'
+  ): any {
+    const cursorId = this.parseCursor(cursor)
+
+    // For simplicity, we'll handle single field ordering
+    const orderField = Object.keys(orderBy)[0] || '_id'
+    const orderDirection = orderBy[orderField] || 'asc'
+
+    const isAscending = orderDirection === 'asc' || orderDirection === 1
+    const isForward = direction === 'forward'
+
+    // Build comparison operator based on direction and order
+    let operator: string
+    if (isForward) {
+      operator = isAscending ? '$gt' : '$lt'
+    } else {
+      operator = isAscending ? '$lt' : '$gt'
+    }
+
+    return {
+      [orderField]: { [operator]: new ObjectId(cursorId) }
+    }
+  }
+
+  /**
+   * Calculate skip for offset pagination
+   */
+  static calculateSkip(page: number, perPage: number): number {
+    if (page < 1) throw new Error('Page must be greater than 0')
+    return (page - 1) * perPage
+  }
+
+  /**
+   * Calculate total pages
+   */
+  static calculateTotalPages(total: number, perPage: number): number {
+    return Math.ceil(total / perPage)
+  }
+
+  /**
+   * Get pagination metadata
+   */
+  static getPaginationMeta(
+    total: number,
+    page: number,
+    perPage: number,
+    dataLength: number
+  ): {
+    total: number
+    page: number
+    perPage: number
+    totalPages: number
+    hasNextPage: boolean
+    hasPreviousPage: boolean
+  } {
+    const totalPages = this.calculateTotalPages(total, perPage)
+
+    return {
+      total,
+      page,
+      perPage,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPreviousPage: page > 1
+    }
+  }
+
+  /**
+   * Format results for GraphQL-style connection
+   */
+  static toConnection<T>(
+    data: T[],
+    totalCount: number,
+    hasNextPage: boolean,
+    hasPreviousPage: boolean,
+    createCursor: (item: T) => string = (item: any) => this.createCursor(item)
+  ): {
+    edges: Array<{ node: T; cursor: string }>
+    pageInfo: {
+      hasNextPage: boolean
+      hasPreviousPage: boolean
+      startCursor?: string
+      endCursor?: string
+    }
+    totalCount: number
+  } {
+    const edges = data.map(item => ({
+      node: item,
+      cursor: createCursor(item)
+    }))
+
+    return {
+      edges,
+      pageInfo: {
+        hasNextPage,
+        hasPreviousPage,
+        startCursor: edges[0]?.cursor,
+        endCursor: edges[edges.length - 1]?.cursor
+      },
+      totalCount
+    }
+  }
+
+  /**
+   * Simple offset pagination
+   */
+  static paginate<T>(
+    data: T[],
+    page: number = 1,
+    perPage: number = 10
+  ): {
+    data: T[]
+    meta: {
+      page: number
+      perPage: number
+      total: number
+      totalPages: number
+      hasNextPage: boolean
+      hasPreviousPage: boolean
+    }
+  } {
+    const startIndex = (page - 1) * perPage
+    const endIndex = startIndex + perPage
+    const paginatedData = data.slice(startIndex, endIndex)
+    const total = data.length
+    const totalPages = Math.ceil(total / perPage)
+
+    return {
+      data: paginatedData,
+      meta: {
+        page,
+        perPage,
+        total,
+        totalPages,
+        hasNextPage: page < totalPages,
+        hasPreviousPage: page > 1
+      }
+    }
+  }
+}
 `;
     }
     generateRuntimeIndex() {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-export { QueryBuilder } from './query'
-export { PaginationHelper } from './pagination'
-export { RelationResolver } from './relations'
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+export { QueryBuilder } from './query'
+export { PaginationHelper } from './pagination'
+export { RelationResolver } from './relations'
 `;
     }
     generateRuntimeQuery() {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { ObjectId, Filter, UpdateFilter } from 'mongodb'
-import type { WhereInput, QueryOptions, SelectInput } from '../types'
-import { PaginationHelper } from './pagination'
-
-export class QueryBuilder {
-  static buildWhere<T>(where: WhereInput<T>): Filter<any> {
-    const filter: Filter<any> = {}
-
-    for (const [key, value] of Object.entries(where || {})) {
-      if (key === 'id') {
-        if (typeof value === 'object' && value !== null) {
-          // Для операторов типа { in: [...] } используем _id
-          this.applyOperators(filter, '_id', value)
-        } else {
-          filter._id = this.normalizeId(value)
-        }
-      } else if (typeof value === 'object' && value !== null) {
-        this.applyOperators(filter, key, value)
-      } else {
-        // Оставляем значение как есть для внешних ключей
-        // (внешние ключи хранятся как строки, не преобразуем в ObjectId)
-        filter[key] = value
-      }
-    }
-
-    return filter
-  }
-
-  /**
-   * Build cursor condition for pagination
-   */
-  static buildCursorCondition(
-    cursor: string | ObjectId,
-    orderBy: any = { _id: 'asc' }
-  ): Filter<any> {
-    const cursorId = typeof cursor === 'string'
-      ? PaginationHelper.parseCursor(cursor)
-      : cursor.toString()
-
-    // For simple _id ordering
-    if (orderBy._id || (!Object.keys(orderBy).length)) {
-      return {
-        _id: { $gt: new ObjectId(cursorId) }
-      }
-    }
-
-    // For other field ordering (simplified implementation)
-    // In real implementation, you'd need to know the value at the cursor
-    const orderField = Object.keys(orderBy)[0]
-    const orderDirection = orderBy[orderField]
-
-    // Note: This is a simplified version
-    // Full implementation requires fetching the cursor document
-    return {
-      [orderField]: orderDirection === 'desc'
-        ? { $lt: cursorId }
-        : { $gt: cursorId }
-    }
-  }
-
-  /**
-   * Build MongoDB projection object from select input and hidden fields
-   */
-  static buildProjection<T>(
-    select: SelectInput | undefined,
-    hiddenFields: string[] = []
-  ): any {
-    if (!select) {
-      // По умолчанию: исключаем скрытые поля
-      if (hiddenFields.length === 0) return undefined;
-      const projection: any = {};
-      hiddenFields.forEach(field => {
-        projection[field] = 0;
-      });
-      return projection;
-    }
-
-    const projection: any = {};
-    const processSelect = (sel: SelectInput, prefix = '') => {
-      for (const [key, value] of Object.entries(sel)) {
-        const fullPath = prefix ? \`\${prefix}.\${key}\` : key;
-
-        if (typeof value === 'boolean') {
-          // Базовое поле: true - включать, false - исключать
-          projection[fullPath] = value ? 1 : 0;
-        } else {
-          // Вложенный объект (отношение)
-          processSelect(value, fullPath);
-        }
-      }
-    };
-
-    processSelect(select);
-
-    // Убедимся, что скрытые поля исключены, если не указано явно
-    hiddenFields.forEach(field => {
-      if (projection[field] === undefined) {
-        projection[field] = 0;
-      }
-    });
-
-    return projection;
-  }
-
-  static buildOptions<T>(options: QueryOptions<T>, hiddenFields: string[] = []): any {
-    const result: any = {}
-
-    if (options.skip !== undefined) result.skip = options.skip
-    if (options.take !== undefined) result.limit = options.take
-
-    if (options.orderBy) {
-      result.sort = this.buildSort(options.orderBy)
-    }
-
-    // Добавить проекцию, если есть select или скрытые поля
-    const projection = this.buildProjection(options.select, hiddenFields)
-    if (projection) {
-      result.projection = projection
-    }
-
-    return result
-  }
-
-  private static buildSort(orderBy: any): any {
-    if (Array.isArray(orderBy)) {
-      return orderBy.reduce((acc, curr) => ({ ...acc, ...this.buildSort(curr) }), {})
-    }
-
-    const sort: any = {}
-    for (const [field, direction] of Object.entries(orderBy)) {
-      if (direction === 'asc' || direction === 1) {
-        sort[field] = 1
-      } else if (direction === 'desc' || direction === -1) {
-        sort[field] = -1
-      }
-    }
-    return sort
-  }
-
-  private static applyOperators(filter: any, field: string, operators: any): void {
-    const mongoOperators: Record<string, string> = {
-      equals: '$eq',
-      not: '$ne',
-      in: '$in',
-      notIn: '$nin',
-      lt: '$lt',
-      lte: '$lte',
-      gt: '$gt',
-      gte: '$gte',
-      contains: '$regex',
-      startsWith: '$regex',
-      endsWith: '$regex'
-    }
-
-    for (const [op, value] of Object.entries(operators)) {
-      const mongoOp = mongoOperators[op]
-
-      if (mongoOp) {
-        if (op === 'contains') {
-          filter[field] = { $regex: value, $options: 'i' }
-        } else if (op === 'startsWith') {
-          filter[field] = { $regex: \`^\${value}\`, $options: 'i' }
-        } else if (op === 'endsWith') {
-          filter[field] = { $regex: \`\${value}\$\`, $options: 'i' }
-        } else {
-          if (!filter[field]) filter[field] = {}
-          // Нормализуем ID только для поля _id (внутренний идентификатор)
-          // Внешние ключи хранятся как строки, не преобразуем в ObjectId
-          const normalizedValue = field === '_id' ? this.normalizeId(value) : value
-          filter[field][mongoOp] = normalizedValue
-        }
-      }
-    }
-  }
-
-  static normalizeId(id: string | ObjectId | (string | ObjectId)[]): ObjectId | string | (ObjectId | string)[] {
-    try {
-      if (Array.isArray(id)) {
-        return id.map(item => this.normalizeId(item) as ObjectId | string)
-      }
-      if (typeof id === 'string' && /^[0-9a-fA-F]{24}$/.test(id)) {
-        return new ObjectId(id)
-      }
-      return id
-    } catch {
-      return id
-    }
-  }
-
-  static buildUpdate(data: any): UpdateFilter<any> {
-    const update: UpdateFilter<any> = {}
-
-    const setOperations: any = {}
-    const otherOperations: any = {}
-
-    for (const [key, value] of Object.entries(data)) {
-      if (key.startsWith('$')) {
-        otherOperations[key] = value
-      } else {
-        setOperations[key] = value
-      }
-    }
-
-    if (Object.keys(setOperations).length > 0) {
-      update.$set = setOperations
-    }
-
-    Object.assign(update, otherOperations)
-
-    return update
-  }
-}
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { ObjectId, Filter, UpdateFilter } from 'mongodb'
+import type { WhereInput, QueryOptions, SelectInput } from '../types'
+import { PaginationHelper } from './pagination'
+
+export class QueryBuilder {
+  static buildWhere<T>(where: WhereInput<T>): Filter<any> {
+    const filter: Filter<any> = {}
+
+    for (const [key, value] of Object.entries(where || {})) {
+      if (key === 'id') {
+        if (typeof value === 'object' && value !== null) {
+          // Для операторов типа { in: [...] } используем _id
+          this.applyOperators(filter, '_id', value)
+        } else {
+          filter._id = this.normalizeId(value)
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        this.applyOperators(filter, key, value)
+      } else {
+        // Оставляем значение как есть для внешних ключей
+        // (внешние ключи хранятся как строки, не преобразуем в ObjectId)
+        filter[key] = value
+      }
+    }
+
+    return filter
+  }
+
+  /**
+   * Build cursor condition for pagination
+   */
+  static buildCursorCondition(
+    cursor: string | ObjectId,
+    orderBy: any = { _id: 'asc' }
+  ): Filter<any> {
+    const cursorId = typeof cursor === 'string'
+      ? PaginationHelper.parseCursor(cursor)
+      : cursor.toString()
+
+    // For simple _id ordering
+    if (orderBy._id || (!Object.keys(orderBy).length)) {
+      return {
+        _id: { $gt: new ObjectId(cursorId) }
+      }
+    }
+
+    // For other field ordering (simplified implementation)
+    // In real implementation, you'd need to know the value at the cursor
+    const orderField = Object.keys(orderBy)[0]
+    const orderDirection = orderBy[orderField]
+
+    // Note: This is a simplified version
+    // Full implementation requires fetching the cursor document
+    return {
+      [orderField]: orderDirection === 'desc'
+        ? { $lt: cursorId }
+        : { $gt: cursorId }
+    }
+  }
+
+  /**
+   * Build MongoDB projection object from select input and hidden fields
+   */
+  static buildProjection<T>(
+    select: SelectInput | undefined,
+    hiddenFields: string[] = []
+  ): any {
+    if (!select) {
+      // По умолчанию: исключаем скрытые поля
+      if (hiddenFields.length === 0) return undefined;
+      const projection: any = {};
+      hiddenFields.forEach(field => {
+        projection[field] = 0;
+      });
+      return projection;
+    }
+
+    const projection: any = {};
+    const processSelect = (sel: SelectInput, prefix = '') => {
+      for (const [key, value] of Object.entries(sel)) {
+        const fullPath = prefix ? \`\${prefix}.\${key}\` : key;
+
+        if (typeof value === 'boolean') {
+          // Базовое поле: true - включать, false - исключать
+          projection[fullPath] = value ? 1 : 0;
+        } else {
+          // Вложенный объект (отношение)
+          processSelect(value, fullPath);
+        }
+      }
+    };
+
+    processSelect(select);
+
+    // Убедимся, что скрытые поля исключены, если не указано явно
+    hiddenFields.forEach(field => {
+      if (projection[field] === undefined) {
+        projection[field] = 0;
+      }
+    });
+
+    return projection;
+  }
+
+  static buildOptions<T>(options: QueryOptions<T>, hiddenFields: string[] = []): any {
+    const result: any = {}
+
+    if (options.skip !== undefined) result.skip = options.skip
+    if (options.take !== undefined) result.limit = options.take
+
+    if (options.orderBy) {
+      result.sort = this.buildSort(options.orderBy)
+    }
+
+    // Добавить проекцию, если есть select или скрытые поля
+    const projection = this.buildProjection(options.select, hiddenFields)
+    if (projection) {
+      result.projection = projection
+    }
+
+    return result
+  }
+
+  private static buildSort(orderBy: any): any {
+    if (Array.isArray(orderBy)) {
+      return orderBy.reduce((acc, curr) => ({ ...acc, ...this.buildSort(curr) }), {})
+    }
+
+    const sort: any = {}
+    for (const [field, direction] of Object.entries(orderBy)) {
+      if (direction === 'asc' || direction === 1) {
+        sort[field] = 1
+      } else if (direction === 'desc' || direction === -1) {
+        sort[field] = -1
+      }
+    }
+    return sort
+  }
+
+  private static applyOperators(filter: any, field: string, operators: any): void {
+    const mongoOperators: Record<string, string> = {
+      equals: '$eq',
+      not: '$ne',
+      in: '$in',
+      notIn: '$nin',
+      lt: '$lt',
+      lte: '$lte',
+      gt: '$gt',
+      gte: '$gte',
+      contains: '$regex',
+      startsWith: '$regex',
+      endsWith: '$regex'
+    }
+
+    for (const [op, value] of Object.entries(operators)) {
+      const mongoOp = mongoOperators[op]
+
+      if (mongoOp) {
+        if (op === 'contains') {
+          filter[field] = { $regex: value, $options: 'i' }
+        } else if (op === 'startsWith') {
+          filter[field] = { $regex: \`^\${value}\`, $options: 'i' }
+        } else if (op === 'endsWith') {
+          filter[field] = { $regex: \`\${value}\$\`, $options: 'i' }
+        } else {
+          if (!filter[field]) filter[field] = {}
+          // Нормализуем ID только для поля _id (внутренний идентификатор)
+          // Внешние ключи хранятся как строки, не преобразуем в ObjectId
+          const normalizedValue = field === '_id' ? this.normalizeId(value) : value
+          filter[field][mongoOp] = normalizedValue
+        }
+      }
+    }
+  }
+
+  static normalizeId(id: string | ObjectId | (string | ObjectId)[]): ObjectId | string | (ObjectId | string)[] {
+    try {
+      if (Array.isArray(id)) {
+        return id.map(item => this.normalizeId(item) as ObjectId | string)
+      }
+      if (typeof id === 'string' && /^[0-9a-fA-F]{24}$/.test(id)) {
+        return new ObjectId(id)
+      }
+      return id
+    } catch {
+      return id
+    }
+  }
+
+  static buildUpdate(data: any): UpdateFilter<any> {
+    const update: UpdateFilter<any> = {}
+
+    const setOperations: any = {}
+    const otherOperations: any = {}
+
+    for (const [key, value] of Object.entries(data)) {
+      if (key.startsWith('$')) {
+        otherOperations[key] = value
+      } else {
+        setOperations[key] = value
+      }
+    }
+
+    if (Object.keys(setOperations).length > 0) {
+      update.$set = setOperations
+    }
+
+    Object.assign(update, otherOperations)
+
+    return update
+  }
+}
 `;
     }
     generateRuntimeRelations() {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { Db, ObjectId } from 'mongodb'
-
-export class RelationResolver {
-  static async resolveOneToOne(
-    db: Db,
-    sourceCollection: string,
-    targetCollection: string,
-    sourceId: string,
-    foreignKey: string
-  ): Promise<any> {
-    const collection = db.collection(targetCollection)
-    return await collection.findOne({ [foreignKey]: sourceId })
-  }
-
-  static async resolveOneToMany(
-    db: Db,
-    sourceCollection: string,
-    targetCollection: string,
-    sourceId: string,
-    foreignKey: string
-  ): Promise<any[]> {
-    const collection = db.collection(targetCollection)
-    return await collection.find({ [foreignKey]: sourceId }).toArray()
-  }
-
-  static async resolveManyToMany(
-    db: Db,
-    sourceCollection: string,
-    targetCollection: string,
-    joinCollection: string,
-    sourceId: string
-  ): Promise<any[]> {
-    const joinCol = db.collection(joinCollection)
-    const targetCol = db.collection(targetCollection)
-
-    const connections = await joinCol.find({
-      [\`\${sourceCollection.toLowerCase()}Id\`]: sourceId
-    }).toArray()
-
-    const targetIds = connections.map(c => c[\`\${targetCollection.toLowerCase()}Id\`])
-
-    return await targetCol.find({
-      _id: { $in: targetIds.map(id => new ObjectId(id)) }
-    }).toArray()
-  }
-
-  static formatDocument(doc: any): any {
-    if (!doc) return doc
-
-    const formatted = { ...doc }
-    if (formatted._id) {
-      formatted.id = formatted._id.toString()
-      delete formatted._id
-    }
-
-    return formatted
-  }
-}
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { Db, ObjectId } from 'mongodb'
+
+export class RelationResolver {
+  static async resolveOneToOne(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    sourceId: string,
+    foreignKey: string
+  ): Promise<any> {
+    const collection = db.collection(targetCollection)
+    return await collection.findOne({ [foreignKey]: sourceId })
+  }
+
+  static async resolveOneToMany(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    sourceId: string,
+    foreignKey: string
+  ): Promise<any[]> {
+    const collection = db.collection(targetCollection)
+    return await collection.find({ [foreignKey]: sourceId }).toArray()
+  }
+
+  static async resolveManyToMany(
+    db: Db,
+    sourceCollection: string,
+    targetCollection: string,
+    joinCollection: string,
+    sourceId: string
+  ): Promise<any[]> {
+    const joinCol = db.collection(joinCollection)
+    const targetCol = db.collection(targetCollection)
+
+    const connections = await joinCol.find({
+      [\`\${sourceCollection.toLowerCase()}Id\`]: sourceId
+    }).toArray()
+
+    const targetIds = connections.map(c => c[\`\${targetCollection.toLowerCase()}Id\`])
+
+    return await targetCol.find({
+      _id: { $in: targetIds.map(id => new ObjectId(id)) }
+    }).toArray()
+  }
+
+  static formatDocument(doc: any): any {
+    if (!doc) return doc
+
+    const formatted = { ...doc }
+    if (formatted._id) {
+      formatted.id = formatted._id.toString()
+      delete formatted._id
+    }
+
+    return formatted
+  }
+}
 `;
     }
     generateModelsIndex(models) {
@@ -1192,431 +1192,431 @@ export class RelationResolver {
         return files;
     }
     generateModelDelegate(model) {
-        return `// This file was auto-generated by Lenz. Do not edit manually.
-// @generated
-
-import { Collection, ObjectId, Document } from 'mongodb'
-import type {
-  ${model.name},
-  ${model.name}CreateInput,
-  ${model.name}UpdateInput,
-  ${model.name}WhereInput,
-  ${model.name}QueryOptions,
-  ${model.name}CreateArgs,
-  ${model.name}UpdateArgs,
-  ${model.name}DeleteArgs,
-  ${model.name}UpsertArgs,
-  PaginatedResult,
-  CursorPaginatedResult,
-  OffsetPaginationArgs,
-  CursorPaginationArgs
-} from '../types'
-import { QueryBuilder } from '../runtime/query'
-import { PaginationHelper } from '../runtime/pagination'
-import { RelationResolver } from '../runtime/relations'
-import type { LenzClient } from '../client'
-
-export class ${model.name}Delegate {
-  constructor(private client: LenzClient) {}
-
-  private readonly hiddenFields: string[] = ${JSON.stringify(model.fields.filter(f => f.isHidden).map(f => f.name))};
-
-  private get collection(): Collection<Document> {
-    return this.client.$db.collection('${model.collectionName}')
-  }
-
-  async findUnique(args: { where: ${model.name}WhereInput } & ${model.name}QueryOptions): Promise<${model.name} | null> {
-    const query = QueryBuilder.buildWhere(args.where)
-    const options = QueryBuilder.buildOptions(args, this.hiddenFields)
-
-    const doc = await this.collection.findOne(query, options)
-    if (!doc) return null
-
-    const formatted = RelationResolver.formatDocument(doc)
-
-    if (args.include) {
-      return await this.includeRelations(formatted, args.include)
-    }
-
-    return formatted
-  }
-
-  async findMany(args?: ${model.name}QueryOptions): Promise<${model.name}[]> {
-    const { cursor, ...otherArgs } = args || {}
-    let where = args?.where || {}
-
-    // Handle cursor-based pagination
-    if (cursor) {
-      const cursorCondition = QueryBuilder.buildCursorCondition(cursor, args?.orderBy)
-      where = {
-        ...where,
-        ...cursorCondition
-      }
-    }
-
-    const query = QueryBuilder.buildWhere(where)
-    const options = QueryBuilder.buildOptions(otherArgs || {}, this.hiddenFields)
-
-    const mongoCursor = this.collection.find(query, options)
-    const docs = await mongoCursor.toArray()
-    const formatted = docs.map(RelationResolver.formatDocument)
-
-    if (args?.include) {
-      return await Promise.all(
-        formatted.map(doc => this.includeRelations(doc, args.include!))
-      )
-    }
-
-    return formatted
-  }
-
-  async findFirst(args?: ${model.name}QueryOptions): Promise<${model.name} | null> {
-    const results = await this.findMany({ ...args, take: 1 })
-    return results[0] || null
-  }
-
-  async create(args: ${model.name}CreateArgs): Promise<${model.name}> {
-    const now = new Date()
-    const document = {
-      ...args.data,
-      _id: new ObjectId(),
-      createdAt: now,
-      updatedAt: now
-    }
-
-    const result = await this.collection.insertOne(document)
-    const createdDoc = await this.collection.findOne({ _id: result.insertedId })
-
-    if (!createdDoc) {
-      throw new Error('Failed to create document')
-    }
-
-    const formatted = RelationResolver.formatDocument(createdDoc)
-
-    if (args.include) {
-      return await this.includeRelations(formatted, args.include)
-    }
-
-    return formatted
-  }
-
-  async createMany(args: { data: ${model.name}CreateInput[] }): Promise<{ count: number }> {
-    const now = new Date()
-    const documents = args.data.map(data => ({
-      ...data,
-      _id: new ObjectId(),
-      createdAt: now,
-      updatedAt: now
-    }))
-
-    const result = await this.collection.insertMany(documents)
-    return { count: result.insertedCount }
-  }
-
-  async update(args: ${model.name}UpdateArgs): Promise<${model.name}> {
-    const query = QueryBuilder.buildWhere(args.where)
-    const updateData = {
-      ...args.data,
-      updatedAt: new Date()
-    }
-
-    const update = QueryBuilder.buildUpdate(updateData)
-    const result = await this.collection.findOneAndUpdate(
-      query,
-      update,
-      { returnDocument: 'after' }
-    )
-
-    const updatedDoc = result.value || result
-    if (!updatedDoc) {
-      throw new Error('Document not found')
-    }
-
-    const formatted = RelationResolver.formatDocument(updatedDoc)
-
-    if (args.include) {
-      return await this.includeRelations(formatted, args.include)
-    }
-
-    return formatted
-  }
-
-  async updateMany(args: { where?: ${model.name}WhereInput; data: ${model.name}UpdateInput }): Promise<{ count: number }> {
-    const query = args.where ? QueryBuilder.buildWhere(args.where) : {}
-    const updateData = {
-      ...args.data,
-      updatedAt: new Date()
-    }
-
-    const update = QueryBuilder.buildUpdate(updateData)
-    const result = await this.collection.updateMany(query, update)
-    return { count: result.modifiedCount }
-  }
-
-  async upsert(args: ${model.name}UpsertArgs): Promise<${model.name}> {
-    const query = QueryBuilder.buildWhere(args.where)
-    const existing = await this.collection.findOne(query)
-
-    if (existing) {
-      return this.update({
-        where: args.where,
-        data: args.update,
-        select: args.select,
-        include: args.include
-      })
-    } else {
-      return this.create({
-        data: args.create,
-        select: args.select,
-        include: args.include
-      })
-    }
-  }
-
-  async delete(args: ${model.name}DeleteArgs): Promise<${model.name} | null> {
-    const query = QueryBuilder.buildWhere(args.where)
-    const doc = await this.collection.findOne(query)
-
-    if (!doc) return null
-
-    await this.collection.deleteOne(query)
-    const formatted = RelationResolver.formatDocument(doc)
-
-    if (args.include) {
-      return await this.includeRelations(formatted, args.include)
-    }
-
-    return formatted
-  }
-
-  async deleteMany(args: { where?: ${model.name}WhereInput }): Promise<{ count: number }> {
-    const query = args.where ? QueryBuilder.buildWhere(args.where) : {}
-    const result = await this.collection.deleteMany(query)
-    return { count: result.deletedCount }
-  }
-
-  async count(args?: { where?: ${model.name}WhereInput }): Promise<number> {
-    const query = args?.where ? QueryBuilder.buildWhere(args.where) : {}
-    return await this.collection.countDocuments(query)
-  }
-
-  async aggregate<T = any>(pipeline: any[]): Promise<T[]> {
-    return await this.collection.aggregate(pipeline).toArray() as T[]
-  }
-
-  /**
-   * Offset-based pagination (page-based)
-   * Similar to Prisma's skip/take pagination
-   */
-  async findManyPaginated(args: OffsetPaginationArgs<${model.name}>): Promise<PaginatedResult<${model.name}>> {
-    const page = args.page || 1
-    const perPage = args.take || args.perPage || 10
-    const skip = (page - 1) * perPage
-
-    // Get total count
-    const where = args.where ? QueryBuilder.buildWhere(args.where) : {}
-    const total = await this.collection.countDocuments(where)
-
-    // Get paginated data
-    const query = QueryBuilder.buildWhere(args.where || {})
-    const options = {
-      skip,
-      limit: perPage,
-      ...QueryBuilder.buildOptions(args, this.hiddenFields)
-    }
-
-    const mongoCursor = this.collection.find(query, options)
-    const docs = await mongoCursor.toArray()
-    const data = docs.map(RelationResolver.formatDocument)
-
-    // Handle includes
-    let resultData = data
-    if (args.include) {
-      resultData = await Promise.all(
-        data.map(doc => this.includeRelations(doc, args.include!))
-      )
-    }
-
-    const totalPages = Math.ceil(total / perPage)
-
-    return {
-      data: resultData,
-      meta: {
-        total,
-        page,
-        perPage,
-        totalPages,
-        hasNextPage: page < totalPages,
-        hasPreviousPage: page > 1
-      }
-    }
-  }
-
-  /**
-   * Cursor-based pagination
-   * More efficient for large datasets, similar to Relay/GraphQL cursor pagination
-   */
-  async findManyWithCursor(args: CursorPaginationArgs<${model.name}>): Promise<CursorPaginatedResult<${model.name}>> {
-    const take = args.take || 20
-    let where = args.where || {}
-
-    // Apply cursor if provided
-    if (args.cursor) {
-      const cursorCondition = QueryBuilder.buildCursorCondition(args.cursor, args.orderBy)
-      where = {
-        ...where,
-        ...cursorCondition
-      }
-    }
-
-    // Get total count (optional, for pageInfo)
-    const query = QueryBuilder.buildWhere(args.where || {})
-    const totalCount = await this.collection.countDocuments(query)
-
-    // Get data with one extra to check if there's more
-    const options = {
-      limit: take + 1,
-      ...QueryBuilder.buildOptions(args, this.hiddenFields)
-    }
-
-    const mongoCursor = this.collection.find(where, options)
-    const docs = await mongoCursor.toArray()
-    const hasNextPage = docs.length > take
-
-    // Remove extra element if exists
-    const resultDocs = hasNextPage ? docs.slice(0, take) : docs
-    const data = resultDocs.map(RelationResolver.formatDocument)
-
-    // Handle includes
-    let resultData = data
-    if (args.include) {
-      resultData = await Promise.all(
-        data.map(doc => this.includeRelations(doc, args.include!))
-      )
-    }
-
-    // Create edges with cursors
-    const edges = resultData.map(doc => ({
-      node: doc,
-      cursor: PaginationHelper.createCursor(doc)
-    }))
-
-    return {
-      edges,
-      pageInfo: {
-        hasNextPage,
-        hasPreviousPage: !!args.cursor,
-        startCursor: edges[0]?.cursor,
-        endCursor: edges[edges.length - 1]?.cursor
-      },
-      totalCount
-    }
-  }
-
-  /**
-   * Find with advanced pagination options
-   * Supports both offset and cursor pagination
-   */
-  async findWithPagination(
-    args: ${model.name}QueryOptions & {
-      paginationType?: 'offset' | 'cursor'
-      page?: number
-      perPage?: number
-      cursor?: string | ObjectId
-    }
-  ): Promise<any> {
-    const paginationType = args.paginationType || 'offset'
-
-    if (paginationType === 'cursor') {
-      return this.findManyWithCursor({
-        where: args.where,
-        select: args.select,
-        include: args.include,
-        orderBy: args.orderBy,
-        cursor: args.cursor,
-        take: args.take || args.perPage
-      })
-    } else {
-      return this.findManyPaginated({
-        where: args.where,
-        select: args.select,
-        include: args.include,
-        orderBy: args.orderBy,
-        skip: args.skip,
-        take: args.take,
-        page: args.page,
-        perPage: args.perPage
-      })
-    }
-  }
-
-  /**
-   * Count with pagination info
-   */
-  async countWithPagination(args?: { where?: ${model.name}WhereInput }): Promise<{
-    total: number
-    filtered?: number
-  }> {
-    const where = args?.where ? QueryBuilder.buildWhere(args.where) : {}
-    const total = await this.collection.estimatedDocumentCount()
-    const filtered = await this.collection.countDocuments(where)
-
-    return {
-      total,
-      filtered: total !== filtered ? filtered : undefined
-    }
-  }
-
-  private applySelect(document: any, select: any): any {
-    if (!select) {
-      // If no select, exclude hidden fields by default
-      if (this.hiddenFields.length === 0) return document;
-      const result = { ...document };
-      this.hiddenFields.forEach(field => {
-        delete result[field];
-      });
-      return result;
-    }
-
-    // Build projection using QueryBuilder
-    const projection = QueryBuilder.buildProjection(select, this.hiddenFields);
-    if (!projection) return document;
-
-    const result = { ...document };
-    // Apply projection (simplified - only top-level fields)
-    for (const [field, value] of Object.entries(projection)) {
-      if (value === 0 && field in result) {
-        delete result[field];
-      }
-      // If value === 1, keep the field (already present)
-    }
-    return result;
-  }
-
-  private async includeRelations(document: any, include: any): Promise<any> {
-    const result = { ...document }
-    if (!include || typeof include !== 'object') {
-      return result
-    }
-
-    ${this.generateRelationInclusionCode(model)}
-
-    return result
-  }
-
-  // Raw access
-  get $raw() {
-    return {
-      collection: this.collection,
-      find: async (filter: any) => await this.collection.find(filter).toArray(),
-      findOne: async (filter: any) => await this.collection.findOne(filter),
-      insertOne: async (doc: any) => await this.collection.insertOne(doc),
-      updateOne: async (filter: any, update: any) => await this.collection.updateOne(filter, update),
-      deleteOne: async (filter: any) => await this.collection.deleteOne(filter),
-      aggregate: async (pipeline: any[]) => await this.collection.aggregate(pipeline).toArray()
-    }
-  }
-}
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { Collection, ObjectId, Document } from 'mongodb'
+import type {
+  ${model.name},
+  ${model.name}CreateInput,
+  ${model.name}UpdateInput,
+  ${model.name}WhereInput,
+  ${model.name}QueryOptions,
+  ${model.name}CreateArgs,
+  ${model.name}UpdateArgs,
+  ${model.name}DeleteArgs,
+  ${model.name}UpsertArgs,
+  PaginatedResult,
+  CursorPaginatedResult,
+  OffsetPaginationArgs,
+  CursorPaginationArgs
+} from '../types'
+import { QueryBuilder } from '../runtime/query'
+import { PaginationHelper } from '../runtime/pagination'
+import { RelationResolver } from '../runtime/relations'
+import type { LenzClient } from '../client'
+
+export class ${model.name}Delegate {
+  constructor(private client: LenzClient) {}
+
+  private readonly hiddenFields: string[] = ${JSON.stringify(model.fields.filter(f => f.isHidden).map(f => f.name))};
+
+  private get collection(): Collection<Document> {
+    return this.client.$db.collection('${model.collectionName}')
+  }
+
+  async findUnique(args: { where: ${model.name}WhereInput } & ${model.name}QueryOptions): Promise<${model.name} | null> {
+    const query = QueryBuilder.buildWhere(args.where)
+    const options = QueryBuilder.buildOptions(args, this.hiddenFields)
+
+    const doc = await this.collection.findOne(query, options)
+    if (!doc) return null
+
+    const formatted = RelationResolver.formatDocument(doc)
+
+    if (args.include) {
+      return await this.includeRelations(formatted, args.include)
+    }
+
+    return formatted
+  }
+
+  async findMany(args?: ${model.name}QueryOptions): Promise<${model.name}[]> {
+    const { cursor, ...otherArgs } = args || {}
+    let where = args?.where || {}
+
+    // Handle cursor-based pagination
+    if (cursor) {
+      const cursorCondition = QueryBuilder.buildCursorCondition(cursor, args?.orderBy)
+      where = {
+        ...where,
+        ...cursorCondition
+      }
+    }
+
+    const query = QueryBuilder.buildWhere(where)
+    const options = QueryBuilder.buildOptions(otherArgs || {}, this.hiddenFields)
+
+    const mongoCursor = this.collection.find(query, options)
+    const docs = await mongoCursor.toArray()
+    const formatted = docs.map(RelationResolver.formatDocument)
+
+    if (args?.include) {
+      return await Promise.all(
+        formatted.map(doc => this.includeRelations(doc, args.include!))
+      )
+    }
+
+    return formatted
+  }
+
+  async findFirst(args?: ${model.name}QueryOptions): Promise<${model.name} | null> {
+    const results = await this.findMany({ ...args, take: 1 })
+    return results[0] || null
+  }
+
+  async create(args: ${model.name}CreateArgs): Promise<${model.name}> {
+    const now = new Date()
+    const document = {
+      ...args.data,
+      _id: new ObjectId(),
+      createdAt: now,
+      updatedAt: now
+    }
+
+    const result = await this.collection.insertOne(document)
+    const createdDoc = await this.collection.findOne({ _id: result.insertedId })
+
+    if (!createdDoc) {
+      throw new Error('Failed to create document')
+    }
+
+    const formatted = RelationResolver.formatDocument(createdDoc)
+
+    if (args.include) {
+      return await this.includeRelations(formatted, args.include)
+    }
+
+    return formatted
+  }
+
+  async createMany(args: { data: ${model.name}CreateInput[] }): Promise<{ count: number }> {
+    const now = new Date()
+    const documents = args.data.map(data => ({
+      ...data,
+      _id: new ObjectId(),
+      createdAt: now,
+      updatedAt: now
+    }))
+
+    const result = await this.collection.insertMany(documents)
+    return { count: result.insertedCount }
+  }
+
+  async update(args: ${model.name}UpdateArgs): Promise<${model.name}> {
+    const query = QueryBuilder.buildWhere(args.where)
+    const updateData = {
+      ...args.data,
+      updatedAt: new Date()
+    }
+
+    const update = QueryBuilder.buildUpdate(updateData)
+    const result = await this.collection.findOneAndUpdate(
+      query,
+      update,
+      { returnDocument: 'after' }
+    )
+
+    const updatedDoc = result.value || result
+    if (!updatedDoc) {
+      throw new Error('Document not found')
+    }
+
+    const formatted = RelationResolver.formatDocument(updatedDoc)
+
+    if (args.include) {
+      return await this.includeRelations(formatted, args.include)
+    }
+
+    return formatted
+  }
+
+  async updateMany(args: { where?: ${model.name}WhereInput; data: ${model.name}UpdateInput }): Promise<{ count: number }> {
+    const query = args.where ? QueryBuilder.buildWhere(args.where) : {}
+    const updateData = {
+      ...args.data,
+      updatedAt: new Date()
+    }
+
+    const update = QueryBuilder.buildUpdate(updateData)
+    const result = await this.collection.updateMany(query, update)
+    return { count: result.modifiedCount }
+  }
+
+  async upsert(args: ${model.name}UpsertArgs): Promise<${model.name}> {
+    const query = QueryBuilder.buildWhere(args.where)
+    const existing = await this.collection.findOne(query)
+
+    if (existing) {
+      return this.update({
+        where: args.where,
+        data: args.update,
+        select: args.select,
+        include: args.include
+      })
+    } else {
+      return this.create({
+        data: args.create,
+        select: args.select,
+        include: args.include
+      })
+    }
+  }
+
+  async delete(args: ${model.name}DeleteArgs): Promise<${model.name} | null> {
+    const query = QueryBuilder.buildWhere(args.where)
+    const doc = await this.collection.findOne(query)
+
+    if (!doc) return null
+
+    await this.collection.deleteOne(query)
+    const formatted = RelationResolver.formatDocument(doc)
+
+    if (args.include) {
+      return await this.includeRelations(formatted, args.include)
+    }
+
+    return formatted
+  }
+
+  async deleteMany(args: { where?: ${model.name}WhereInput }): Promise<{ count: number }> {
+    const query = args.where ? QueryBuilder.buildWhere(args.where) : {}
+    const result = await this.collection.deleteMany(query)
+    return { count: result.deletedCount }
+  }
+
+  async count(args?: { where?: ${model.name}WhereInput }): Promise<number> {
+    const query = args?.where ? QueryBuilder.buildWhere(args.where) : {}
+    return await this.collection.countDocuments(query)
+  }
+
+  async aggregate<T = any>(pipeline: any[]): Promise<T[]> {
+    return await this.collection.aggregate(pipeline).toArray() as T[]
+  }
+
+  /**
+   * Offset-based pagination (page-based)
+   * Similar to Prisma's skip/take pagination
+   */
+  async findManyPaginated(args: OffsetPaginationArgs<${model.name}>): Promise<PaginatedResult<${model.name}>> {
+    const page = args.page || 1
+    const perPage = args.take || args.perPage || 10
+    const skip = (page - 1) * perPage
+
+    // Get total count
+    const where = args.where ? QueryBuilder.buildWhere(args.where) : {}
+    const total = await this.collection.countDocuments(where)
+
+    // Get paginated data
+    const query = QueryBuilder.buildWhere(args.where || {})
+    const options = {
+      skip,
+      limit: perPage,
+      ...QueryBuilder.buildOptions(args, this.hiddenFields)
+    }
+
+    const mongoCursor = this.collection.find(query, options)
+    const docs = await mongoCursor.toArray()
+    const data = docs.map(RelationResolver.formatDocument)
+
+    // Handle includes
+    let resultData = data
+    if (args.include) {
+      resultData = await Promise.all(
+        data.map(doc => this.includeRelations(doc, args.include!))
+      )
+    }
+
+    const totalPages = Math.ceil(total / perPage)
+
+    return {
+      data: resultData,
+      meta: {
+        total,
+        page,
+        perPage,
+        totalPages,
+        hasNextPage: page < totalPages,
+        hasPreviousPage: page > 1
+      }
+    }
+  }
+
+  /**
+   * Cursor-based pagination
+   * More efficient for large datasets, similar to Relay/GraphQL cursor pagination
+   */
+  async findManyWithCursor(args: CursorPaginationArgs<${model.name}>): Promise<CursorPaginatedResult<${model.name}>> {
+    const take = args.take || 20
+    let where = args.where || {}
+
+    // Apply cursor if provided
+    if (args.cursor) {
+      const cursorCondition = QueryBuilder.buildCursorCondition(args.cursor, args.orderBy)
+      where = {
+        ...where,
+        ...cursorCondition
+      }
+    }
+
+    // Get total count (optional, for pageInfo)
+    const query = QueryBuilder.buildWhere(args.where || {})
+    const totalCount = await this.collection.countDocuments(query)
+
+    // Get data with one extra to check if there's more
+    const options = {
+      limit: take + 1,
+      ...QueryBuilder.buildOptions(args, this.hiddenFields)
+    }
+
+    const mongoCursor = this.collection.find(where, options)
+    const docs = await mongoCursor.toArray()
+    const hasNextPage = docs.length > take
+
+    // Remove extra element if exists
+    const resultDocs = hasNextPage ? docs.slice(0, take) : docs
+    const data = resultDocs.map(RelationResolver.formatDocument)
+
+    // Handle includes
+    let resultData = data
+    if (args.include) {
+      resultData = await Promise.all(
+        data.map(doc => this.includeRelations(doc, args.include!))
+      )
+    }
+
+    // Create edges with cursors
+    const edges = resultData.map(doc => ({
+      node: doc,
+      cursor: PaginationHelper.createCursor(doc)
+    }))
+
+    return {
+      edges,
+      pageInfo: {
+        hasNextPage,
+        hasPreviousPage: !!args.cursor,
+        startCursor: edges[0]?.cursor,
+        endCursor: edges[edges.length - 1]?.cursor
+      },
+      totalCount
+    }
+  }
+
+  /**
+   * Find with advanced pagination options
+   * Supports both offset and cursor pagination
+   */
+  async findWithPagination(
+    args: ${model.name}QueryOptions & {
+      paginationType?: 'offset' | 'cursor'
+      page?: number
+      perPage?: number
+      cursor?: string | ObjectId
+    }
+  ): Promise<any> {
+    const paginationType = args.paginationType || 'offset'
+
+    if (paginationType === 'cursor') {
+      return this.findManyWithCursor({
+        where: args.where,
+        select: args.select,
+        include: args.include,
+        orderBy: args.orderBy,
+        cursor: args.cursor,
+        take: args.take || args.perPage
+      })
+    } else {
+      return this.findManyPaginated({
+        where: args.where,
+        select: args.select,
+        include: args.include,
+        orderBy: args.orderBy,
+        skip: args.skip,
+        take: args.take,
+        page: args.page,
+        perPage: args.perPage
+      })
+    }
+  }
+
+  /**
+   * Count with pagination info
+   */
+  async countWithPagination(args?: { where?: ${model.name}WhereInput }): Promise<{
+    total: number
+    filtered?: number
+  }> {
+    const where = args?.where ? QueryBuilder.buildWhere(args.where) : {}
+    const total = await this.collection.estimatedDocumentCount()
+    const filtered = await this.collection.countDocuments(where)
+
+    return {
+      total,
+      filtered: total !== filtered ? filtered : undefined
+    }
+  }
+
+  private applySelect(document: any, select: any): any {
+    if (!select) {
+      // If no select, exclude hidden fields by default
+      if (this.hiddenFields.length === 0) return document;
+      const result = { ...document };
+      this.hiddenFields.forEach(field => {
+        delete result[field];
+      });
+      return result;
+    }
+
+    // Build projection using QueryBuilder
+    const projection = QueryBuilder.buildProjection(select, this.hiddenFields);
+    if (!projection) return document;
+
+    const result = { ...document };
+    // Apply projection (simplified - only top-level fields)
+    for (const [field, value] of Object.entries(projection)) {
+      if (value === 0 && field in result) {
+        delete result[field];
+      }
+      // If value === 1, keep the field (already present)
+    }
+    return result;
+  }
+
+  private async includeRelations(document: any, include: any): Promise<any> {
+    const result = { ...document }
+    if (!include || typeof include !== 'object') {
+      return result
+    }
+
+    ${this.generateRelationInclusionCode(model)}
+
+    return result
+  }
+
+  // Raw access
+  get $raw() {
+    return {
+      collection: this.collection,
+      find: async (filter: any) => await this.collection.find(filter).toArray(),
+      findOne: async (filter: any) => await this.collection.findOne(filter),
+      insertOne: async (doc: any) => await this.collection.insertOne(doc),
+      updateOne: async (filter: any, update: any) => await this.collection.updateOne(filter, update),
+      deleteOne: async (filter: any) => await this.collection.deleteOne(filter),
+      aggregate: async (pipeline: any[]) => await this.collection.aggregate(pipeline).toArray()
+    }
+  }
+}
 `;
     }
     generateRelationInclusionCode(model) {
@@ -1626,10 +1626,21 @@ export class ${model.name}Delegate {
                 case 'oneToMany':
                     lines.push(`    // Relation: ${relation.field} (oneToMany)`);
                     lines.push(`    if (include.${relation.field} !== undefined) {`);
-                    lines.push(`      const ${relation.field} = await this.client.${this.toCamelCase(relation.target)}.findMany({`);
-                    lines.push(`        where: { ${relation.foreignKey}: document.id },`);
-                    lines.push(`        include: typeof include.${relation.field} === 'object' ? include.${relation.field} : undefined`);
-                    lines.push(`      })`);
+                    // Check foreign key location: if in source, document has array of IDs; if in target, target has foreign key
+                    if (relation.foreignKeyLocation === 'source') {
+                        // Foreign key is array of IDs in source document
+                        lines.push(`      const ${relation.field} = await this.client.${this.toCamelCase(relation.target)}.findMany({`);
+                        lines.push(`        where: { id: { in: document.${relation.foreignKey} } },`);
+                        lines.push(`        include: typeof include.${relation.field} === 'object' ? include.${relation.field} : undefined`);
+                        lines.push(`      })`);
+                    }
+                    else {
+                        // Foreign key is single ID in target documents (default)
+                        lines.push(`      const ${relation.field} = await this.client.${this.toCamelCase(relation.target)}.findMany({`);
+                        lines.push(`        where: { ${relation.foreignKey}: document.id },`);
+                        lines.push(`        include: typeof include.${relation.field} === 'object' ? include.${relation.field} : undefined`);
+                        lines.push(`      })`);
+                    }
                     lines.push(`      result.${relation.field} = ${relation.field}`);
                     lines.push(`    }`);
                     break;
@@ -1645,9 +1656,9 @@ export class ${model.name}Delegate {
                     break;
                 case 'oneToOne':
                     lines.push(`    // Relation: ${relation.field} (oneToOne)`);
-                    lines.push(`    if (include.${relation.field} !== undefined) {`);
-                    lines.push(`      const ${relation.field} = await this.client.${this.toCamelCase(relation.target)}.findFirst({`);
-                    lines.push(`        where: { ${relation.foreignKey}: document.id },`);
+                    lines.push(`    if (include.${relation.field} !== undefined && document.${relation.foreignKey}) {`);
+                    lines.push(`      const ${relation.field} = await this.client.${this.toCamelCase(relation.target)}.findUnique({`);
+                    lines.push(`        where: { id: document.${relation.foreignKey} },`);
                     lines.push(`        include: typeof include.${relation.field} === 'object' ? include.${relation.field} : undefined`);
                     lines.push(`      })`);
                     lines.push(`      result.${relation.field} = ${relation.field}`);