@navios/di 0.2.0 → 0.3.0

package/docs/examples/service-lifecycle.mts

@@ -0,0 +1,359 @@
+import type { OnServiceDestroy, OnServiceInit } from '@navios/di'
+
+import { asyncInject, Container, inject, Injectable } from '@navios/di'
+
+const container = new Container()
+/**
+ * Service Lifecycle Example
+ *
+ * This example demonstrates:
+ * - OnServiceInit interface
+ * - OnServiceDestroy interface
+ * - Service initialization and cleanup
+ * - Resource management
+ */
+
+// 1. Service with initialization and cleanup
+@Injectable()
+class DatabaseService implements OnServiceInit, OnServiceDestroy {
+  private connection: any = null
+  private isConnected = false
+
+  async onServiceInit() {
+    console.log('🔄 Initializing database service...')
+
+    try {
+      this.connection = await this.connect()
+      this.isConnected = true
+      console.log('✅ Database service initialized successfully')
+    } catch (error) {
+      console.error('❌ Failed to initialize database service:', error)
+      throw error
+    }
+  }
+
+  async onServiceDestroy() {
+    console.log('🔄 Destroying database service...')
+
+    try {
+      if (this.connection && this.isConnected) {
+        await this.disconnect()
+        this.isConnected = false
+        console.log('✅ Database service destroyed successfully')
+      } else {
+        console.log('ℹ️ Database service was not connected')
+      }
+    } catch (error) {
+      console.error('❌ Error during database service cleanup:', error)
+    }
+  }
+
+  private async connect() {
+    // Simulate database connection
+    console.log('🔌 Connecting to database...')
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    return {
+      host: 'localhost',
+      port: 5432,
+      database: 'myapp',
+      connected: true,
+      connectTime: new Date(),
+    }
+  }
+
+  private async disconnect() {
+    // Simulate database disconnection
+    console.log('🔌 Disconnecting from database...')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+
+  async query(sql: string) {
+    if (!this.isConnected) {
+      throw new Error('Database not connected')
+    }
+
+    console.log(`📊 Executing query: ${sql}`)
+    return { rows: [], query: sql, executedAt: new Date() }
+  }
+}
+
+// 2. Service with multiple resources
+@Injectable()
+class CacheService implements OnServiceInit, OnServiceDestroy {
+  private cache = new Map()
+  private cleanupInterval: NodeJS.Timeout | null = null
+  private stats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+  }
+
+  async onServiceInit() {
+    console.log('🔄 Initializing cache service...')
+
+    // Start cleanup interval
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup()
+    }, 30000) // Cleanup every 30 seconds
+
+    console.log('✅ Cache service initialized successfully')
+  }
+
+  async onServiceDestroy() {
+    console.log('🔄 Destroying cache service...')
+
+    // Clear the cache
+    this.cache.clear()
+
+    // Clear the interval
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
+    }
+
+    console.log('✅ Cache service destroyed successfully')
+    console.log('📊 Final cache stats:', this.stats)
+  }
+
+  set(key: string, value: any, ttl?: number) {
+    const expires = ttl ? Date.now() + ttl : null
+    this.cache.set(key, { value, expires })
+    this.stats.sets++
+  }
+
+  get(key: string) {
+    const item = this.cache.get(key)
+    if (!item) {
+      this.stats.misses++
+      return null
+    }
+
+    if (item.expires && Date.now() > item.expires) {
+      this.cache.delete(key)
+      this.stats.misses++
+      return null
+    }
+
+    this.stats.hits++
+    return item.value
+  }
+
+  private cleanup() {
+    const now = Date.now()
+    let cleaned = 0
+
+    for (const [key, item] of this.cache.entries()) {
+      if (item.expires && now > item.expires) {
+        this.cache.delete(key)
+        cleaned++
+      }
+    }
+
+    if (cleaned > 0) {
+      console.log(`🧹 Cache cleanup: removed ${cleaned} expired entries`)
+    }
+  }
+
+  getStats() {
+    return { ...this.stats, size: this.cache.size }
+  }
+}
+
+// 3. Service with conditional initialization
+@Injectable()
+class EmailService implements OnServiceInit, OnServiceDestroy {
+  private smtpConnection: any = null
+  private initialized = false
+
+  async onServiceInit() {
+    console.log('🔄 Initializing email service...')
+
+    // Check if email service should be enabled
+    const emailEnabled = process.env.EMAIL_ENABLED === 'true'
+
+    if (emailEnabled) {
+      try {
+        this.smtpConnection = await this.connectToSmtp()
+        this.initialized = true
+        console.log('✅ Email service initialized successfully')
+      } catch (error) {
+        console.error('❌ Failed to initialize email service:', error)
+        // Don't throw - let the service be created but mark it as failed
+      }
+    } else {
+      console.log('ℹ️ Email service disabled by configuration')
+    }
+  }
+
+  async onServiceDestroy() {
+    console.log('🔄 Destroying email service...')
+
+    if (this.initialized && this.smtpConnection) {
+      try {
+        await this.disconnectFromSmtp()
+        console.log('✅ Email service destroyed successfully')
+      } catch (error) {
+        console.error('❌ Error during email service cleanup:', error)
+      }
+    } else {
+      console.log('ℹ️ Email service was not initialized')
+    }
+  }
+
+  private async connectToSmtp() {
+    console.log('🔌 Connecting to SMTP server...')
+    await new Promise((resolve) => setTimeout(resolve, 150))
+
+    return {
+      host: 'smtp.example.com',
+      port: 587,
+      secure: false,
+      connected: true,
+    }
+  }
+
+  private async disconnectFromSmtp() {
+    console.log('🔌 Disconnecting from SMTP server...')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+
+  async sendEmail(to: string, subject: string, body: string) {
+    if (!this.initialized) {
+      throw new Error('Email service not initialized')
+    }
+
+    console.log(`📧 Sending email to ${to}: ${subject}`)
+    return { success: true, messageId: Math.random().toString(36) }
+  }
+}
+
+// 4. Service that depends on other services with lifecycle
+@Injectable()
+class UserService implements OnServiceInit, OnServiceDestroy {
+  private readonly db = inject(DatabaseService)
+  private readonly cache = inject(CacheService)
+  private readonly email = asyncInject(EmailService)
+  private initialized = false
+
+  async onServiceInit() {
+    console.log('🔄 Initializing user service...')
+
+    // Wait for email service to be ready
+    await this.email
+    this.initialized = true
+
+    console.log('✅ User service initialized successfully')
+  }
+
+  async onServiceDestroy() {
+    console.log('🔄 Destroying user service...')
+
+    // Clear user-related cache entries
+    this.cache.set('users:count', null)
+    this.cache.set('users:active', null)
+
+    console.log('✅ User service destroyed successfully')
+  }
+
+  async createUser(name: string, email: string) {
+    if (!this.initialized) {
+      throw new Error('User service not initialized')
+    }
+
+    console.log(`👤 Creating user: ${name}`)
+
+    // Check cache first
+    const cached = this.cache.get(`user:${email}`)
+    if (cached) {
+      console.log('📋 User found in cache')
+      return cached
+    }
+
+    // Create user in database
+    const user = {
+      id: Math.random().toString(36),
+      name,
+      email,
+      createdAt: new Date(),
+    }
+
+    // Cache the user
+    this.cache.set(`user:${email}`, user, 300000) // 5 minutes TTL
+
+    // Send welcome email
+    try {
+      const emailService = await this.email
+      await emailService.sendEmail(
+        email,
+        'Welcome!',
+        `Hello ${name}, welcome to our platform!`,
+      )
+    } catch (error) {
+      console.error('Failed to send welcome email:', error)
+    }
+
+    return user
+  }
+
+  async getUser(email: string) {
+    // Check cache first
+    const cached = this.cache.get(`user:${email}`)
+    if (cached) {
+      return cached
+    }
+
+    // Query database
+    const result = await this.db.query(
+      `SELECT * FROM users WHERE email = '${email}'`,
+    )
+    return result.rows[0] || null
+  }
+}
+
+// 5. Usage example
+async function demonstrateLifecycle() {
+  console.log('=== Service Lifecycle Example ===\n')
+
+  // Create services (initialization happens automatically)
+  const userService = await container.get(UserService)
+  // oxlint-disable-next-line no-unused-vars
+  const dbService = await container.get(DatabaseService)
+  const cacheService = await container.get(CacheService)
+
+  // Use the services
+  const user = await userService.createUser('Alice', 'alice@example.com')
+  console.log('Created user:', user)
+
+  // Check cache stats
+  const stats = cacheService.getStats()
+  console.log('Cache stats:', stats)
+
+  // Simulate some work
+  await new Promise((resolve) => setTimeout(resolve, 1000))
+
+  // Get user from cache
+  const cachedUser = await userService.getUser('alice@example.com')
+  console.log('Retrieved user:', cachedUser)
+
+  // Check updated cache stats
+  const updatedStats = cacheService.getStats()
+  console.log('Updated cache stats:', updatedStats)
+
+  console.log('\n=== Service Cleanup ===')
+
+  // Services will be cleaned up when the application shuts down
+  // or when explicitly invalidated
+}
+
+// Main function
+async function main() {
+  await demonstrateLifecycle()
+}
+
+// Run the example
+if (require.main === module) {
+  main().catch(console.error)
+}
+
+export { DatabaseService, CacheService, EmailService, UserService }