// Shared types between frontend and backend
export interface User {
  id: string
  email: string
  profile: {
    firstName: string
    lastName: string
    avatar?: string
    bio?: string
  }
  preferences: UserPreferences
  roles: ('user' | 'admin' | 'moderator')[]
  metadata: {
    createdAt: Date
    updatedAt: Date
    lastLoginAt?: Date
    emailVerifiedAt?: Date
  }
}
export interface UserPreferences {
  theme: 'light' | 'dark' | 'auto'
  notifications: {
    email: boolean
    push: boolean
    sms: boolean
  }
  privacy: {
    profileVisible: boolean
    activityVisible: boolean
  }
}
export interface ApiResponse {
  data: T
  status: 'success' | 'error'
  message?: string
  meta?: {
    pagination?: {
      page: number
      limit: number
      total: number
      hasMore: boolean
    }
    timing?: {
      queryTime: number
      totalTime: number
    }
  }
}
export type ApiError = {
  status: 'error'
  error: {
    code: string
    message: string
    details?: Record
  }
}

// Drizzle schema definition
import { pgTable, text, timestamp, jsonb, boolean, index } from 'drizzle-orm/pg-core'
import { relations } from 'drizzle-orm'
export const users = pgTable('users', {
  id: text('id').primaryKey(),
  email: text('email').notNull().unique(),
  firstName: text('first_name').notNull(),
  lastName: text('last_name').notNull(),
  avatar: text('avatar'),
  bio: text('bio'),
  preferences: jsonb('preferences').$type().notNull().default({}),
  roles: text('roles').array().notNull().default(['user']),
  emailVerified: boolean('email_verified').notNull().default(false),
  createdAt: timestamp('created_at').notNull().defaultNow(),
  updatedAt: timestamp('updated_at').notNull().defaultNow(),
  lastLoginAt: timestamp('last_login_at')
}, (table) => ({
  emailIdx: index('email_idx').on(table.email),
  createdAtIdx: index('created_at_idx').on(table.createdAt)
}))
export const posts = pgTable('posts', {
  id: text('id').primaryKey(),
  authorId: text('author_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
  title: text('title').notNull(),
  content: text('content').notNull(),
  excerpt: text('excerpt'),
  slug: text('slug').notNull().unique(),
  status: text('status', { enum: ['draft', 'published', 'archived'] }).notNull().default('draft'),
  tags: text('tags').array().notNull().default([]),
  metadata: jsonb('metadata').$type(),
  publishedAt: timestamp('published_at'),
  createdAt: timestamp('created_at').notNull().defaultNow(),
  updatedAt: timestamp('updated_at').notNull().defaultNow()
}, (table) => ({
  slugIdx: index('slug_idx').on(table.slug),
  authorIdx: index('author_idx').on(table.authorId),
  statusIdx: index('status_idx').on(table.status)
}))
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts)
}))
export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id]
  })
}))
// Inferred types from schema
export type User = typeof users.$inferSelect
export type NewUser = typeof users.$inferInsert
export type Post = typeof posts.$inferSelect
export type NewPost = typeof posts.$inferInsert

