The Backend with OpenAPI

// Example using Stoker's notFound utility (install 'stoker' if using)
import { Hono } from 'hono';
import { notFound } from 'stoker'; // Assuming 'stoker' is installed

const app = new Hono();

app.notFound(notFound());

export default app;

// Example: Global error handler
import { Hono } from 'hono';
import { HTTPException } from 'hono/http-exception';

const app = new Hono();

app.onError((err, c) => {
  if (err instanceof HTTPException) {
    return err.getResponse();
  }
  console.error(`${err}`);
  return c.json({
    message: 'Internal Server Error',
    ...(process.env.NODE_ENV !== 'production' && { stack: err.stack }),
  }, 500);
});

export default app;

// In your Hono app file (e.g., src/app.ts)
import { Hono } from 'hono';
import { logger } from 'hono-pino';
import { PinoLogger } from 'pino'; // Import PinoLogger type

// Define app bindings for type safety
interface AppBindings {
  Variables: {
    logger: PinoLogger;
  };
}

const app = new Hono<AppBindings>();

// Custom logger instance with request ID for traceability
app.use(logger({
  genReqId: (req) => {
    const requestId = req.headers.get('x-request-id') || crypto.randomUUID();
    return requestId;
  },
  // Configure pino for pretty printing in development
  ...(process.env.NODE_ENV !== 'production' && {
    transport: {
      target: 'pino-pretty',
      options: {
        colorize: true,
      },
    },
  }),
}));

// Your routes would go here, e.g.:
app.get('/', (c) => {
  // Access the logger from the context
  c.get('logger').info('Hello from Hono!');
  return c.json({ message: 'Hello Hono API!' });
});

export default app;

// Conceptual example of Zod OpenAPI integration
// You would typically define your Zod schemas and integrate them with Hono routes
// using a library like hono-zod-openapi or similar patterns.
// This allows for type-safe validation and automatic OpenAPI spec generation.

// Conceptual example of Drizzle and Zod integration
// Define your Drizzle schema:
// import { pgTable, text, timestamp } from 'drizzle-orm/pg-core';
// export const users = pgTable('users', {
//   id: text('id').primaryKey(),
//   name: text('name').notNull(),
//   createdAt: timestamp('created_at').defaultNow(),
// });

// Generate Zod schema from Drizzle:
// import { createSelectSchema } from 'drizzle-zod';
// export const selectUserSchema = createSelectSchema(users);
// This `selectUserSchema` can then be used in your Hono route definitions for response validation.

// Example: Protecting a Hono route with Clerk
import { Hono } from 'hono';
import { ClerkExpressRequireAuth } from '@clerk/clerk-sdk-node'; // Or a custom Hono-compatible middleware

const app = new Hono();

// This is a conceptual example. You might need to adapt Clerk's Node.js SDK
// to work seamlessly with Hono's middleware system.
// A common pattern is to create a Hono middleware that wraps Clerk's verification logic.
const clerkAuthMiddleware = async (c, next) => {
  try {
    // Clerk's SDK would handle token verification from headers
    // and attach user information to the request context.
    // For example, using `ClerkExpressRequireAuth` if adapted for Hono.
    // Or manually verifying the session token:
    // const sessionToken = c.req.header('Authorization')?.split(' ')[1];
    // const client = new ClerkClient({ secretKey: process.env.CLERK_SECRET_KEY });
    // const session = await client.verifyToken(sessionToken);
    // if (!session) throw new Error('Unauthorized');
    // c.set('userId', session.userId); // Attach user ID to Hono context

    // For simplicity, let's assume a basic check for now
    const userId = c.req.header('X-Clerk-User-Id'); // Example for a pre-verified token from a frontend
    if (!userId) {
      return c.json({ error: 'Unauthorized: Missing user ID' }, 401);
    }
    c.set('userId', userId); // Set user ID in Hono context
    await next();
  } catch (error) {
    console.error('Clerk authentication error:', error);
    return c.json({ error: 'Unauthorized: Invalid token' }, 401);
  }
};

app.get('/protected', clerkAuthMiddleware, (c) => {
  const userId = c.get('userId');
  return c.json({ message: `Hello, authenticated user ${userId}!` });
});

export default app;

// Example: Using Growthbook in Hono
import { Hono } from 'hono';
import { GrowthBook } from '@growthbook/growthbook';

const app = new Hono();

// Initialize Growthbook at application start
let gb: GrowthBook;

app.use(async (c, next) => {
  if (!gb) {
    gb = new GrowthBook({
      apiHost: '[https://cdn.growthbook.io](https://cdn.growthbook.io)', // Or your self-hosted instance
      clientKey: process.env.GROWTHBOOK_API_KEY, // Use clientKey for client-side, or secretKey for server-side
      enableDevMode: process.env.NODE_ENV !== 'production',
    });
    await gb.loadFeatures(); // Load features from Growthbook API
  }
  // You can pass the GrowthBook instance down through the context for easy access in handlers
  c.set('growthbook', gb);
  await next();
});

app.get('/feature-test', (c) => {
  const gbInstance = c.get('growthbook');
  if (gbInstance.isOn('new-api-endpoint')) {
    return c.json({ message: 'New API endpoint enabled by feature flag!' });
  } else {
    return c.json({ message: 'Old API endpoint is active (feature flag disabled).' });
  }
});

export default app;

// src/types.d.ts (or similar)
import { Env } from 'hono'; // Hono's base Env type
import { z } from 'zod'; // Assuming Zod for validation

// Define your expected environment variables schema
export const EnvSchema = z.object({
  DATABASE_URL: z.string().url(),
  CLERK_SECRET_KEY: z.string(),
  // ... other env variables
});

// Extend Hono's Env to include your validated environment variables
declare module 'hono' {
  interface Env extends z.infer<typeof EnvSchema> {}
}

// src/utils/env.ts (or similar)
import { EnvSchema } from '../types';

export const parseEnv = (env: unknown) => {
  return EnvSchema.parse(env);
};

// src/app.ts (Hono app)
import { Hono } from 'hono';
import { parseEnv } from './utils/env';
import { EnvSchema } from './types'; // Import EnvSchema for type inference

const app = new Hono<{ Bindings: z.infer<typeof EnvSchema> }>();

// Middleware to parse and validate environment variables from c.env
app.use(async (c, next) => {
  try {
    const parsedEnv = parseEnv(c.env);
    // Hono automatically merges c.env with Bindings, so direct assignment might not be needed
    // if your EnvSchema matches the Bindings type.
    // For explicit access or if you need to transform, you can do:
    // c.set('validatedEnv', parsedEnv);
    await next();
  } catch (error) {
    console.error('Environment variable validation error:', error);
    return c.json({ error: 'Server configuration error' }, 500);
  }
});

export default app;

// src/db/index.ts (conceptual)
import { drizzle } from 'drizzle-orm/libsql'; // For Turso/SQLite
import { createClient } from '@libsql/client'; // For Turso

export const createDB = (env: { DATABASE_URL: string; DATABASE_AUTH_TOKEN?: string }) => {
  const client = createClient({
    url: env.DATABASE_URL,
    authToken: env.DATABASE_AUTH_TOKEN,
  });
  const db = drizzle(client);
  return { client, db };
};

// src/routes/tasks/handlers.ts (conceptual Hono handler)
import { Hono } from 'hono';
import { createDB } from '../../db'; // Adjust path

const app = new Hono();

app.get('/tasks', async (c) => {
  const { db } = createDB(c.env); // Pass c.env to createDB
  // const tasks = await db.select().from(schema.tasks).execute();
  return c.json({ message: 'Tasks retrieved (using Cloudflare DB setup)' });
});