npm install @deessejs/extensions-cache

// deesse.config.ts
import { defineConfig } from '@deessejs/core'
import { RedisCacheProvider } from '@deessejs/extensions-cache-redis'

export const config = defineConfig({
  extensions: {
    cache: {
      provider: new RedisCacheProvider({
        host: process.env.REDIS_HOST,
        port: parseInt(process.env.REDIS_PORT || '6379'),
        password: process.env.REDIS_PASSWORD,
      }),
      options: {
        prefix: 'deesse:',
        defaultTTL: 3600,
      },
    },
  },
})

import { cache } from '@deessejs/extensions'

// Set with TTL
await cache.set('user:123', user, 3600)

// Get
const user = await cache.get<User>('user:123')

// Delete
await cache.delete('user:123')

// Clear all
await cache.clear()

npm install @deessejs/extensions-queue

import { BullMQQueueProvider } from '@deessejs/extensions-queue-bullmq'

export const config = defineConfig({
  extensions: {
    queue: {
      provider: new BullMQQueueProvider({
        connection: {
          host: process.env.REDIS_HOST,
          port: 6379,
        },
      }),
      options: {
        defaultJobOptions: {
          attempts: 3,
          backoff: {
            type: 'exponential',
            delay: 1000,
          },
        },
      },
    },
  },
})

import { queue } from '@deessejs/extensions'

// Add job
await queue.add('send-email', {
  to: 'user@example.com',
  subject: 'Welcome',
})

// Add with options
await queue.add('process-image', { imageId: '123' }, {
  priority: 1,
  delay: 5000,
})

// Register worker
queue.process('send-email', async (job) => {
  await sendEmail(job.data.to, job.data.subject)
})

npm install @deessejs/extensions-logger

import { PinoLoggerProvider } from '@deessejs/extensions-logger-pino'

export const config = defineConfig({
  extensions: {
    logger: {
      provider: new PinoLoggerProvider({
        level: process.env.LOG_LEVEL || 'info',
        transport: {
          target: 'pino/file',
          options: {
            destination: './logs/app.log',
          },
        },
      }),
    },
  },
})

import { logger } from '@deessejs/extensions'

// Log levels
logger.debug('Cache stats', { hits: 100, misses: 5 })
logger.info('User logged in', { userId: '123' })
logger.warn('High memory usage', { usage: '90%' })
logger.error('Database error', { error: err.message })

// With context
const childLogger = logger.child({ component: 'auth' })
childLogger.info('Login attempt', { email: user.email })

npm install @deessejs/extensions-storage

import { S3StorageProvider } from '@deessejs/extensions-storage-s3'

export const config = defineConfig({
  extensions: {
    storage: {
      provider: new S3StorageProvider({
        region: process.env.AWS_REGION,
        credentials: {
          accessKeyId: process.env.AWS_ACCESS_KEY_ID,
          secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
        },
        bucket: process.env.S3_BUCKET,
      }),
    },
  },
})

import { storage } from '@deessejs/extensions'

// Upload file
const url = await storage.upload('uploads/avatar.jpg', file, {
  contentType: 'image/jpeg',
  metadata: { userId: '123' },
})

// Download file
const stream = await storage.download('uploads/avatar.jpg')

// Delete file
await storage.delete('uploads/avatar.jpg')

// Get signed URL (for private files)
const signedUrl = await storage.getSignedUrl('uploads/avatar.jpg', {
  expiresIn: 3600,
})

// List files
const files = await storage.list('uploads/', { limit: 100 })

npm install @deessejs/extensions-search

import { MeilisearchProvider } from '@deessejs/extensions-search-meilisearch'

export const config = defineConfig({
  extensions: {
    search: {
      provider: new MeilisearchProvider({
        host: process.env.MEILISEARCH_HOST,
        apiKey: process.env.MEILISEARCH_MASTER_KEY,
      }),
    },
  },
})

import { search } from '@deessejs/extensions'

// Create index
await search.createIndex('posts', {
  searchableAttributes: ['title', 'content'],
  sortableAttributes: ['createdAt'],
  filterableAttributes: ['category', 'published'],
})

