import { createRouter, json, logger } from 'expediate';

const app = createRouter();

app.use('/', logger());
app.use('/', json());

app.get('/hello/:name', (req, res) => {
  res.send(`Hello, ${req.params.name}!`);
});

app.post('/echo', (req, res) => {
  res.setHeader('Content-Type', 'application/json');
  res.send(JSON.stringify((req as any).body));
});

app.listen(3000, () => console.log('Listening on :3000'));

import { createRouter } from 'expediate';

const app = createRouter();

router.METHOD(path, ...middleware)

const guard: Middleware = (req, res, next) => {
  if (!req.headers.authorization) return res.status(401).end();
  next();
};

app.get('/secret', guard, (req, res) => res.send('classified'));
app.get('/multi',  [guard, anotherMiddleware], handler);

app.get('/users/:id',              handler);  // req.params.id
app.get('/orgs/:org/repos/:repo',  handler);  // req.params.org, req.params.repo

app.get('/items/:id(\\d+)',        handler);  // digits only — /items/42 ✓  /items/abc ✗
app.get('/files/:name([\\w-]+)',   handler);  // word chars and hyphens
app.get('/v:ver(\\d+)/status',    handler);  // literal suffix after constraint

app.get('/api/*',       handler);  // one path segment
app.get('/api/**',      handler);  // any depth
app.get('/**/*.php',    handler);  // PHP files in any subdirectory
app.get('/v?/status',   handler);  // one character wildcard

app.get(/^\/users\/(?<id>\d+)/, handler);  // req.params.id

const app = createRouter({ trustProxy: true });

res.send('Hello');                   // write body and end
res.send();                          // end with no body
res.status(404).send('Not found');   // set status + body (chainable)
res.status(201).end();               // set status and end
res.redirect('/new-url');            // 302 redirect
res.json({ ok: true });              // JSON body + Content-Type header
res.type('text/csv').send(data);     // set Content-Type (chainable)
res.etag('v1').json(payload);        // weak ETag W/"v1" (chainable)
res.etag(sha256hex, true).send(buf); // strong ETag "sha256hex"
res.download('/path/to/file.pdf');   // Content-Disposition: attachment
res.download('/path/to/file.pdf', 'invoice.pdf'); // custom download name
res.cookie('session', 'abc', {
  maxAge:   3_600_000,               // milliseconds
  path:     '/api',
  httpOnly: true,
  secure:   true,
  sameSite: 'Strict',
});

app.onError((err, _req, res) => {
  const status = (err as any)?.status ?? 500;
  res.status(status).json({ error: String(err) });
});

app.setNotFound((_req, res) => res.status(404).json({ error: 'Not Found' }));

app.use('/protected', (req, _res, next) => {
  if (!req.headers.authorization) return next(new Error('Unauthorized'));
  next();
});

const api = createRouter();
api.get('/users',     listUsers);
api.get('/users/:id', getUser);
api.post('/users',    createUser);

const app = createRouter();
app.use('/api/v1', api);  // /api/v1/users → api sees /users

app.use('/auth', authRouter);   // Router instance
app.use('/auth', authRouter.listener);  // equivalent

// HTTP
const server = app.listen(3000, () => console.log('Ready'));

// HTTPS
import { readFileSync } from 'fs';
app.listen(443, {
  key:  readFileSync('server.key'),
  cert: readFileSync('server.crt'),
});

// HTTP/2
app.listen(443, { key, cert, http2: true });

// Graceful shutdown
process.on('SIGTERM', () => app.shutdown(10_000));

// Discover OS-assigned ephemeral port (useful in tests)
const srv = app.listen(0, () => {
  const { port } = srv.address() as AddressInfo;
  console.log(`Listening on port ${port}`);
});

console.log(app.routes());
// [{ method: 'GET', path: '/users', stripPath: false }, ...]

import { json } from 'expediate';

app.use('/', json());

app.post('/data', (req, res) => {
  const body = (req as any).body;
  res.json({ received: body });
});

import { formData } from 'expediate';

app.post('/upload', formData(), (req, res) => {
  const parts = (req as any).body as FormPart[];
  for (const part of parts) {
    const disp = part.headers['content-disposition'];
    console.log(disp, '-', part.content.length, 'bytes');
  }
  res.status(201).end();
});

import { formEncoded } from 'expediate';

app.post('/form', formEncoded(), (req, res) => {
  const { username, tags } = (req as any).body;
  res.json({ username, tags }); // tags may be string | string[]
});

import { parseBody } from 'expediate';

app.use('/', parseBody());

import { streamFormData } from 'expediate';

app.post('/upload', async (req, res) => {
  for await (const part of streamFormData(req)) {
    const name = part.headers['content-disposition'];
    const chunks: Buffer[] = [];
    for await (const chunk of part.stream) chunks.push(chunk);
    const content = Buffer.concat(chunks);
    // process content...
  }
  res.send('ok');
});

import { serveStatic } from 'expediate';

app.use('/public', serveStatic('./dist'));

