bun create elysia task-api
cd task-api

bun add @elysiajs/swagger @elysiajs/bearer @elysiajs/cors

mkdir -p src/{routes,models,plugins,middleware}

import { Elysia, t } from 'elysia'
 
// تعريف مخططات المهام كإضافة Elysia لإعادة الاستخدام
export const taskModel = new Elysia({ name: 'Model.Task' })
  .model({
    // مخطط إنشاء مهمة
    'task.create': t.Object({
      title: t.String({ minLength: 1, maxLength: 200 }),
      description: t.Optional(t.String({ maxLength: 1000 })),
      priority: t.Optional(
        t.Union([
          t.Literal('low'),
          t.Literal('medium'),
          t.Literal('high')
        ], { default: 'medium' })
      ),
      dueDate: t.Optional(t.String({ format: 'date' }))
    }),
 
    // مخطط تحديث مهمة
    'task.update': t.Object({
      title: t.Optional(t.String({ minLength: 1, maxLength: 200 })),
      description: t.Optional(t.String({ maxLength: 1000 })),
      priority: t.Optional(
        t.Union([
          t.Literal('low'),
          t.Literal('medium'),
          t.Literal('high')
        ])
      ),
      completed: t.Optional(t.Boolean()),
      dueDate: t.Optional(t.String({ format: 'date' }))
    }),
 
    // مخطط استجابة المهمة
    'task.response': t.Object({
      id: t.String(),
      title: t.String(),
      description: t.Nullable(t.String()),
      priority: t.Union([
        t.Literal('low'),
        t.Literal('medium'),
        t.Literal('high')
      ]),
      completed: t.Boolean(),
      dueDate: t.Nullable(t.String()),
      createdAt: t.String(),
      updatedAt: t.String()
    }),
 
    // معاملات مشتركة
    'task.params': t.Object({
      id: t.String()
    })
  })

export interface Task {
  id: string
  title: string
  description: string | null
  priority: 'low' | 'medium' | 'high'
  completed: boolean
  dueDate: string | null
  createdAt: string
  updatedAt: string
}
 
// مخزن بسيط في الذاكرة
class TaskStore {
  private tasks: Map<string, Task> = new Map()
 
  create(data: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Task {
    const id = crypto.randomUUID()
    const now = new Date().toISOString()
    const task: Task = {
      id,
      ...data,
      createdAt: now,
      updatedAt: now
    }
    this.tasks.set(id, task)
    return task
  }
 
  getAll(): Task[] {
    return Array.from(this.tasks.values())
  }
 
  getById(id: string): Task | undefined {
    return this.tasks.get(id)
  }
 
  update(id: string, data: Partial<Omit<Task, 'id' | 'createdAt'>>): Task | undefined {
    const task = this.tasks.get(id)
    if (!task) return undefined
 
    const updated: Task = {
      ...task,
      ...data,
      updatedAt: new Date().toISOString()
    }
    this.tasks.set(id, updated)
    return updated
  }
 
  delete(id: string): boolean {
    return this.tasks.delete(id)
  }
 
  filter(predicate: (task: Task) => boolean): Task[] {
    return this.getAll().filter(predicate)
  }
}
 
export const taskStore = new TaskStore()

import { Elysia, t } from 'elysia'
import { taskModel } from '../models/task.model'
import { taskStore } from '../models/store'
 
export const taskRoutes = new Elysia({ prefix: '/tasks' })
  .use(taskModel)
 
  // GET /tasks - عرض جميع المهام مع تصفية اختيارية
  .get('/', ({ query }) => {
    let tasks = taskStore.getAll()
 
    if (query.completed !== undefined) {
      tasks = tasks.filter(t => t.completed === (query.completed === 'true'))
    }
 
    if (query.priority) {
      tasks = tasks.filter(t => t.priority === query.priority)
    }
 
    return {
      data: tasks,
      total: tasks.length
    }
  }, {
    query: t.Object({
      completed: t.Optional(t.String()),
      priority: t.Optional(
        t.Union([
          t.Literal('low'),
          t.Literal('medium'),
          t.Literal('high')
        ])
      )
    }),
    detail: {
      tags: ['Tasks'],
      summary: 'عرض جميع المهام'
    }
  })
 
