Hono + Cloudflare D1: Production Best Practices [2026]

import { Hono } from 'hono';
import { drizzle } from 'drizzle-orm/d1';
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
import { eq, sql } from 'drizzle-orm';

// 1. Drizzle Schema Definition
export const customers = sqliteTable('customers', {
  id: text('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name').notNull(),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`(unixepoch())`),
});

export const orders = sqliteTable('orders', {
  id: text('id').primaryKey(),
  customerId: text('customer_id').notNull().references(() => customers.id),
  totalCents: integer('total_cents').notNull(),
  status: text('status', { enum: ['pending', 'paid', 'shipped'] }).notNull().default('pending'),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().default(sql`(unixepoch())`),
});

export const orderItems = sqliteTable('order_items', {
  id: text('id').primaryKey(),
  orderId: text('order_id').notNull().references(() => orders.id),
  sku: text('sku').notNull(),
  quantity: integer('quantity').notNull(),
  priceCents: integer('price_cents').notNull(),
});

// 2. Type-Safe Environment Bindings
export interface Env {
  Bindings: {
    DB: D1Database;
    ENVIRONMENT: 'production' | 'staging' | 'development';
  };
  Variables: {
    db: ReturnType<typeof drizzle>;
    sessionId?: string;
  };
}

const app = new Hono<Env>();

// 3. Database Context & Sessions Middleware
app.use('*', async (c, next) => {
  // Drizzle ORM D1-Treiber: Schlanke Initialisierung ohne native Binaries (~8 KB)
  c.set('db', drizzle(c.env.DB));
  
  // D1 Sessions API: Read-your-own-writes Konsistenz über x-d1-session Header
  const clientSession = c.req.header('x-d1-session');
  if (clientSession) {
    c.set('sessionId', clientSession);
  }
  
  await next();
});

// 4. Global Error Handler (RFC 7807 Problem Details)
app.onError((err, c) => {
  console.error('[Hono D1 Error]:', err);
  
  if (err.message.includes('SQLITE_CONSTRAINT')) {
    return c.json({
      type: 'https://weretrade.com/errors/db-constraint',
      title: 'Database Constraint Violation',
      status: 409,
      detail: 'Der Datensatz verletzt einen Unique-Constraint oder Fremdschlüssel.',
    }, 409);
  }
  
  return c.json({
    type: 'https://weretrade.com/errors/internal-server-error',
    title: 'Internal Server Error',
    status: 500,
    detail: c.env.ENVIRONMENT === 'production' ? 'Ein Datenbankfehler ist aufgetreten.' : err.message,
  }, 500);
});

// 5. Atomare Batch-Transaktion (Order Placement)
app.post('/api/orders', async (c) => {
  const body = await c.req.json<{
    customerId: string;
    items: Array<{ sku: string; quantity: number; priceCents: number }>;
  }>();

  if (!body.customerId || !body.items || body.items.length === 0) {
    return c.json({ error: 'Ungültige Bestelldaten' }, 400);
  }

  const orderId = `ord_${crypto.randomUUID()}`;
  const totalCents = body.items.reduce((sum, item) => sum + item.priceCents * item.quantity, 0);

  // D1 Batch API: Führt alle Statements in einer einzigen SQLite-Transaktion atomar aus.
  // Scheitert ein Statement, rollt D1 automatisch den gesamten Batch zurück.
  const statements: D1PreparedStatement[] = [
    // 1. Order anlegen
    c.env.DB.prepare(
      `INSERT INTO orders (id, customer_id, total_cents, status, created_at)
       VALUES (?, ?, ?, 'pending', unixepoch())`
    ).bind(orderId, body.customerId, totalCents),
    
    // 2. Order Items hinzufügen
    ...body.items.map((item) =>
      c.env.DB.prepare(
        `INSERT INTO order_items (id, order_id, sku, quantity, price_cents)
         VALUES (?, ?, ?, ?, ?)`
      ).bind(`item_${crypto.randomUUID()}`, orderId, item.sku, item.quantity, item.priceCents)
    ),
  ];

  const results = await c.env.DB.batch(statements);

  // Extrahiere Session-Token für Read-Replication Folgereads
  const sessionToken = results[0]?.meta?.last_row_id?.toString() || undefined;

  return c.json({
    success: true,
    orderId,
    totalCents,
    itemCount: body.items.length,
  }, 201, {
    ...(sessionToken ? { 'x-d1-session': sessionToken } : {}),
    'Cache-Control': 'no-store',
  });
});

// 6. Fast-Path Prepared Query (Get Customer Orders)
app.get('/api/customers/:id/orders', async (c) => {
  const customerId = c.req.param('id');
  const db = c.get('db');

  // Drizzle Prepared Statement: Einmal kompiliert, spart CPU-Parsing im V8-Isolat
  const customerOrdersQuery = db
    .select()
    .from(orders)
    .where(eq(orders.customerId, sql.placeholder('custId')))
    .prepare();

  const customerOrders = await customerOrdersQuery.execute({ custId: customerId });

  return c.json({
    customerId,
    orders: customerOrders,
  }, 200, {
    'Cache-Control': 'public, max-age=30, s-maxage=60',
  });
});

export default app;