import { serveFile } from 'expediate';

// Serve dist/index.html for every unmatched route
app.get('/**', serveFile('./dist/index.html'));

import { sendFile } from 'expediate';
import type { StaticOptions } from 'expediate';

const opts: StaticOptions = { etag: true, lastModified: true };

app.get('/downloads/:file', (req, res) => {
  const filePath = path.join('./downloads', req.params.file);
  sendFile(req as any, res as any, filePath, opts as any);
});

import { compress } from 'expediate';

app.use(compress());                // default: Brotli > gzip > deflate, threshold 1 KB
app.use(compress({ threshold: 512, brotliQuality: 6 }));

import { conditionalGet } from 'expediate';

app.get('/api/user/:id', conditionalGet(), (req, res) => {
  const user = getUser(req.params.id);
  res.etag(user.updatedAt.toISOString()); // set before sending
  res.json(user);                          // → 304 when client is up to date
});

res.etag('v1');              // weak ETag:   W/"v1"
res.etag(sha256hex, true);   // strong ETag: "sha256hex"

import { cacheControl } from 'expediate';

app.use('/api', cacheControl({ noStore: true }));
app.use('/static', cacheControl({ maxAge: 31_536_000, immutable: true }));

import { requestId } from 'expediate';

app.use(requestId());
app.get('/health', (req, res) => res.json({ id: req.id, status: 'ok' }));

import { rateLimit } from 'expediate';

// 100 requests per minute per IP
app.use(rateLimit({ windowMs: 60_000, max: 100 }));

// Tighter limit on login
app.post('/auth/login', rateLimit({ windowMs: 60_000, max: 5 }), loginHandler);

import { csrf } from 'expediate';

app.use(csrf());
app.get('/form', (req, res) =>
  res.send(`<input type="hidden" name="_csrf" value="${req.csrfToken!()}">`));
// POST /form is validated automatically

import { securityHeaders } from 'expediate';

app.use(securityHeaders());
// Disable HSTS on plain HTTP:
app.use(securityHeaders({ hsts: false }));

import { logger } from 'expediate';

app.use('/', logger({
  track:        true,            // warn on requests that never finish (dev only)
  trackTimeout: 30_000,          // ms before emitting a LOST warning
  user:         (req) => (req as any).user?.username ?? '-',
  locale:       'en-US',
  logger:       (msg) => process.stderr.write(msg + '\n'),
}));

import { createRouter, json, createJwtPlugin } from 'expediate';

const app  = createRouter();
const auth = createJwtPlugin({
  accessTokenSecret:  process.env.JWT_SECRET!,
  refreshTokenSecret: process.env.JWT_REFRESH_SECRET!,
});

// Mount auth endpoints (require json() body parser first)
app.post('/auth/login',   json(), auth.login);
app.post('/auth/refresh', json(), auth.refresh);
app.post('/auth/logout',  json(), auth.logout);

// authenticate — silently populates req.user; calls next() even on failure
// authorize   — rejects with 401 if req.user is not set
app.get('/me', auth.authenticate, auth.authorize, (req, res) => {
  res.send(`Hello, ${(req as any).user.username}`);
});

interface TokenPayload {
  sub:          string;   // user ID
  username:     string;
  iss:          string;   // issuer
  iat:          number;   // issued at (Unix s)
  exp:          number;   // expires at (Unix s)
  roles?:       string[];
  permissions?: string[];
}

// Require at least one of the listed roles
app.delete('/admin/users/:id', ...auth.requireRole('admin'), deleteUser);

// Require ALL listed permissions
app.put('/posts/:id', ...auth.requirePermission('write', 'publish'), updatePost);

app.get('/report', ...auth.requireRole('admin', 'editor'), getReport);

const auth = createJwtPlugin({
  // Secrets — always override in production
  accessTokenSecret:  'change-me',
  refreshTokenSecret: 'change-me',

  // Expiry
  accessTokenExpiry:  15 * 60,         // 15 minutes (seconds)
  refreshTokenExpiry: 7 * 24 * 3600,   // 7 days (seconds)

  // Token claims
  issuer:      'my-app',
  checkIssuer: true,                   // reject tokens with wrong iss claim
  alg:         'HS256',                // 'HS256' | 'HS384' | 'HS512'
                                       // 'RS256' | 'RS384' | 'RS512'
                                       // 'ES256' | 'ES384' | 'ES512'

  // For RS*/ES* algorithms supply PEM keys instead of a shared secret
  // accessTokenPrivateKey: readFileSync('private.pem', 'utf8'),
  // accessTokenPublicKey:  readFileSync('public.pem',  'utf8'),

  // User lookup (replace with a database query) — must override
  fetchUser: async (username) => {
    return await db.users.findOne({ username });
  },

  // Password validation — default uses SHA-256; replace with bcrypt/argon2
  isPasswordValid: async (user, password) => {
    return await bcrypt.compare(password, user.passwordHash);
  },

  // Custom JWT payload
  payload: (user) => ({
    sub:   user.id,
    email: user.email,
    roles: user.roles,
  }),

  // Custom token store (replace with Redis for multi-instance deployments)
  refreshTokenStore: redisAdapter,
});

