create-workerstack 0.1.0

package/template/src/database/db.ts

@@ -0,0 +1,111 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import type { PostgresJsDatabase } from 'drizzle-orm/postgres-js'
+import type { Logger as DrizzleLogger } from 'drizzle-orm/logger'
+import type { Context } from 'hono'
+import postgres from 'postgres'
+import { Logger } from '@/utils/logger'
+import * as schema from './schema'
+
+/**
+ * Database logger adapter that bridges Drizzle ORM logging with our structured logger
+ *
+ * Implements Drizzle's Logger interface and formats SQL queries for
+ * structured logging in Cloudflare Workers.
+ */
+class DatabaseLogger implements DrizzleLogger {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  /**
+   * Logs SQL queries executed by Drizzle ORM
+   *
+   * @param query - The SQL query string
+   * @param params - Query parameters
+   */
+  logQuery(query: string, params: unknown[]): void {
+    this.logger.debug('Database query executed', {
+      query,
+      params,
+      paramsCount: params.length,
+    })
+  }
+}
+
+/**
+ * Initialize Drizzle ORM with PostgreSQL via postgres.js
+ *
+ * This function creates a Drizzle instance with:
+ * - Automatic camelCase → snake_case column mapping
+ * - Full schema awareness for type-safe queries
+ * - PostgreSQL connection via postgres.js
+ * - Optional structured query logging
+ * - Prefetch disabled for Transaction pool mode compatibility (e.g. Supabase, PgBouncer)
+ *
+ * @param connectionString - PostgreSQL connection URL
+ * @param logger - Optional Logger instance for query logging
+ * @returns Drizzle database instance
+ *
+ * @example
+ * // Without logging
+ * const db = initDB(env.DATABASE_URL)
+ *
+ * // With logging
+ * const logger = createLogger({ context: 'database' })
+ * const db = initDB(env.DATABASE_URL, logger)
+ * const rows = await db.select().from(schema.exampleTable)
+ */
+export function initDB(
+  connectionString: string,
+  logger?: Logger
+): PostgresJsDatabase<typeof schema> {
+  const client = postgres(connectionString, { prepare: false })
+  return drizzle(client, {
+    schema,
+    casing: 'snake_case',
+    logger: logger ? new DatabaseLogger(logger) : undefined,
+  })
+}
+
+/**
+ * Type export for use in Hono context and other places
+ */
+export type Database = ReturnType<typeof initDB>
+
+/**
+ * Hono middleware that initializes database and adds it to context
+ *
+ * Automatically initializes Drizzle with PostgreSQL and
+ * attaches the database instance to the context. If a logger is available
+ * in the context, it will be used for query logging.
+ *
+ * Expects DATABASE_URL to be set in the environment bindings.
+ *
+ * @example
+ * app.use('*', loggerMiddleware())  // Set up logger first
+ * app.use('*', dbMiddleware())      // Then set up database with logging
+ *
+ * // Using raw Drizzle queries
+ * app.get('/api/example', async (c) => {
+ *   const rows = await c.var.db.select().from(schema.exampleTable)
+ *   return c.json(rows)
+ * })
+ *
+ */
+export function dbMiddleware() {
+  return async (c: Context, next: () => Promise<void>) => {
+    const logger = c.var.logger?.withContext({ component: 'database' })
+    const db = initDB(c.env.DATABASE_URL, logger)
+    c.set('db', db)
+    await next()
+  }
+}
+
+// Extend Hono's context type to include database
+declare module 'hono' {
+  interface ContextVariableMap {
+    db: Database
+  }
+}

package/template/src/database/schema.ts

@@ -0,0 +1 @@
+export * from './auth-schema'

package/template/src/index.tsx

@@ -0,0 +1,17 @@
+import { Hono } from 'hono'
+import { renderer } from './client'
+import { loggerMiddleware } from './utils/logger'
+import { dbMiddleware } from './database/db'
+import api from './api'
+
+const app = new Hono()
+
+app.use('/api/*', loggerMiddleware())
+app.use('/api/*', dbMiddleware())
+app.use(renderer)
+app.route('/api', api)
+app.get('*', (c) => {
+  return c.render(<div id="root"></div>)
+})
+
+export default app