  // GET /tasks/:id - الحصول على مهمة واحدة
  .get('/:id', ({ params, status }) => {
    const task = taskStore.getById(params.id)
 
    if (!task) {
      return status(404, {
        error: 'المهمة غير موجودة',
        id: params.id
      })
    }
 
    return task
  }, {
    params: 'task.params',
    detail: {
      tags: ['Tasks'],
      summary: 'الحصول على مهمة بالمعرف'
    }
  })
 
  // POST /tasks - إنشاء مهمة جديدة
  .post('/', ({ body }) => {
    const task = taskStore.create({
      title: body.title,
      description: body.description ?? null,
      priority: body.priority ?? 'medium',
      completed: false,
      dueDate: body.dueDate ?? null
    })
 
    return task
  }, {
    body: 'task.create',
    response: 'task.response',
    detail: {
      tags: ['Tasks'],
      summary: 'إنشاء مهمة جديدة'
    }
  })
 
  // PATCH /tasks/:id - تحديث مهمة
  .patch('/:id', ({ params, body, status }) => {
    const task = taskStore.update(params.id, {
      ...(body.title !== undefined && { title: body.title }),
      ...(body.description !== undefined && { description: body.description }),
      ...(body.priority !== undefined && { priority: body.priority }),
      ...(body.completed !== undefined && { completed: body.completed }),
      ...(body.dueDate !== undefined && { dueDate: body.dueDate })
    })
 
    if (!task) {
      return status(404, {
        error: 'المهمة غير موجودة',
        id: params.id
      })
    }
 
    return task
  }, {
    params: 'task.params',
    body: 'task.update',
    detail: {
      tags: ['Tasks'],
      summary: 'تحديث مهمة'
    }
  })
 
  // DELETE /tasks/:id - حذف مهمة
  .delete('/:id', ({ params, status }) => {
    const deleted = taskStore.delete(params.id)
 
    if (!deleted) {
      return status(404, {
        error: 'المهمة غير موجودة',
        id: params.id
      })
    }
 
    return { success: true, id: params.id }
  }, {
    params: 'task.params',
    detail: {
      tags: ['Tasks'],
      summary: 'حذف مهمة'
    }
  })

import { Elysia } from 'elysia'
import { bearer } from '@elysiajs/bearer'
 
// في الإنتاج، استخدم مكتبة JWT مناسبة وقاعدة بيانات
const VALID_TOKENS = new Set([
  'demo-token-2026'
])
 
export const authPlugin = new Elysia({ name: 'Plugin.Auth' })
  .use(bearer())
  .derive(({ bearer }) => {
    return {
      isAuthenticated: bearer ? VALID_TOKENS.has(bearer) : false
    }
  })
  .macro({
    requireAuth(enabled: boolean) {
      if (!enabled) return
 
      return {
        beforeHandle({ isAuthenticated, status, set }) {
          if (!isAuthenticated) {
            set.headers['WWW-Authenticate'] = 'Bearer realm="task-api"'
            return status(401, {
              error: 'غير مصرح',
              message: 'يلزم توكن Bearer صالح'
            })
          }
        }
      }
    }
  })

import { Elysia, t } from 'elysia'
import { taskModel } from '../models/task.model'
import { taskStore } from '../models/store'
import { authPlugin } from '../plugins/auth'
 
export const taskRoutes = new Elysia({ prefix: '/tasks' })
  .use(taskModel)
  .use(authPlugin)
 
  // مسارات GET تبقى عامة (بدون requireAuth)
  .get('/', ({ query }) => {
    // ... نفس الكود السابق
  }, {
    // ... نفس الإعدادات
  })
 
  .get('/:id', ({ params, status }) => {
    // ... نفس الكود السابق
  }, {
    // ... نفس الإعدادات
  })
 
