import { asyncHandler } from '../../middleware/errorHandler';
import { requireAuth, requireApiKey } from '../../middleware/auth-combined';
import { validateBody } from '../../middleware/validation';
import { rateLimitChat } from '../../middleware/rateLimitChat';

// For user authentication (JWT)
router.post('/endpoint', requireAuth, asyncHandler(handler));

// For API key authentication
router.post('/endpoint', requireApiKey, asyncHandler(handler));

// For tenant-isolated routes
router.post('/endpoint', requireAuth, tenantMiddleware, asyncHandler(handler));

// schemas/myEndpoint.ts
import { z } from 'zod';

export const myEndpointSchema = z.object({
  name: z.string().min(1).max(255),
  description: z.string().optional(),
});

export type MyEndpointInput = z.infer<typeof myEndpointSchema>;

router.post('/endpoint', requireAuth, validateBody(myEndpointSchema), asyncHandler(handler));

import { Request, Response } from 'express';
import { logger } from '../../logger';

export const myHandler = async (req: Request, res: Response) => {
  const { userId, workspaceId } = req.auth; // From auth middleware

  logger.info(
    {
      requestId: req.requestId,
      userId,
      workspaceId,
      action: 'my_action',
    },
    'Processing request',
  );

  try {
    // Business logic here
    const result = await myService.doSomething(req.body);

    res.status(200).json({ success: true, data: result });
  } catch (error) {
    logger.error(
      {
        requestId: req.requestId,
        userId,
        error,
      },
      'Request failed',
    );
    throw error; // Let error middleware handle it
  }
};

import { logger } from '../../logger';

// Good - structured logging
logger.info({ userId, workspaceId, requestId, agentId }, 'Agent created');

// Bad - string interpolation
logger.info(`User ${userId} created agent ${agentId}`); // Don't do this

import request from 'supertest';
import { createTestApp } from '../fixtures/testHarness';

describe('POST /api/v1/myendpoint', () => {
  let app: Express;

  beforeAll(async () => {
    app = await createTestApp();
  });

  it('should create resource', async () => {
    const response = await request(app)
      .post('/api/v1/myendpoint')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ name: 'Test' });

    expect(response.status).toBe(201);
    expect(response.body.data.name).toBe('Test');
  });
});