package/template/src/lib/better-auth/index.ts

@@ -0,0 +1,28 @@
+import { betterAuth } from "better-auth";
+import { drizzleAdapter } from "better-auth/adapters/drizzle";
+import { betterAuthOptions } from './options';
+import type { Database } from "@/database/db";
+
+import * as schema from "@/database/schema";
+
+/**
+ * Better Auth Instance
+ */
+export const auth = (db: Database, env: CloudflareBindings) => {
+  return betterAuth({
+    ...betterAuthOptions(env),
+    database: drizzleAdapter(db, {
+        provider: "pg",
+        schema,
+    }),
+    baseURL: env.BETTER_AUTH_URL!,
+    secret: env.BETTER_AUTH_SECRET!,
+  });
+};
+
+type SessionResult = NonNullable<Awaited<ReturnType<ReturnType<typeof auth>["api"]["getSession"]>>>;
+
+export type AuthType = {
+  user: SessionResult["user"] | null
+  session: SessionResult["session"] | null
+}

package/template/src/lib/better-auth/options.ts

@@ -0,0 +1,29 @@
+import { createEmailService } from "@/services/email";
+import { BetterAuthOptions } from 'better-auth';
+import { admin } from "better-auth/plugins";
+
+export const betterAuthOptions = (env: CloudflareBindings): BetterAuthOptions => {
+  const emailService = createEmailService(env.RESEND_API_KEY);
+
+  return {
+  appName: 'YOUR_APP_NAME',
+  basePath: '/api/auth',
+
+  emailAndPassword: {
+    enabled: true,
+    requireEmailVerification: false,
+    sendResetPassword: async ({ user, url }) => {
+      await emailService.sendPasswordReset(user.email, url);
+    },
+  },
+  emailVerification: {
+    sendOnSignUp: true,
+    sendVerificationEmail: async ({ user, url }) => {
+      await emailService.sendVerificationEmail(user.email, url);
+    },
+  },
+  plugins: [
+    admin(),
+  ],
+};
+};

package/template/src/services/email.ts

@@ -0,0 +1,51 @@
+import { Resend } from "resend";
+
+// TODO: Update with your app name and email domain
+const FROM_EMAIL = "App <noreply@example.com>";
+
+export function createEmailService(apiKey: string) {
+  const resend = new Resend(apiKey);
+
+  return {
+    async sendPasswordReset(to: string, url: string) {
+      await resend.emails.send({
+        from: FROM_EMAIL,
+        to,
+        subject: "Reset your password",
+        html: `
+          <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h2 style="color: #1a1a2e;">Reset your password</h2>
+            <p>You requested a password reset. Click the button below to create a new password:</p>
+            <a href="${url}" style="display: inline-block; background-color: #7c3aed; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; margin: 16px 0;">
+              Reset Password
+            </a>
+            <p style="color: #666; font-size: 14px;">If you didn't request this change, you can safely ignore this email.</p>
+            <p style="color: #666; font-size: 14px;">This link expires in 1 hour.</p>
+            <hr style="border: none; border-top: 1px solid #eee; margin: 24px 0;" />
+            <p style="color: #999; font-size: 12px;">Sent by your app</p>
+          </div>
+        `,
+      });
+    },
+
+    async sendVerificationEmail(to: string, url: string) {
+      await resend.emails.send({
+        from: FROM_EMAIL,
+        to,
+        subject: "Verify your email",
+        html: `
+          <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <h2 style="color: #1a1a2e;">Verify your email</h2>
+            <p>Thanks for signing up! Click the button below to verify your email address:</p>
+            <a href="${url}" style="display: inline-block; background-color: #7c3aed; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; margin: 16px 0;">
+              Verify Email
+            </a>
+            <p style="color: #666; font-size: 14px;">If you didn't create an account, you can safely ignore this email.</p>
+            <hr style="border: none; border-top: 1px solid #eee; margin: 24px 0;" />
+            <p style="color: #999; font-size: 12px;">Sent by your app</p>
+          </div>
+        `,
+      });
+    },
+  };
+}