  // POST، PATCH، DELETE تحتاج مصادقة الآن
  .post('/', ({ body }) => {
    // ... نفس المعالج
  }, {
    body: 'task.create',
    response: 'task.response',
    requireAuth: true,  // محمي!
    detail: {
      tags: ['Tasks'],
      summary: 'إنشاء مهمة جديدة',
      security: [{ bearer: [] }]
    }
  })
 
  .patch('/:id', ({ params, body, status }) => {
    // ... نفس المعالج
  }, {
    params: 'task.params',
    body: 'task.update',
    requireAuth: true,  // محمي!
    detail: {
      tags: ['Tasks'],
      summary: 'تحديث مهمة',
      security: [{ bearer: [] }]
    }
  })
 
  .delete('/:id', ({ params, status }) => {
    // ... نفس المعالج
  }, {
    params: 'task.params',
    requireAuth: true,  // محمي!
    detail: {
      tags: ['Tasks'],
      summary: 'حذف مهمة',
      security: [{ bearer: [] }]
    }
  })

import { Elysia } from 'elysia'
import { swagger } from '@elysiajs/swagger'
import { cors } from '@elysiajs/cors'
import { taskRoutes } from './routes/tasks'
 
const app = new Elysia()
  // إضافات عامة
  .use(cors())
  .use(swagger({
    documentation: {
      info: {
        title: 'واجهة برمجة تطبيقات إدارة المهام',
        version: '1.0.0',
        description: 'واجهة برمجة تطبيقات REST آمنة الأنواع مبنية بـ ElysiaJS و Bun'
      },
      tags: [
        { name: 'Tasks', description: 'عمليات CRUD للمهام' },
        { name: 'Health', description: 'فحوصات صحة API' }
      ],
      components: {
        securitySchemes: {
          bearer: {
            type: 'http',
            scheme: 'bearer'
          }
        }
      }
    }
  }))
 
  // فحص الصحة
  .get('/health', () => ({
    status: 'ok',
    timestamp: new Date().toISOString(),
    runtime: 'bun',
    version: '1.0.0'
  }), {
    detail: {
      tags: ['Health'],
      summary: 'فحص صحة API'
    }
  })
 
  // تركيب مجموعات المسارات
  .use(taskRoutes)
 
  // معالج أخطاء عام
  .onError(({ code, error }) => {
    if (code === 'VALIDATION') {
      return {
        error: 'خطأ في التحقق',
        message: error.message
      }
    }
 
    return {
      error: 'خطأ داخلي في الخادم',
      message: 'حدث خطأ ما'
    }
  })
 
