DeepSeek Harness: التنظيف التلقائي و ctx.effect()

class Context {
  private _disposables: Disposable[] = []
  
  register(disposable: Disposable) {
    this._disposables.push(disposable)
  }
  
  dispose() {
    for (const d of this._disposables.reverse()) {
      d.dispose()
    }
  }
}

import { Context } from '@deepseek-ai/cordis'

export const name = 'auto-cleanup-demo'

export function apply(ctx: Context) {
  // جميع التسجيلات أدناه تُنظّف تلقائياً
  ctx.on('session/created', (s) => {
    ctx.logger.info(`session: ${s.id}`)
  })

  ctx.setInterval(() => {
    ctx.logger.info('tick')
  }, 10000)

  ctx.command('demo')
    .action(() => 'demo command')
}
// عند إلغاء تحميل الإضافة: المستمع أُزيل + المؤقت مُسح + الأمر أُلغي، صفر كود يدوي

ctx.effect(() => {
  // أعد دالة تنظيف
  return () => {
    // منطق التنظيف
  }
})

import { Context } from '@deepseek-ai/cordis'

export const name = 'manual-cleanup'

export function apply(ctx: Context) {
  const connection = createExternalConnection()

  ctx.effect(() => {
    return () => {
      connection.close()
      ctx.logger.info('connection closed')
    }
  })
}

// النمط 1: إعادة دالة التنظيف (مُوصى به)
ctx.effect(() => {
  const ws = new WebSocket('ws://localhost:8080')
  return () => ws.close()
})

// النمط 2: تمرير مرجع دالة التنظيف
const cleanup = () => { /* ... */ }
ctx.effect(cleanup)

ctx.effect(() => {
  const resource = acquireResource()
  
  return () => {
    releaseResource(resource)
  }
})

// نموذج try-finally المُكافئ ذهنياً
try {
  const resource = acquireResource()
  // استخدام المورد
} finally {
  releaseResource(resource)
}

export function apply(ctx: Context) {
  ctx.effect(() => {
    const db = openDatabase()
    const cache = openCache()
    
    return () => {
      cache.close()  // أغلق التابع أولاً
      db.close()     // ثم أغلق ما يعتمد عليه
    }
  })
}

ctx.effect(() => {
  const conn = createConnection()
  return () => {
    try {
      conn.close()
    } catch (e) {
      ctx.logger.warn('cleanup error:', e)
    }
  }
})

export function apply(ctx: Context) {
  // استخدم ctx.setInterval — تنظيف تلقائي
  ctx.setInterval(() => {
    ctx.logger.info('heartbeat')
  }, 30000)
}

export function apply(ctx: Context) {
  const timer = setInterval(() => {
    ctx.logger.info('heartbeat')
  }, 30000)

  ctx.effect(() => {
    return () => clearInterval(timer)
  })
}

// ❌ خطأ: setTimeout يظل يعمل بعد إلغاء التحميل
export function apply(ctx: Context) {
  setTimeout(() => {
    ctx.logger.info('delayed action') // الإضافة قد تكون أُلغي تحميلها بالفعل!
  }, 5000)
}

// ✅ صحيح: استخدم ctx.setTimeout
export function apply(ctx: Context) {
  ctx.setTimeout(() => {
    ctx.logger.info('delayed action') // لن يعمل بعد إلغاء التحميل
  }, 5000)
}

import { createServer } from 'http'

export function apply(ctx: Context) {
  const server = createServer((req, res) => {
    res.end('ok')
  })

  server.listen(3456)

  ctx.effect(() => {
    return () => {
      server.close()
      ctx.logger.info('HTTP server closed')
    }
  })
}

import WebSocket from 'ws'

export function apply(ctx: Context) {
  const ws = new WebSocket('ws://localhost:8080')

  ws.on('open', () => {
    ctx.logger.info('ws connected')
  })

  ctx.effect(() => {
    return () => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.close()
      }
    }
  })
}

import { Pool } from 'pg'

export function apply(ctx: Context) {
  const pool = new Pool({
    connectionString: 'postgresql://localhost/mydb',
    max: 10
  })

  ctx.effect(() => {
    return async () => {
      await pool.end()
      ctx.logger.info('db pool closed')
    }
  })
}

export function apply(ctx: Context) {
  const emitter = getExternalEmitter()

  const handler = (data: any) => {
    ctx.logger.info('event:', data)
  }

  emitter.on('data', handler)

  ctx.effect(() => {
    return () => {
      emitter.off('data', handler)
    }
  })
}

// ❌ تسرب: المؤقت يظل يعمل بعد إلغاء التحميل
export function apply(ctx: Context) {
  setInterval(() => {
    console.log('orphan timer')
  }, 1000)
}

// ❌ إغلاق قاعدة البيانات أولاً، ثم إغلاق الذاكرة المؤقتة التي تعتمد عليها
ctx.effect(() => {
  const db = openDB()
  const cache = new Cache(db)
  return () => {
    db.close()      // أُغلقت db أولاً
    cache.close()   // الذاكرة المؤقتة تصل لـ db داخلياً → خطأ
  }
})

// ❌ دالة التنظيف ترمي استثناءً، تقطع التنظيف اللاحق
ctx.effect(() => {
  return () => {
    throw new Error('cleanup failed')  // تأثيرات أخرى قد لا تُنفّذ
  }
})

// ❌ يشير لمتغير خارجي قد يكون غير صالح بعد إلغاء التحميل
let globalRef: SomeObject | null = new SomeObject()

export function apply(ctx: Context) {
  ctx.effect(() => {
    return () => {
      globalRef!.cleanup()  // globalRef قد أُعيّن لـ null بكود آخر
    }
  })
}