// Modern Express.js with TypeScript and validation
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'
import { db } from './lib/database'
import { users, posts } from './schema'
import { eq, and, desc } from 'drizzle-orm'
const app = new Hono()
// Validation schemas
const createUserSchema = z.object({
  email: z.string().email(),
  firstName: z.string().min(2).max(50),
  lastName: z.string().min(2).max(50),
  avatar: z.string().url().optional(),
  bio: z.string().max(500).optional(),
  preferences: z.object({
    theme: z.enum(['light', 'dark', 'auto']).default('auto'),
    notifications: z.object({
      email: z.boolean().default(true),
      push: z.boolean().default(true),
      sms: z.boolean().default(false)
    })
  }).optional()
})
const updateUserSchema = createUserSchema.partial()
const createPostSchema = z.object({
  title: z.string().min(1).max(200),
  content: z.string().min(1),
  excerpt: z.string().max(300).optional(),
  tags: z.array(z.string()).max(10).optional(),
  status: z.enum(['draft', 'published']).default('draft')
})
// User endpoints
app.post('/api/users', zValidator('json', createUserSchema), async (c) => {
  const validatedData = c.req.valid('json')
  try {
    const [user] = await db.insert(users).values({
      id: crypto.randomUUID(),
      ...validatedData,
      preferences: validatedData.preferences || {
        theme: 'auto',
        notifications: { email: true, push: true, sms: false }
      }
    }).returning()
    const response: ApiResponse = {
      data: user,
      status: 'success'
    }
    return c.json(response, 201)
  } catch (error) {
    const errorResponse: ApiError = {
      status: 'error',
      error: {
        code: 'USER_CREATION_FAILED',
        message: 'Failed to create user',
        details: error instanceof Error ? { message: error.message } : undefined
      }
    }
    return c.json(errorResponse, 400)
  }
})
app.get('/api/users/:id', async (c) => {
  const userId = c.req.param('id')
  const [user] = await db.select()
    .from(users)
    .where(eq(users.id, userId))
    .limit(1)
  if (!user) {
    return c.json({
      status: 'error',
      error: {
        code: 'USER_NOT_FOUND',
        message: 'User not found'
      }
    }, 404)
  }
  return c.json>({
    data: user,
    status: 'success'
  })
})
app.patch('/api/users/:id', zValidator('json', updateUserSchema), async (c) => {
  const userId = c.req.param('id')
  const updates = c.req.valid('json')
  const [updatedUser] = await db.update(users)
    .set({
      ...updates,
      updatedAt: new Date()
    })
    .where(eq(users.id, userId))
    .returning()
  if (!updatedUser) {
    return c.json({
      status: 'error',
      error: {
        code: 'USER_NOT_FOUND',
        message: 'User not found'
      }
    }, 404)
  }
  return c.json>({
    data: updatedUser,
    status: 'success'
  })
})
// Post endpoints with author population
app.get('/api/posts', async (c) => {
  const page = parseInt(c.req.query('page') || '1')
  const limit = parseInt(c.req.query('limit') || '10')
  const offset = (page - 1) * limit
  const postsWithAuthors = await db.select({
    post: posts,
    author: users
  })
    .from(posts)
    .leftJoin(users, eq(posts.authorId, users.id))
    .where(eq(posts.status, 'published'))
    .orderBy(desc(posts.publishedAt))
    .limit(limit)
    .offset(offset)
  const [{ count }] = await db.select({ count: sqlcount(*) })
    .from(posts)
    .where(eq(posts.status, 'published'))
  return c.json>({
    data: postsWithAuthors,
    status: 'success',
    meta: {
      pagination: {
        page,
        limit,
        total: count,
        hasMore: offset + limit < count
      }
    }
  })
})
app.post('/api/posts', zValidator('json', createPostSchema), async (c) => {
  const data = c.req.valid('json')
  const userId = c.get('userId') // From auth middleware
  const slug = data.title.toLowerCase()
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-|-$/g, '')
  const [post] = await db.insert(posts).values({
    id: crypto.randomUUID(),
    authorId: userId,
    ...data,
    slug,
    publishedAt: data.status === 'published' ? new Date() : null
  }).returning()
  return c.json>({
    data: post,
    status: 'success'
  }, 201)
})

// Type-safe API client
import type { ApiResponse, ApiError, User, Post } from '@/types'
class ApiClient {
  private baseUrl: string
  constructor(baseUrl: string = '/api') {
    this.baseUrl = baseUrl
  }
  private async request(
    endpoint: string,
    options?: RequestInit
  ): Promise> {
    const response = await fetch(${this.baseUrl}${endpoint}, {
      ...options,
      headers: {
        'Content-Type': 'application/json',
        ...options?.headers
      }
    })
    if (!response.ok) {
      const error: ApiError = await response.json()
      throw new Error(error.error.message)
    }
    return response.json()
  }
  // User methods
  async getUser(id: string) {
    return this.request(/users/${id})
  }
  async createUser(data: CreateUserInput) {
    return this.request('/users', {
      method: 'POST',
      body: JSON.stringify(data)
    })
  }
  async updateUser(id: string, data: UpdateUserInput) {
    return this.request(/users/${id}, {
      method: 'PATCH',
      body: JSON.stringify(data)
    })
  }
  // Post methods
  async getPosts(page = 1, limit = 10) {
    return this.request(/posts?page=${page}&limit=${limit})
  }
  async createPost(data: CreatePostInput) {
    return this.request('/posts', {
      method: 'POST',
      body: JSON.stringify(data)
    })
  }
}
export const apiClient = new ApiClient()
// React Query hooks
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
export function useUser(userId: string) {
  return useQuery({
    queryKey: ['users', userId],
    queryFn: () => apiClient.getUser(userId),
    staleTime: 5 * 60 * 1000, // 5 minutes
    retry: 2
  })
}
export function useCreateUser() {
  const queryClient = useQueryClient()
  return useMutation({
    mutationFn: (data: CreateUserInput) => apiClient.createUser(data),
    onSuccess: (response) => {
      queryClient.invalidateQueries({ queryKey: ['users'] })
      queryClient.setQueryData(['users', response.data.id], response)
    }
  })
}
export function usePosts(page = 1, limit = 10) {
  return useQuery({
    queryKey: ['posts', page, limit],
    queryFn: () => apiClient.getPosts(page, limit),
    staleTime: 2 * 60 * 1000,
    placeholderData: (previousData) => previousData
  })
}
export function useCreatePost() {
  const queryClient = useQueryClient()
  return useMutation({
    mutationFn: (data: CreatePostInput) => apiClient.createPost(data),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['posts'] })
    }
  })
}

