@bairock/lenz 0.0.14 → 0.0.16

package/dist/engine/generators/ClientGenerator.js

@@ -0,0 +1,386 @@
+import { toCamelCase } from './helpers.js';
+export class ClientGenerator {
+    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
+`;
+    }
+    generateClient(clientName, models) {
+        return `// This file was auto-generated by Lenz. Do not edit manually.
+// @generated
+
+import { MongoClient, Db, ObjectId, Collection, Document } from 'mongodb'
+import type { LenzConfig } from './types'
+import { QueryBuilder } from './runtime/query'
+import { RelationResolver } from './runtime/relations'
+import { Logger } from './runtime/logger'
+
+${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 database: string
+  private supportsTransactions: boolean = false
+  private logger: Logger
+
+  // Model delegates
+${models.map(model => `  public ${toCamelCase(model.name)}: ${model.name}Delegate`).join('\n')}
+
+  private extractDatabaseFromUrl(url: string): string {
+    try {
+      const parsed = new URL(url);
+      const db = parsed.pathname.replace(/^\//, '').split('/')[0];
+      return db || 'myapp';
+    } catch {
+      return 'myapp';
+    }
+  }
+
+  constructor(config: LenzConfig = {}) {
+    this.config = {
+      ...config,
+      url: config.url || process.env.MONGODB_URI || 'mongodb://localhost:27017/myapp',
+      log: config.log || []
+    };
+    this.database = config.database || this.extractDatabaseFromUrl(this.config.url);
+    this.logger = new Logger(this.config.log);
+
+    // Initialize model delegates
+${models.map(model => `    this.${toCamelCase(model.name)} = new ${model.name}Delegate(this)`).join('\n')}
+  }
+
+  // Extensions storage ($extends support)
+  private extensions: Array<{
+    query?: Record<string, Record<string, (params: { args: any; query: (args: any) => Promise<any> }) => Promise<any>>>
+    result?: Record<string, Record<string, { needs?: Record<string, boolean>; compute: (parent: any) => any }>>
+    client?: Record<string, (...args: any[]) => any>
+  }> = []
+
+  /**
+   * Prisma-compatible $extends — add query interception, computed fields, and client methods
+   * @example
+   * const xprisma = lenz.$extends({
+   *   query: {
+   *     user: {
+   *       findMany: async ({ args, query }) => {
+   *         args.where = { ...args.where, deleted: false }
+   *         return query(args)
+   *       }
+   *     }
+   *   },
+   *   result: {
+   *     user: {
+   *       fullName: {
+   *         needs: { firstName: true, lastName: true },
+   *         compute: (user) => \`\${user.firstName} \${user.lastName}\`
+   *       }
+   *     }
+   *   },
+   *   client: {
+   *     ping: async () => lenz.$mongo.client.db().admin().ping()
+   *   }
+   * })
+   */
+  $extends(extension: any): this {
+    this.extensions.push(extension)
+
+    if (extension.client) {
+      for (const [key, fn] of Object.entries(extension.client)) {
+        ;(this as any)[key] = fn
+      }
+    }
+
+    return this
+  }
+
+  getQueryExtension(modelName: string, method: string): ((params: { args: any; query: (args: any) => Promise<any> }) => Promise<any>) | null {
+    for (const ext of this.extensions) {
+      if (ext.query?.[modelName]?.[method]) {
+        return ext.query[modelName][method]
+      }
+    }
+    return null
+  }
+
+  getResultExtensions(modelName: string): Array<{ name: string; compute: (parent: any) => any }> | null {
+    const exts: Array<{ name: string; compute: (parent: any) => any }> = []
+    for (const ext of this.extensions) {
+      if (ext.result?.[modelName]) {
+        for (const [name, config] of Object.entries(ext.result[modelName])) {
+          exts.push({ name, compute: (config as any).compute })
+        }
+      }
+    }
+    return exts.length > 0 ? exts : null
+  }
+
+  $on(event: string, callback: any): void {
+    this.logger.on(event, callback)
+  }
+
+  get $logger(): Logger {
+    return this.logger
+  }
+
+  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.database)
+
+    await this.db.command({ ping: 1 })
+
+    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
+    }
+
+    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>(
+    args: Array<(tx: any) => Promise<any>> | ((tx: any) => Promise<T>),
+    options?: { maxRetry?: number; timeout?: number }
+  ): Promise<any> {
+    if (!this.mongoClient) {
+      throw new Error('Not connected to database')
+    }
+
+    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 maxRetry = options?.maxRetry ?? 3;
+
+    const isTransientError = (error: any): boolean => {
+      return error?.code === 112 ||
+             error?.code === 245 ||
+             error?.code === 246 ||
+             error?.errorLabels?.includes('TransientTransactionError') ||
+             error?.errorLabels?.includes('UnknownTransactionCommitResult')
+    }
+
+    if (Array.isArray(args)) {
+      const session = this.mongoClient.startSession()
+      try {
+        session.startTransaction()
+        const fns = args as Array<(tx: any) => Promise<any>>;
+        const results: any[] = [];
+        for (const fn of fns) {
+          results.push(await fn(session));
+        }
+        await session.commitTransaction()
+        return results
+      } catch (error) {
+        await session.abortTransaction().catch(() => {})
+        throw error
+      } finally {
+        session.endSession()
+      }
+    }
+
+    let lastError: any;
+    for (let attempt = 0; attempt <= maxRetry; attempt++) {
+      const session = this.mongoClient.startSession()
+      try {
+        session.startTransaction()
+
+        const result = await (args as (tx: any) => Promise<T>)(session)
+
+        let committed = false;
+        for (let commitAttempt = 0; commitAttempt < 3; commitAttempt++) {
+          try {
+            await session.commitTransaction()
+            committed = true;
+            break;
+          } catch (commitError: any) {
+            if (commitAttempt < 2 && isTransientError(commitError)) {
+              await new Promise(r => setTimeout(r, Math.min(100 * Math.pow(2, commitAttempt), 1000)))
+              continue
+            }
+            throw commitError
+          }
+        }
+
+        if (!committed) {
+          throw new Error('Failed to commit transaction after retries')
+        }
+
+        return result
+      } catch (error: any) {
+        await session.abortTransaction().catch(() => {})
+
+        if (attempt < maxRetry && isTransientError(error)) {
+          const delay = Math.min(100 * Math.pow(2, attempt), 2000)
+          await new Promise(r => setTimeout(r, delay))
+          lastError = error
+          continue
+        }
+
+        throw error
+      } finally {
+        session.endSession()
+      }
+    }
+
+    throw lastError || new Error('Transaction failed')
+  }
+
+  $supportsTransactions(): boolean {
+    return this.supportsTransactions
+  }
+
+  private async initializeCollections(): Promise<void> {
+    if (!this.db) return
+
+    const models = ${JSON.stringify(this.getModelsForRuntime(models), null, 2)}
+
+    for (const model of models) {
+      if (!model.collectionName) continue
+
+      const collections = await this.db.listCollections({ name: model.collectionName }).toArray()
+
+      if (collections.length === 0) {
+        await this.db.createCollection(model.collectionName)
+
+        if (model.indexes.length > 0) {
+          const indexes = model.indexes.map(index => {
+            const spec: any = {
+              key: index.fields.reduce((acc, field) => {
+                const dbField = model.fieldDbNames?.[field] || field
+                acc[dbField] = 1
+                return acc
+              }, {}),
+              unique: index.unique,
+              sparse: index.sparse || false
+            };
+            if (index.name) spec.name = index.name;
+            return spec;
+          })
+
+          try {
+            await this.db.collection(model.collectionName).createIndexes(indexes)
+          } catch (error) {
+            console.warn(\`Failed to create indexes for \${model.name}:\`, error)
+          }
+        }
+
+        // Create full-text search index (if configured)
+        if (model.fulltextFields && model.fulltextFields.length > 0) {
+          try {
+            const textIndex: any = {};
+            for (const field of model.fulltextFields) {
+              const dbField = model.fieldDbNames?.[field] || field
+              textIndex[dbField] = 'text'
+            }
+            await this.db.collection(model.collectionName).createIndex(textIndex, { name: \`\${model.collectionName}_text\` })
+          } catch (error) {
+            console.warn(\`Failed to create text index 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
+    }
+  }
+
+  get $raw(): { collection: (name: string) => Collection<Document> } {
+    if (!this.db) {
+      throw new Error('Database not connected. Call $connect() first.')
+    }
+    return {
+      collection: (name: string) => this.db!.collection(name)
+    }
+  }
+}
+`;
+    }
+    getModelsForRuntime(models) {
+        return models.map(model => ({
+            name: model.name,
+            collectionName: model.collectionName,
+            fieldDbNames: Object.fromEntries(model.fields.filter(f => f.dbName).map(f => [f.name, f.dbName])),
+            indexes: model.indexes.map(index => {
+                const idx = {
+                    fields: index.fields,
+                    unique: index.unique,
+                    sparse: index.sparse ?? false
+                };
+                if (index.name)
+                    idx.name = index.name;
+                return idx;
+            }),
+            fulltextFields: model.fulltextFields
+        }));
+    }
+}
+//# sourceMappingURL=ClientGenerator.js.map

package/dist/engine/generators/ClientGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientGenerator.js","sourceRoot":"","sources":["../../../src/engine/generators/ClientGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,OAAO,eAAe;IAC1B,aAAa,CAAC,UAAkB;QAC9B,OAAO;;;WAGA,UAAU;;;;WAIV,UAAU;;;;;mBAKF,UAAU;;CAE5B,CAAC;IACA,CAAC;IAED,cAAc,CAAC,UAAkB,EAAE,MAAsB;QACvD,OAAO;;;;;;;;;EAST,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;WACX,KAAK,CAAC,IAAI,6BAA6B,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;eAE5D,UAAU;;;;;;;;;EASvB,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;EAsB5F,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,KAAK,CAAC,IAAI,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8NpF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+E7E,CAAC;IACA,CAAC;IAED,mBAAmB,CAAC,MAAsB;QACxC,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC1B,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,YAAY,EAAE,MAAM,CAAC,WAAW,CAC9B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAChE;YACD,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBACjC,MAAM,GAAG,GAAQ;oBACf,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,KAAK;iBAC9B,CAAC;gBACF,IAAI,KAAK,CAAC,IAAI;oBAAE,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;gBACtC,OAAO,GAAG,CAAC;YACb,CAAC,CAAC;YACF,cAAc,EAAE,KAAK,CAAC,cAAc;SACrC,CAAC,CAAC,CAAC;IACN,CAAC;CACF"}

package/dist/engine/generators/DelegateGenerator.d.ts

@@ -0,0 +1,9 @@
+import { GraphQLModel } from '../GraphQLParser.js';
+export declare class DelegateGenerator {
+    private helpers;
+    private relations;
+    generateModelsIndex(models: GraphQLModel[]): string;
+    generateModelFiles(models: GraphQLModel[]): Record<string, string>;
+    generateModelDelegate(model: GraphQLModel, collectionNameMap?: Record<string, string>): string;
+}
+//# sourceMappingURL=DelegateGenerator.d.ts.map

package/dist/engine/generators/DelegateGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DelegateGenerator.d.ts","sourceRoot":"","sources":["../../../src/engine/generators/DelegateGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKnD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,SAAS,CAA2B;IAE5C,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM;IAInD,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAWlE,qBAAqB,CAAC,KAAK,EAAE,YAAY,EAAE,iBAAiB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,MAAM;CAgbnG"}