// Middy ile problem - static konfigürasyonconst schema = getSchemaForTenant(tenantId) // Bunu dynamic yapmamız lazım!.use(validator({ eventSchema: schema })) // Ama bu static olmak zorunda

// Developer A'nın yaklaşımıexport const handler = middy(businessLogic)  .use(httpJsonBodyParser())  .use(validator())  .use(httpErrorHandler())
// Developer B'nin yaklaşımı (sıralama farklı!)export const handler = middy(businessLogic)    .use(httpErrorHandler()) // Error handling önce mi?  .use(httpJsonBodyParser())  .use(validator())
// Developer C'nin yaklaşımıexport const handler = middy(businessLogic)  .use(customAuth()) // Team-specific middleware  .use(httpJsonBodyParser())  // Validator hiç yok!

interface LightweightContext {  event: any  context: any  response?: any  metadata: Map<string, any> // Memory efficient storage  startTime: number}
type MiddlewareHandler = (  ctx: LightweightContext,   next: () => Promise<void>) => Promise<void>
class CustomMiddlewareEngine {  private middlewares: MiddlewareHandler[] = []  private isCompiled = false  private compiledChain?: (ctx: LightweightContext) => Promise<void>    use(middleware: MiddlewareHandler): this {    if (this.isCompiled) {      throw new Error('Cannot add middleware after compilation')    }    this.middlewares.push(middleware)    return this  }    // Performance için middleware chain'ini pre-compile et  private compile(): void {    const chain = this.middlewares.reduceRight(      (next, middleware) => (ctx: LightweightContext) =>         middleware(ctx, () => next(ctx)),      () => Promise.resolve()    )    this.compiledChain = chain    this.isCompiled = true  }    async execute(event: any, context: any): Promise<any> {    if (!this.isCompiled) this.compile()        const ctx: LightweightContext = {      event,      context,      metadata: new Map(),      startTime: Date.now()    }        try {      await this.compiledChain!(ctx)      return ctx.response    } catch (error) {      return this.handleError(error, ctx)    }  }}

interface DynamicValidationOptions {  getSchema: (ctx: LightweightContext) => Promise<any>  cacheKey?: (ctx: LightweightContext) => string}
const dynamicValidator = (options: DynamicValidationOptions): MiddlewareHandler => {  const schemaCache = new Map<string, any>()    return async (ctx, next) => {    let schema: any        if (options.cacheKey) {      const key = options.cacheKey(ctx)      schema = schemaCache.get(key)            if (!schema) {        schema = await options.getSchema(ctx)        schemaCache.set(key, schema)      }    } else {      schema = await options.getSchema(ctx)    }        const isValid = validateAgainstSchema(ctx.event, schema)    if (!isValid) {      throw new ValidationError('Invalid request data')    }        await next()  }}
// Multi-tenant desteği ile kullanımconst handler = new CustomMiddlewareEngine()  .use(dynamicValidator({    getSchema: async (ctx) => {      const tenantId = ctx.event.pathParameters?.tenantId      return await getTenantSchema(tenantId)    },    cacheKey: (ctx) => `tenant:${ctx.event.pathParameters?.tenantId}`  }))

interface TeamStandards {  requiredMiddlewares: string[]  forbiddenMiddlewares?: string[]  middlewareOrder: string[]}
const teamStandardsEnforcer = (standards: TeamStandards): MiddlewareHandler => {  return async (ctx, next) => {    const appliedMiddlewares = ctx.metadata.get('middlewares') || []        // Gerekli middleware'lerin mevcut olduğunu doğrula    for (const required of standards.requiredMiddlewares) {      if (!appliedMiddlewares.includes(required)) {        throw new Error(`Required middleware missing: ${required}`)      }    }        await next()  }}
// Standardize handler factory oluşturconst createStandardHandler = (businessLogic: Function) => {  return new CustomMiddlewareEngine()    .use(teamStandardsEnforcer({      requiredMiddlewares: ['auth', 'validation', 'errorHandler'],      middlewareOrder: ['auth', 'validation', 'businessLogic', 'errorHandler']    }))    .use(authMiddleware())    .use(validationMiddleware())    .use(wrapBusinessLogic(businessLogic))    .use(errorHandlerMiddleware())}

export const handler = middy(businessLogic)  .use(httpJsonBodyParser())  .use(httpCors({ origin: true }))  .use(validator({ eventSchema: schema }))  .use(httpErrorHandler())  .use(httpSecurityHeaders())

const handler = new CustomMiddlewareEngine()  .use(jsonParser())  .use(corsHandler({ origin: true }))  .use(requestValidator(schema))  .use(businessLogicWrapper(businessLogic))  .use(errorHandler())  .use(securityHeaders())

interface CircuitBreakerOptions {  failureThreshold: number  recoveryTimeout: number  monitor?: (state: 'open' | 'closed' | 'half-open') => void}
const circuitBreaker = (options: CircuitBreakerOptions): MiddlewareHandler => {  let failures = 0  let lastFailure = 0  let state: 'open' | 'closed' | 'half-open' = 'closed'    return async (ctx, next) => {    const now = Date.now()        // Recovery denemesi yapmalı mıyız kontrol et    if (state === 'open' && now - lastFailure > options.recoveryTimeout) {      state = 'half-open'      options.monitor?.(state)    }        // Circuit açıksa request'leri blokla    if (state === 'open') {      throw new Error('Circuit breaker is open - service temporarily unavailable')    }        try {      await next()            // Başarı - failure'ları resetle      if (failures > 0) {        failures = 0        state = 'closed'        options.monitor?.(state)      }          } catch (error) {      failures++      lastFailure = now            if (failures >= options.failureThreshold) {        state = 'open'        options.monitor?.(state)      }            throw error    }  }}

interface CacheOptions {  ttl: number  keyGenerator: (ctx: LightweightContext) => string  shouldCache: (ctx: LightweightContext) => boolean  invalidateOn?: string[]}
const smartCache = (options: CacheOptions): MiddlewareHandler => {  const cache = new Map<string, { data: any, expires: number }>()    return async (ctx, next) => {    const cacheKey = options.keyGenerator(ctx)    const now = Date.now()        // Cache hit kontrolü    if (options.shouldCache(ctx)) {      const cached = cache.get(cacheKey)      if (cached && cached.expires > now) {        ctx.response = cached.data        ctx.metadata.set('cache', 'hit')        return // Kalan middleware'leri atla      }    }        await next()        // Response'u cache'le    if (ctx.response && options.shouldCache(ctx)) {      cache.set(cacheKey, {        data: ctx.response,        expires: now + options.ttl      })      ctx.metadata.set('cache', 'miss')    }  }}
// Intelligent caching ile kullanımconst handler = new CustomMiddlewareEngine()  .use(smartCache({    ttl: 5 * 60 * 1000, // 5 dakika    keyGenerator: (ctx) => `user:${ctx.event.pathParameters?.userId}`,    shouldCache: (ctx) => ctx.event.httpMethod === 'GET'  }))  .use(businessLogicWrapper(getUserProfile))

// Custom middleware'i mevcut Middy ile karıştırexport const handler = middy(businessLogic)  .use(customPerformanceMiddleware()) // Bizim custom  .use(httpJsonBodyParser())          // Middy  .use(customValidation())            // Bizim custom  .use(httpErrorHandler())            // Middy

// Tüm Middy middleware'leri için custom equivalent'lar inşa etconst customJsonParser = (): MiddlewareHandler => {  return async (ctx, next) => {    if (ctx.event.body && typeof ctx.event.body === 'string') {      try {        ctx.event.body = JSON.parse(ctx.event.body)      } catch (error) {        throw new Error('Invalid JSON body')      }    }    await next()  }}

describe('Custom Middleware Framework', () => {  test('should execute middleware chain in order', async () => {    const executionOrder: string[] = []        const middleware1 = async (ctx: any, next: Function) => {      executionOrder.push('before-1')      await next()      executionOrder.push('after-1')    }        const middleware2 = async (ctx: any, next: Function) => {      executionOrder.push('before-2')      await next()      executionOrder.push('after-2')    }        const engine = new CustomMiddlewareEngine()      .use(middleware1)      .use(middleware2)        await engine.execute({}, {})        expect(executionOrder).toEqual([      'before-1', 'before-2', 'after-2', 'after-1'    ])  })    test('should handle circuit breaker correctly', async () => {    const failingMiddleware = async () => {      throw new Error('Service unavailable')    }        const engine = new CustomMiddlewareEngine()      .use(circuitBreaker({ failureThreshold: 2, recoveryTimeout: 1000 }))      .use(failingMiddleware)        // İlk failure    await expect(engine.execute({}, {})).rejects.toThrow('Service unavailable')        // İkinci failure - circuit'i açmalı    await expect(engine.execute({}, {})).rejects.toThrow('Service unavailable')        // Üçüncü request - circuit breaker tarafından bloklanmalı    await expect(engine.execute({}, {})).rejects.toThrow('Circuit breaker is open')  })})