  .listen(3000)
 
console.log(`🦊 واجهة برمجة تطبيقات المهام تعمل على ${app.server?.hostname}:${app.server?.port}`)
console.log(`📚 توثيق Swagger على http://localhost:3000/swagger`)
 
// تصدير نوع التطبيق لـ Eden Treaty
export type App = typeof app

bun run src/index.ts

# فحص الصحة
curl http://localhost:3000/health
 
# إنشاء مهمة (مع مصادقة)
curl -X POST http://localhost:3000/tasks \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer demo-token-2026" \
  -d '{"title": "تعلم ElysiaJS", "priority": "high"}'
 
# عرض جميع المهام (عام)
curl http://localhost:3000/tasks
 
# تصفية حسب الأولوية
curl "http://localhost:3000/tasks?priority=high"
 
# تحديث مهمة
curl -X PATCH http://localhost:3000/tasks/<task-id> \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer demo-token-2026" \
  -d '{"completed": true}'
 
# حذف مهمة
curl -X DELETE http://localhost:3000/tasks/<task-id> \
  -H "Authorization: Bearer demo-token-2026"
 
# محاولة بدون مصادقة (يجب أن تحصل على 401)
curl -X POST http://localhost:3000/tasks \
  -H "Content-Type: application/json" \
  -d '{"title": "يجب أن يفشل"}'

bun add @elysiajs/eden

import { treaty } from '@elysiajs/eden'
import type { App } from './index'
 
// إنشاء عميل آمن الأنواع
const api = treaty<App>('localhost:3000')
 
async function demo() {
  // ✅ إكمال تلقائي كامل للمسار والجسم والاستجابة
  const { data: tasks } = await api.tasks.get({
    query: { priority: 'high' }
  })
 
  console.log('المهام عالية الأولوية:', tasks)
 
  // ✅ TypeScript يعرف شكل الجسم
  const { data: newTask } = await api.tasks.post({
    title: 'شحن الميزة',
    priority: 'high'
  }, {
    headers: {
      authorization: 'Bearer demo-token-2026'
    }
  })
 
  console.log('المهمة المنشأة:', newTask)
 
  // ✅ TypeScript يعرف أن هذا يرجع Task | error
  if (newTask) {
    const { data: updated } = await api.tasks({ id: newTask.id }).patch({
      completed: true
    }, {
      headers: {
        authorization: 'Bearer demo-token-2026'
      }
    })
 
    console.log('المهمة المحدثة:', updated)
  }
}
 
demo()

import { Elysia } from 'elysia'
 
export const loggerPlugin = new Elysia({ name: 'Plugin.Logger' })
  .onRequest(({ request }) => {
    console.log(`→ ${request.method} ${new URL(request.url).pathname}`)
  })
  .onAfterResponse(({ request, set }) => {
    console.log(`← ${request.method} ${new URL(request.url).pathname} ${set.status ?? 200}`)
  })

import { Elysia } from 'elysia'
 
const requestCounts = new Map<string, { count: number; resetAt: number }>()
 
export const rateLimitPlugin = new Elysia({ name: 'Plugin.RateLimit' })
  .derive(({ request }) => {
    const ip = request.headers.get('x-forwarded-for') ?? 'unknown'
    return { clientIp: ip }
  })
  .onBeforeHandle(({ clientIp, status, set }) => {
    const now = Date.now()
    const window = 60_000 // دقيقة واحدة
    const limit = 100
 
    let entry = requestCounts.get(clientIp)
 
    if (!entry || now > entry.resetAt) {
      entry = { count: 0, resetAt: now + window }
      requestCounts.set(clientIp, entry)
    }
 
    entry.count++
 
    set.headers['X-RateLimit-Limit'] = String(limit)
    set.headers['X-RateLimit-Remaining'] = String(Math.max(0, limit - entry.count))
 
    if (entry.count > limit) {
      set.headers['Retry-After'] = String(Math.ceil((entry.resetAt - now) / 1000))
      return status(429, { error: 'طلبات كثيرة جداً' })
    }
  })

import { describe, it, expect, beforeAll } from 'bun:test'
import { treaty } from '@elysiajs/eden'
import { Elysia } from 'elysia'
import { taskRoutes } from '../routes/tasks'
 
// إنشاء نسخة اختبار
const app = new Elysia()
  .use(taskRoutes)
 
const api = treaty(app)
 
describe('واجهة برمجة تطبيقات المهام', () => {
  let taskId: string
 
  it('يجب أن ينشئ مهمة', async () => {
    const { data, status } = await api.tasks.post({
      title: 'مهمة اختبار',
      priority: 'high'
    }, {
      headers: {
        authorization: 'Bearer demo-token-2026'
      }
    })
 
    expect(status).toBe(200)
    expect(data?.title).toBe('مهمة اختبار')
    expect(data?.priority).toBe('high')
    expect(data?.completed).toBe(false)
 
    taskId = data!.id
  })
 
  it('يجب أن يعرض المهام', async () => {
    const { data } = await api.tasks.get()
 
    expect(data?.total).toBeGreaterThan(0)
  })
 
  it('يجب أن يحذف مهمة', async () => {
    const { data } = await api.tasks({ id: taskId }).delete(undefined, {
      headers: {
        authorization: 'Bearer demo-token-2026'
      }
    })
 
    expect(data?.success).toBe(true)
  })
})

bun test