package/template/src/style.css

@@ -0,0 +1,45 @@
+*,
+*::before,
+*::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  background-color: #0A0A0F;
+  color: #F1F5F9;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  overflow-x: hidden;
+}
+
+a {
+  text-decoration: none;
+  color: inherit;
+}
+
+@keyframes float {
+  0%, 100% { transform: translateY(0px); }
+  50% { transform: translateY(-12px); }
+}
+
+@keyframes fadeInUp {
+  from {
+    opacity: 0;
+    transform: translateY(30px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 0.4; }
+  50% { opacity: 0.8; }
+}

package/template/src/utils/logger.ts

@@ -0,0 +1,211 @@
+import type { Context } from 'hono'
+
+/**
+ * Log levels following standard severity
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+/**
+ * Structured log entry compatible with Cloudflare Workers Logs
+ * All fields are automatically indexed for querying
+ */
+export interface LogEntry {
+  timestamp: string
+  level: LogLevel
+  message: string
+  requestId?: string
+  traceId?: string
+  [key: string]: unknown
+}
+
+/**
+ * Logger configuration options
+ */
+export interface LoggerConfig {
+  minLevel?: LogLevel
+  context?: Record<string, unknown>
+}
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+}
+
+/**
+ * Structured JSON logger for Cloudflare Workers
+ *
+ * Outputs logs in JSON format for automatic indexing by Workers Logs.
+ * Supports contextual metadata, request correlation, and flexible log levels.
+ *
+ * @example
+ * const logger = createLogger({ requestId: 'abc-123' })
+ * logger.info('User logged in', { userId: '456' })
+ * // Output: {"timestamp":"2025-12-08T...","level":"info","message":"User logged in","requestId":"abc-123","userId":"456"}
+ */
+export class Logger {
+  private context: Record<string, unknown>
+  private minLevel: number
+
+  constructor(config: LoggerConfig = {}) {
+    this.context = config.context || {}
+    this.minLevel = LOG_LEVELS[config.minLevel || 'info']
+  }
+
+  /**
+   * Creates a child logger with additional context
+   * The new context is merged with the parent context
+   */
+  withContext(additionalContext: Record<string, unknown>): Logger {
+    return new Logger({
+      minLevel: this.getMinLevelName(),
+      context: { ...this.context, ...additionalContext },
+    })
+  }
+
+  /**
+   * Logs a message at the specified level
+   */
+  log(level: LogLevel, message: string, context?: Record<string, unknown>): void {
+    if (LOG_LEVELS[level] < this.minLevel) {
+      return
+    }
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      ...this.context,
+      ...context,
+    }
+
+    // Truncate if exceeds Cloudflare's 256 KB limit
+    const logString = JSON.stringify(entry)
+    if (logString.length > 256000) {
+      console.log(
+        JSON.stringify({
+          ...entry,
+          message: entry.message.substring(0, 1000) + '... [truncated]',
+          _truncated: true,
+          _originalSize: logString.length,
+        })
+      )
+    } else {
+      console.log(logString)
+    }
+  }
+
+  /**
+   * Log debug message (lowest priority)
+   */
+  debug(message: string, context?: Record<string, unknown>): void {
+    this.log('debug', message, context)
+  }
+
+  /**
+   * Log info message (normal priority)
+   */
+  info(message: string, context?: Record<string, unknown>): void {
+    this.log('info', message, context)
+  }
+
+  /**
+   * Log warning message (elevated priority)
+   */
+  warn(message: string, context?: Record<string, unknown>): void {
+    this.log('warn', message, context)
+  }
+
+  /**
+   * Log error message (highest priority)
+   * Automatically extracts stack trace from Error objects
+   */
+  error(message: string, context?: Record<string, unknown>): void {
+    const errorContext = { ...context }
+
+    // Extract error details if an Error object is provided
+    if (context?.error instanceof Error) {
+      errorContext.errorName = context.error.name
+      errorContext.errorMessage = context.error.message
+      errorContext.errorStack = context.error.stack
+      delete errorContext.error
+    }
+
+    this.log('error', message, errorContext)
+  }
+
+  private getMinLevelName(): LogLevel {
+    const entries = Object.entries(LOG_LEVELS)
+    const found = entries.find(([, value]) => value === this.minLevel)
+    return (found?.[0] as LogLevel) || 'info'
+  }
+}
+
+/**
+ * Creates a new logger instance with optional context
+ */
+export function createLogger(context?: Record<string, unknown>, minLevel: LogLevel = 'info'): Logger {
+  return new Logger({ context, minLevel })
+}
+
+/**
+ * Hono middleware that adds logger to context and logs requests
+ *
+ * Automatically logs request start/end with timing and status code.
+ * Attaches logger instance to c.var.logger for use in handlers.
+ *
+ * @example
+ * app.use('*', loggerMiddleware())
+ *
+ * app.get('/api/users', (c) => {
+ *   c.var.logger.info('Fetching users')
+ *   return c.json({ users: [] })
+ * })
+ */
+export function loggerMiddleware() {
+  return async (c: Context, next: () => Promise<void>) => {
+    const requestId = crypto.randomUUID()
+    // Use performance.now() for measuring operation duration
+    // (more idiomatic than Date.now() for performance timing)
+    const startTime = performance.now()
+
+    // Create logger with request context
+    const logger = createLogger({
+      requestId,
+      method: c.req.method,
+      path: c.req.path,
+      userAgent: c.req.header('user-agent'),
+      ip: c.req.header('cf-connecting-ip'),
+    }, 'debug')
+
+    // Attach logger to context
+    c.set('logger', logger)
+
+    logger.info('Request started')
+
+    try {
+      await next()
+
+      const duration = performance.now() - startTime
+      logger.info('Request completed', {
+        status: c.res.status,
+        durationMs: duration,
+      })
+    } catch (error) {
+      const duration = performance.now() - startTime
+      logger.error('Request failed', {
+        error,
+        durationMs: duration,
+      })
+      throw error
+    }
+  }
+}
+
+// Extend Hono's context type to include logger
+declare module 'hono' {
+  interface ContextVariableMap {
+    logger: Logger
+  }
+}