// Fully type-safe React components
'use client'
import { useUser, useUpdateUser } from '@/hooks/api'
import { useState } from 'react'
interface UserProfileProps {
  userId: string
}
export function UserProfile({ userId }: UserProfileProps) {
  const { data: response, isLoading, error } = useUser(userId)
  const updateUser = useUpdateUser()
  const [isEditing, setIsEditing] = useState(false)
  if (isLoading) {
    return 
  }
  if (error) {
    return (
      

        
Failed to load user profile
      
    )
  }

  const user = response!.data
  const handleSave = async (updates: Partial) => {
    try {
      await updateUser.mutateAsync({ id: userId, data: updates })
      setIsEditing(false)
    } catch (error) {
      console.error('Failed to update user:', error)
    }
  }
  return (
    

      

        

          {user.profile.avatar && (
            ${user.profile.firstName} ${user.profile.lastName}}
              className="w-20 h-20 rounded-full"
            />
          )}
          

            

              {user.profile.firstName} {user.profile.lastName}
            
            
{user.email}
          
        

        {isEditing ? (
           setIsEditing(false)} />
        ) : (
          <>
            {user.profile.bio && (
              
{user.profile.bio}
            )}
             setIsEditing(true)}
              className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
            >
              Edit Profile
            
          
        )}
      
    
  )
}

// Comprehensive integration tests
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { testClient } from './test-utils'
import { db } from '@/lib/database'
import { users, posts } from '@/schema'
describe('User and Post Integration', () => {
  let testUserId: string
  beforeAll(async () => {
    // Set up test database
    await db.delete(posts)
    await db.delete(users)
  })
  afterAll(async () => {
    // Clean up
    await db.delete(posts)
    await db.delete(users)
  })
  it('should create user, post, and retrieve with author', async () => {
    // Create user
    const createUserResponse = await testClient.post('/api/users', {
      json: {
        email: 'test@example.com',
        firstName: 'Test',
        lastName: 'User'
      }
    })
    expect(createUserResponse.status).toBe(201)
    const userResponse = await createUserResponse.json()
    testUserId = userResponse.data.id
    // Create post
    const createPostResponse = await testClient.post('/api/posts', {
      json: {
        title: 'Test Post',
        content: 'This is a test post',
        status: 'published'
      },
      headers: {
        'x-user-id': testUserId
      }
    })
    expect(createPostResponse.status).toBe(201)
    // Retrieve posts with author
    const postsResponse = await testClient.get('/api/posts')
    const postsData = await postsResponse.json()
    expect(postsData.data).toHaveLength(1)
    expect(postsData.data[0].author.email).toBe('test@example.com')
  })
})

// End-to-end testing from UI to database
import { test, expect } from '@playwright/test'
test.describe('User Profile Flow', () => {
  test('should create user and display profile', async ({ page }) => {
    // Navigate to signup
    await page.goto('/signup')
    // Fill form
    await page.fill('input[name="email"]', 'newuser@example.com')
    await page.fill('input[name="firstName"]', 'New')
    await page.fill('input[name="lastName"]', 'User')
    await page.fill('input[name="password"]', 'SecurePassword123!')
    // Submit
    await page.click('button[type="submit"]')
    // Wait for redirect to profile
    await page.waitForURL(/\/profile/)
    // Verify profile data
    await expect(page.locator('h1')).toContainText('New User')
    await expect(page.locator('text=newuser@example.com')).toBeVisible()
    // Edit profile
    await page.click('button:has-text("Edit Profile")')
    await page.fill('textarea[name="bio"]', 'This is my bio')
    await page.click('button:has-text("Save")')
    // Verify update
    await expect(page.locator('text=This is my bio')).toBeVisible()
  })
})

Multi-stage Docker build for full-stack app
FROM node:20-alpine AS base
Dependencies stage
FROM base AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
Build stage
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
Build frontend and backend
RUN npm run build
Production stage
FROM base AS runner
WORKDIR /app
ENV NODE_ENV production
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 appuser
Copy necessary files
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/public ./public
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./package.json
USER appuser
EXPOSE 3000
CMD ["node", "dist/server.js"]

name: Full-Stack CI/CD
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_PASSWORD: postgres
          POSTGRES_DB: testdb
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - name: Install dependencies
        run: npm ci
      - name: Run linter
        run: npm run lint
      - name: Run type check
        run: npm run type-check
      - name: Run unit tests
        run: npm run test:unit
      - name: Run integration tests
        run: npm run test:integration
        env:
          DATABASE_URL: postgresql://postgres:postgres@localhost:5432/testdb
      - name: Run E2E tests
        run: npm run test:e2e
      - name: Build
        run: npm run build
  deploy:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to production
        run: |
          # Deploy steps
          npm run deploy:production

// Edge caching with Vercel or Cloudflare
export const config = {
  runtime: 'edge'
}
export default async function handler(req: Request) {
  const url = new URL(req.url)
  const userId = url.searchParams.get('userId')
  // Cache configuration
  const cacheControl = {
    public: 'public',
    maxAge: 60, // 1 minute
    staleWhileRevalidate: 300, // 5 minutes
    staleIfError: 86400 // 24 hours
  }
  try {
    const user = await getUser(userId!)
    return new Response(JSON.stringify(user), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': ${cacheControl.public}, max-age=${cacheControl.maxAge}, stale-while-revalidate=${cacheControl.staleWhileRevalidate}
      }
    })
  } catch (error) {
    return new Response(JSON.stringify({ error: 'User not found' }), {
      status: 404,
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': public, max-age=60, stale-if-error=${cacheControl.staleIfError}
      }
    })
  }
}