import { createMapTokenStore } from 'expediate';
const auth = createJwtPlugin({ refreshTokenStore: createMapTokenStore() });

import { createRouter, json, apiBuilder } from 'expediate';
import type { ServiceDefinition } from 'expediate';

interface TodoState {
  items: Record<string, { title: string; done: boolean }>;
  nextId: number;
}

const todoService: ServiceDefinition<TodoState> = {
  // Initial state
  data: () => ({ items: {}, nextId: 1 }),

  // Shared helper methods (bound to `this`)
  methods: {
    findOrThrow(this: TodoState, id: string) {
      const item = this.items[id];
      if (!item) throw { status: 404, message: 'Todo not found' };
      return item;
    },
  },

  GET: {
    '/todos':     function (this: TodoState) { return Object.entries(this.items).map(([id, v]) => ({ id, ...v })); },
    '/todos/:id': function (this: TodoState, params) { return this.findOrThrow(params.id); },
  },

  POST: {
    '/todos': function (this: TodoState, _params, body: any) {
      const id = String(this.nextId++);
      this.items[id] = { title: body.title, done: false };
      return { id, ...this.items[id] };
    },
  },

  DELETE: {
    '/todos/:id': function (this: TodoState, params) {
      this.findOrThrow(params.id);
      delete this.items[params.id];
      return undefined;  // → 201 No Content
    },
  },
};

const app = createRouter();
app.use('/', json());
app.use('/api', apiBuilder(todoService));

app.listen(3000);

const service: ServiceDefinition = {
  // Singleton (default — omit `scope`): one global instance
  // scope: undefined

  // Per-session: same instance reused for all requests sharing the key
  scope: (req) => (req as any).session?.ssid ?? null,

  // Per-request: fresh instance for every request (null key)
  scope: () => null,

  data: () => ({ /* initial state */ }),
};

// Plain message
throw { status: 404, message: 'Resource not found' };

// JSON body
throw { status: 422, data: { field: 'email', error: 'invalid format' } };

// Guard pattern for async setup
methods: {
  throwIfNotReady(this: any) {
    if (!this.ready)
      throw { status: 503, message: 'Service initialising — try again shortly' };
  },
},
setup: function (this: any) {
  this.loadData().then(() => { this.ready = true; });
},

import { createRouter, gitHandler } from 'expediate';
import path from 'path';

const app = createRouter();

app.use('/repos/:repo', gitHandler({
  repository: (req) => {
    // Resolve the repo path from the request; return falsy to 404
    const name = req.params.repo;
    if (!/^[\w.-]+$/.test(name)) return null;
    return path.join('/srv/git', name + '.git');
  },
}));

app.listen(3000);

import { describe, openApiSpec, serializeSpec } from 'expediate';

const todoService = describe({
  summary:     'Todo list API',
  description: 'Manage todos',
  GET: {
    '/todos': {
      summary: 'List all todos',
      responses: { 200: { description: 'Todo array' } },
      handler: function (this: TodoState) { return Object.values(this.items); },
    },
  },
  POST: {
    '/todos': {
      summary:     'Create a todo',
      requestBody: { required: true },
      responses:   { 200: { description: 'Created todo' } },
      handler: function (this: TodoState, _params, body: any) {
        const id = String(this.nextId++);
        this.items[id] = { title: body.title, done: false };
        return { id, ...this.items[id] };
      },
    },
  },
});

const app = createRouter();
app.use('/api', apiBuilder(todoService));
app.get('/openapi.json', openApiSpec(todoService, { title: 'Todo API', version: '1.0.0' }));
app.get('/openapi.yaml', openApiSpec(todoService, { title: 'Todo API', version: '1.0.0', format: 'yaml' }));

// Router
import type {
  Router, RouterOptions, RouterRequest, RouterResponse,
  Middleware, MiddlewareArg, NextFunction, ErrorHandler,
  Layer, RouteInfo, CookieOptions, TlsOptions, StringMap,
} from 'expediate';

// Body parsing
import type { BodyOptions, FormPart, FormPartStream, LoggerOptions } from 'expediate';

// Static files
import type { StaticOptions, Mime } from 'expediate';

// Middleware
import type {
  CompressOptions, RequestIdOptions, RateLimitOptions,
  CacheControlOptions, CsrfOptions, SecurityHeadersOptions,
} from 'expediate';

// JWT
import type { JwtConfig, JwtPlugin, TokenPayload, UserRecord, TokenStore, RefreshTokenRecord } from 'expediate';

// API builder
import type { ServiceDefinition, ServiceMethod, ServiceMethods, RouteMap, ApiError } from 'expediate';

// OpenAPI
import type { OperationMeta, OpenApiServiceMeta, SpecOptions, OpenApiDocument } from 'expediate';

// Git
import type { GitHandlerOptions } from 'expediate';