package/template/src/utils/noCache.ts

@@ -0,0 +1,20 @@
+import { MiddlewareHandler } from 'hono'
+
+/**
+ * Middleware to disable Cloudflare caching for API routes
+ * 
+ * Sets appropriate headers to prevent caching at CDN and browser levels:
+ * - Cache-Control: Prevents caching by proxies and browsers
+ * - Pragma: HTTP/1.0 backward compatibility
+ * - Expires: Sets immediate expiration
+ */
+export const noCacheMiddleware = (): MiddlewareHandler => {
+  return async (c, next) => {
+    await next()
+    
+    // Prevent caching by Cloudflare and browsers
+    c.header('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate')
+    c.header('Pragma', 'no-cache')
+    c.header('Expires', '0')
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["vite/client", "./worker-configuration.d.ts", "bun-types"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "hono/jsx",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "exclude": ["src/client", "src/client.tsx"]
+}

package/template/vite.config.ts

@@ -0,0 +1,34 @@
+import { cloudflare } from '@cloudflare/vite-plugin'
+import { defineConfig } from 'vite'
+import ssrPlugin from 'vite-ssr-components/plugin'
+import react from '@vitejs/plugin-react'
+
+import path from 'path'
+
+export default defineConfig({
+  server: {
+    port: 5000,
+    host: '0.0.0.0',
+    allowedHosts: true,
+    watch: {
+      ignored: ['**/.cache/**', '**/node_modules/**'],
+    },
+  },
+  cacheDir: '/tmp/vite-cache',
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  },
+  plugins: [
+    cloudflare(),
+    ssrPlugin({
+      entry: {
+        target: 'src/client.tsx',
+      },
+    }),
+    react({
+      include: /src\/client\/.*\.tsx?$/,
+    }),
+  ],
+})