// Add documents
await search.index('posts').addDocuments([
  { id: 1, title: 'Hello World', content: '...', category: 'tech' },
  { id: 2, title: 'Getting Started', content: '...', category: 'guide' },
])

// Search
const results = await search.index('posts').search('hello', {
  limit: 20,
  filter: 'category = tech',
})

// Update document
await search.index('posts').updateDocuments([{ id: 1, title: 'Updated' }])

// Delete document
await search.index('posts').deleteDocument(1)

npm install @deessejs/extensions-lock

import { RedisLockProvider } from '@deessejs/extensions-lock-redis'

export const config = defineConfig({
  extensions: {
    lock: {
      provider: new RedisLockProvider({
        host: process.env.REDIS_HOST,
        port: 6379,
      }),
    },
  },
})

import { lock } from '@deessejs/extensions'

// Acquire lock
await lock.acquire('process-payment:123', async () => {
  // Only one execution at a time
  await processPayment(123)
}, { ttl: 30000 })

// Manual lock management
const acquired = await lock.acquire('export-data', {
  ttl: 60000,
})

if (acquired) {
  try {
    await exportLargeDataset()
  } finally {
    await lock.release('export-data')
  }
}

npm install @deessejs/extensions-events

import { RedisEventsProvider } from '@deessejs/extensions-events-redis'

export const config = defineConfig({
  extensions: {
    events: {
      provider: new RedisEventsProvider({
        host: process.env.REDIS_HOST,
        port: 6379,
      }),
    },
  },
})

import { events } from '@deessejs/extensions'

// Publish event
await events.publish('user.created', {
  userId: '123',
  email: 'user@example.com',
  timestamp: new Date(),
})

// Subscribe to events
events.subscribe('user.created', async (data) => {
  await sendWelcomeEmail(data.email)
  await updateAnalytics(data)
})

// Subscribe with pattern
events.subscribe('user.*', async (data, event) => {
  console.log('User event:', event, data)
})

// Unsubscribe
const unsubscribe = events.subscribe('user.created', handler)
// Later...
unsubscribe()

npm install @deessejs/extensions-mail

import { ResendMailProvider } from '@deessejs/extensions-mail-resend'

export const config = defineConfig({
  extensions: {
    mail: {
      provider: new ResendMailProvider({
        apiKey: process.env.RESEND_API_KEY,
      }),
      options: {
        from: 'noreply@example.com',
        fromName: 'MyApp',
      },
    },
  },
})

import { mail } from '@deessejs/extensions'

// Send email
await mail.send({
  to: 'user@example.com',
  subject: 'Welcome to MyApp',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
})

// Send with template
await mail.sendTemplate({
  to: 'user@example.com',
  templateId: 'welcome-email',
  data: {
    name: 'John',
    confirmUrl: 'https://example.com/confirm',
  },
})

// Send batch
await mail.sendBatch([
  { to: 'user1@example.com', subject: 'Hello 1' },
  { to: 'user2@example.com', subject: 'Hello 2' },
])

npm install @deessejs/extensions-sms

import { TwilioSMSProvider } from '@deessejs/extensions-sms-twilio'

export const config = defineConfig({
  extensions: {
    sms: {
      provider: new TwilioSMSProvider({
        accountSid: process.env.TWILIO_ACCOUNT_SID,
        authToken: process.env.TWILIO_AUTH_TOKEN,
        from: process.env.TWILIO_PHONE_NUMBER,
      }),
    },
  },
})

import { sms } from '@deessejs/extensions'

// Send SMS
await sms.send('+1234567890', 'Your verification code is 123456')

// Send with options
await sms.send('+1234567890', 'Your code is 123456', {
  priority: 'high',
  metadata: { campaign: 'signup' },
})

// Example: Queue + Logger + Cache
queue.process('process-order', async (job) => {
  logger.info('Processing order', { orderId: job.data.orderId })

  const order = await db.orders.findUnique({
    where: { id: job.data.orderId },
  })

  // Cache the result
  await cache.set(`order:${order.id}`, order, 3600)

  logger.info('Order processed', { orderId: order.id })
})