# docker-compose.yml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
      - "24678:24678"   # Vite HMR WebSocket ポート
    volumes:
      # ソースコードをバインドマウント
      - .:/app
      # node_modules はボリュームで分離 (パフォーマンス)
      - node_modules:/app/node_modules
    environment:
      # Vite: コンテナ外からの HMR 接続を許可
      VITE_HMR_HOST: localhost
      VITE_HMR_PORT: 24678
      # Next.js: ファイル監視に polling を使用
      WATCHPACK_POLLING: "true"
      # Chokidar: polling fallback
      CHOKIDAR_USEPOLLING: "true"
    command: npm run dev
 
volumes:
  node_modules:

# Dockerfile.dev
FROM node:20-alpine
 
WORKDIR /app
 
# 依存関係のみ先にコピー (キャッシュ活用)
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile
 
# ソースコードはバインドマウントされるため COPY 不要
# COPY . . ← 開発用では不要
 
EXPOSE 3000
 
CMD ["pnpm", "dev"]

# docker-compose.yml
services:
  api:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    environment:
      PYTHONDONTWRITEBYTECODE: "1"
      PYTHONUNBUFFERED: "1"
    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload --reload-dir /app/src

# Dockerfile.dev (Python)
FROM python:3.12-slim
 
WORKDIR /app
 
# システム依存パッケージのインストール
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*
 
# 依存関係のインストール
COPY requirements.txt requirements-dev.txt ./
RUN pip install --no-cache-dir -r requirements-dev.txt
 
# ソースコードはバインドマウントで注入
EXPOSE 8000
 
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

# docker-compose.yml
services:
  api:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "8080:8080"
    volumes:
      - .:/app
    command: air -c .air.toml

# .air.toml
root = "."
tmp_dir = "tmp"
 
[build]
cmd = "go build -o ./tmp/main ./cmd/server"
bin = "./tmp/main"
full_bin = "./tmp/main"
include_ext = ["go", "tpl", "tmpl", "html"]
exclude_dir = ["assets", "tmp", "vendor", "node_modules"]
delay = 1000

# Dockerfile.dev (Go)
FROM golang:1.22-alpine
 
WORKDIR /app
 
# Air (ホットリロードツール) のインストール
RUN go install github.com/air-verse/air@latest
 
# 依存関係のダウンロード
COPY go.mod go.sum ./
RUN go mod download
 
EXPOSE 8080
 
CMD ["air", "-c", ".air.toml"]

# docker-compose.yml
services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - bundle_cache:/usr/local/bundle
    environment:
      RAILS_ENV: development
      DATABASE_URL: postgresql://postgres:postgres@db:5432/myapp_dev
    depends_on:
      db:
        condition: service_healthy
    command: bin/rails server -b 0.0.0.0
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - pgdata:/var/lib/postgresql/data
 
volumes:
  bundle_cache:
  pgdata:

# docker-compose.yml (watch 機能)
services:
  app:
    build: .
    ports:
      - "3000:3000"
    develop:
      watch:
        # ソースファイル変更 → コンテナ内に同期
        - action: sync
          path: ./src
          target: /app/src
          ignore:
            - node_modules/
            - "**/*.test.ts"
 
        # package.json 変更 → rebuild
        - action: rebuild
          path: ./package.json
 
        # 設定ファイル変更 → コンテナ再起動
        - action: sync+restart
          path: ./config
          target: /app/config

# watch モードで起動
docker compose watch
 
# 通常起動 + watch
docker compose up -d && docker compose watch
 
# 特定サービスのみ watch
docker compose watch app

# docker-compose.yml - フルスタックアプリの Watch 設定
services:
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    develop:
      watch:
        # TypeScript ソースの同期
        - action: sync
          path: ./frontend/src
          target: /app/src
          ignore:
            - "**/*.test.tsx"
            - "**/*.spec.tsx"
            - "**/__tests__/"
            - "**/__mocks__/"
 
        # 静的アセットの同期
        - action: sync
          path: ./frontend/public
          target: /app/public
 
        # package.json / lockfile 変更 → 再ビルド
        - action: rebuild
          path: ./frontend/package.json
        - action: rebuild
          path: ./frontend/pnpm-lock.yaml
 
        # Vite 設定変更 → 再起動
        - action: sync+restart
          path: ./frontend/vite.config.ts
          target: /app/vite.config.ts
 
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    develop:
      watch:
        - action: sync
          path: ./backend/src
          target: /app/src
 
        - action: sync+restart
          path: ./backend/config
          target: /app/config
 
        - action: rebuild
          path: ./backend/package.json

# docker-compose.yml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
      - "9229:9229"     # Node.js デバッガポート
    volumes:
      - .:/app
      - node_modules:/app/node_modules
    command: >
      node --inspect=0.0.0.0:9229 node_modules/.bin/next dev
    # または
    # command: node --inspect=0.0.0.0:9229 src/index.ts

// .vscode/launch.json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Docker: Attach to Node",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/app",
      "restart": true,
      "skipFiles": ["<node_internals>/**"]
    },
    {
      "name": "Docker: Debug Tests",
      "type": "node",
      "request": "attach",
      "port": 9230,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/app",
      "restart": true
    }
  ]
}

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "8000:8000"
      - "5678:5678"     # debugpy ポート
    volumes:
      - .:/app
    command: >
      python -m debugpy --listen 0.0.0.0:5678 --wait-for-client
      -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload

// .vscode/launch.json (Python)
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Docker: Attach to Python",
      "type": "debugpy",
      "request": "attach",
      "connect": {
        "host": "localhost",
        "port": 5678
      },
      "pathMappings": [
        {
          "localRoot": "${workspaceFolder}",
          "remoteRoot": "/app"
        }
      ]
    }
  ]
}

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile.debug
    ports:
      - "8080:8080"
      - "2345:2345"     # Delve デバッガポート
    volumes:
      - .:/app
    security_opt:
      - "seccomp:unconfined"   # Delve が ptrace を使用するために必要
    command: >
      dlv debug ./cmd/server --headless --listen=:2345
      --api-version=2 --accept-multiclient --continue

# Dockerfile.debug (Go)
FROM golang:1.22
 
WORKDIR /app
 
# Delve デバッガのインストール
RUN go install github.com/go-delve/delve/cmd/dlv@latest
 
COPY go.mod go.sum ./
RUN go mod download
 
COPY . .
 
EXPOSE 8080 2345
 
CMD ["dlv", "debug", "./cmd/server", "--headless", "--listen=:2345", "--api-version=2", "--accept-multiclient", "--continue"]

// .vscode/launch.json (Go)
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Docker: Attach to Go (Delve)",
      "type": "go",
      "request": "attach",
      "mode": "remote",
      "remotePath": "/app",
      "port": 2345,
      "host": "127.0.0.1",
      "showLog": true
    }
  ]
}

# デバッガポートが開いているか確認
docker compose exec app sh -c "netstat -tlnp | grep 9229"
 
# デバッグモードでプロセスが起動しているか確認
docker compose exec app ps aux | grep inspect
 
# ネットワーク接続テスト（ホスト側から）
nc -zv localhost 9229
 
# コンテナのログでデバッグ情報を確認
docker compose logs -f app | grep -i "debugger"

# docker-compose.yml
services:
  app:
    build: .
    depends_on:
      db:
        condition: service_healthy
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_dev
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
 
  # テストランナー (プロファイル)
  test:
    profiles: ["test"]
    build:
      context: .
      target: test
    environment:
      NODE_ENV: test
      DATABASE_URL: postgresql://postgres:postgres@db-test:5432/myapp_test
    depends_on:
      db-test:
        condition: service_healthy
    command: npm run test:ci
 
  # テスト専用 DB
  db-test:
    profiles: ["test"]
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_test
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    # tmpfs でテスト高速化 (永続化不要)
    tmpfs:
      - /var/lib/postgresql/data

# テスト実行
docker compose --profile test run --rm test
 
# テスト後のクリーンアップ
docker compose --profile test down -v
 
# E2E テスト (ブラウザ付き)
docker compose --profile e2e run --rm e2e-tests
 
# カバレッジレポート出力
docker compose --profile test run --rm \
  -v ./coverage:/app/coverage \
  test npm run test:coverage
 
# 特定のテストファイルのみ実行
docker compose --profile test run --rm \
  test npm test -- --testPathPattern="auth"
 
# ウォッチモードでテスト実行（開発中）
docker compose --profile test run --rm \
  test npm test -- --watch

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      db:
        condition: service_healthy
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_test
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    tmpfs:
      - /var/lib/postgresql/data
 
  # Playwright E2E テスト
  e2e:
    profiles: ["e2e"]
    image: mcr.microsoft.com/playwright:v1.42.0-jammy
    working_dir: /app
    volumes:
      - .:/app
      - node_modules:/app/node_modules
      - ./test-results:/app/test-results
      - ./playwright-report:/app/playwright-report
    environment:
      BASE_URL: http://app:3000
      CI: "true"
    depends_on:
      app:
        condition: service_healthy
    command: npx playwright test --reporter=html
    networks:
      - default
 
volumes:
  node_modules:

services:
  # Cypress E2E テスト
  cypress:
    profiles: ["e2e"]
    image: cypress/included:13.6.0
    working_dir: /e2e
    volumes:
      - ./cypress:/e2e/cypress
      - ./cypress.config.ts:/e2e/cypress.config.ts
      - ./cypress/screenshots:/e2e/cypress/screenshots
      - ./cypress/videos:/e2e/cypress/videos
    environment:
      CYPRESS_baseUrl: http://app:3000
      CYPRESS_RECORD_KEY: ${CYPRESS_RECORD_KEY:-}
    depends_on:
      app:
        condition: service_healthy
    command: cypress run --browser chrome

services:
  # テスト用 DB プール（各ワーカーに専用 DB を割り当て）
  db-test:
    profiles: ["test"]
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_test
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    tmpfs:
      - /var/lib/postgresql/data
    volumes:
      - ./scripts/create-test-databases.sh:/docker-entrypoint-initdb.d/create-test-databases.sh

#!/bin/bash
# scripts/create-test-databases.sh
# テストワーカー用のデータベースを事前作成
 
for i in $(seq 1 4); do
  psql -U postgres -c "CREATE DATABASE myapp_test_${i};"
done
echo "Test databases created: myapp_test_1 through myapp_test_4"

# .github/workflows/ci.yml
name: CI
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
 
jobs:
  test:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
 
      # Docker Compose は GitHub Actions に標準搭載
      - name: Start services
        run: docker compose -f docker-compose.ci.yml up -d
 
      - name: Wait for DB
        run: |
          until docker compose -f docker-compose.ci.yml exec -T db \
            pg_isready -U postgres; do
            echo "Waiting for DB..."
            sleep 2
          done
 
      - name: Run migrations
        run: docker compose -f docker-compose.ci.yml exec -T app \
          npx prisma migrate deploy
 
      - name: Run tests
        run: docker compose -f docker-compose.ci.yml exec -T app \
          npm run test:ci
 
      - name: Run lint
        run: docker compose -f docker-compose.ci.yml exec -T app \
          npm run lint
 
      - name: Collect coverage
        run: docker compose -f docker-compose.ci.yml exec -T app \
          npm run test:coverage
 
      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage/lcov.info
 
      - name: Cleanup
        if: always()
        run: docker compose -f docker-compose.ci.yml down -v

# docker-compose.ci.yml
services:
  app:
    build:
      context: .
      target: test       # テストステージを使用
    environment:
      NODE_ENV: test
      DATABASE_URL: postgresql://postgres:postgres@db:5432/myapp_test
      REDIS_URL: redis://redis:6379
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - coverage:/app/coverage
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_test
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 3s
      timeout: 3s
      retries: 10
    tmpfs:
      - /var/lib/postgresql/data   # CI ではメモリ上で高速化
 
  redis:
    image: redis:7-alpine
    tmpfs:
      - /data
 
volumes:
  coverage:

# .gitlab-ci.yml
stages:
  - test
  - build
  - deploy
 
variables:
  DOCKER_HOST: tcp://docker:2376
  DOCKER_TLS_CERTDIR: "/certs"
  COMPOSE_PROJECT_NAME: "ci-${CI_PIPELINE_ID}"
 
test:
  stage: test
  image: docker:24.0
  services:
    - docker:24.0-dind
  before_script:
    - apk add --no-cache docker-compose
  script:
    - docker compose -f docker-compose.ci.yml up -d
    - docker compose -f docker-compose.ci.yml exec -T app npm run test:ci
    - docker compose -f docker-compose.ci.yml exec -T app npm run lint
  after_script:
    - docker compose -f docker-compose.ci.yml down -v
  artifacts:
    reports:
      junit: test-results/junit.xml
    paths:
      - coverage/
    expire_in: 7 days

# .github/workflows/ci.yml (キャッシュ最適化版)
name: CI with Cache
 
on:
  pull_request:
    branches: [main]
 
jobs:
  test:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
 
      # Docker レイヤーキャッシュ
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
 
      - name: Cache Docker layers
        uses: actions/cache@v4
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ hashFiles('**/Dockerfile', '**/package-lock.json') }}
          restore-keys: |
            ${{ runner.os }}-buildx-
 
      # キャッシュを活用してビルド
      - name: Build test image
        run: |
          docker buildx build \
            --cache-from type=local,src=/tmp/.buildx-cache \
            --cache-to type=local,dest=/tmp/.buildx-cache-new,mode=max \
            --target test \
            --load \
            -t myapp:test \
            .
 
      - name: Start services
        run: docker compose -f docker-compose.ci.yml up -d
 
      - name: Run tests
        run: docker compose -f docker-compose.ci.yml exec -T app npm run test:ci
 
      # キャッシュのローテーション（サイズ肥大防止）
      - name: Rotate cache
        run: |
          rm -rf /tmp/.buildx-cache
          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
 
      - name: Cleanup
        if: always()
        run: docker compose -f docker-compose.ci.yml down -v

# .github/workflows/e2e.yml
name: E2E Tests
 
on:
  pull_request:
    branches: [main]
 
jobs:
  e2e:
    runs-on: ubuntu-latest
    timeout-minutes: 30
 
    steps:
      - uses: actions/checkout@v4
 
      - name: Start application
        run: docker compose -f docker-compose.ci.yml up -d
 
      - name: Wait for application to be ready
        run: |
          timeout 60 bash -c 'until curl -sf http://localhost:3000/health; do sleep 2; done'
 
      - name: Run E2E tests
        run: |
          docker compose --profile e2e run --rm \
            -e CI=true \
            -e BASE_URL=http://app:3000 \
            e2e
 
      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 30
 
      - name: Upload screenshots
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: test-screenshots
          path: test-results/
          retention-days: 7
 
      - name: Cleanup
        if: always()
        run: docker compose -f docker-compose.ci.yml --profile e2e down -v

// Docker Desktop settings.json
{
  "filesharingDirectories": [
    "/Users/<username>/projects"
  ],
  "memoryMiB": 8192,
  "cpus": 4,
  "diskSizeMiB": 65536,
  "swapMiB": 1024,
  "useVirtualizationFrameworkVirtioFS": true,
  "useVirtualizationFrameworkRosetta": true
}

# docker-compose.yml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    volumes:
      # ソースコードはバインドマウント
      - .:/app
      # node_modules は名前付きボリュームで分離
      # → macOS のファイルI/Oボトルネックを回避
      - node_modules:/app/node_modules
      # .next キャッシュも分離（Next.js の場合）
      - next_cache:/app/.next
    # ボリュームの初期化（コンテナ起動時に依存関係をインストール）
    entrypoint: >
      sh -c "
        if [ ! -d /app/node_modules/.package-lock.json ]; then
          echo 'Installing dependencies...'
          pnpm install --frozen-lockfile
        fi
        exec pnpm dev
      "
 
volumes:
  node_modules:
  next_cache:

# Dockerfile (マルチステージ + キャッシュ)
FROM node:20-alpine AS base
WORKDIR /app
 
# 依存関係レイヤー (変更頻度: 低)
FROM base AS deps
COPY package.json pnpm-lock.yaml ./
RUN --mount=type=cache,target=/root/.local/share/pnpm/store \
    corepack enable && pnpm install --frozen-lockfile
 
# 開発ステージ
FROM base AS development
COPY --from=deps /app/node_modules ./node_modules
COPY . .
CMD ["pnpm", "dev"]
 
# ビルドステージ
FROM base AS build
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN pnpm build
 
# テストステージ
FROM base AS test
COPY --from=deps /app/node_modules ./node_modules
COPY . .
CMD ["pnpm", "test"]
 
# 本番ステージ
FROM base AS production
COPY --from=build /app/dist ./dist
COPY --from=deps /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

# .dockerignore
node_modules
.next
dist
build
coverage
test-results
playwright-report
 
# Git
.git
.gitignore
 
# IDE
.vscode
.idea
 
# Docker
docker-compose*.yml
Dockerfile*
.dockerignore
 
# ドキュメント
*.md
LICENSE
 
# テスト
__tests__
*.test.ts
*.spec.ts
cypress

# Makefile (Docker Compose 関連)
.PHONY: dev up down logs shell db-shell test clean setup help
 
# デフォルトターゲット
.DEFAULT_GOAL := help
 
help: ## ヘルプを表示
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | \
		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-15s\033[0m %s\n", $$1, $$2}'
 
setup: ## 初期セットアップ（.env コピー、依存関係インストール）
	@test -f .env || cp .env.example .env
	docker compose build
	docker compose up -d db redis
	@echo "Waiting for DB..."
	@sleep 5
	docker compose run --rm app npx prisma migrate deploy
	docker compose run --rm app npx prisma db seed
	@echo "Setup complete! Run 'make dev' to start."
 
dev: up ## 開発サーバー起動 (Docker + ローカル)
	npm run dev
 
up: ## Docker サービス起動
	docker compose up -d
	@docker compose ps
 
down: ## Docker サービス停止
	docker compose down
 
logs: ## ログ表示
	docker compose logs -f --tail=100
 
logs-app: ## アプリログのみ表示
	docker compose logs -f --tail=100 app
 
shell: ## app コンテナに入る
	docker compose exec app sh
 
db-shell: ## DB に接続
	docker compose exec db psql -U postgres -d myapp_dev
 
db-dump: ## DB ダンプ
	docker compose exec db pg_dump -U postgres myapp_dev > backup.sql
 
db-restore: ## DB リストア
	cat backup.sql | docker compose exec -T db psql -U postgres myapp_dev
 
db-reset: ## DB リセット（マイグレーション再実行）
	docker compose exec app npx prisma migrate reset --force
 
test: ## テスト (Docker 上)
	docker compose --profile test run --rm test
 
test-watch: ## テスト ウォッチモード
	docker compose --profile test run --rm test npm test -- --watch
 
test-e2e: ## E2E テスト
	docker compose --profile e2e run --rm e2e
 
lint: ## Lint 実行
	docker compose exec app npm run lint
 
format: ## コードフォーマット
	docker compose exec app npm run format
 
typecheck: ## 型チェック
	docker compose exec app npm run typecheck
 
clean: ## 全削除 (ボリューム含む)
	docker compose down -v --remove-orphans
	docker system prune -f
 
rebuild: ## イメージ再ビルドして起動
	docker compose build --no-cache
	docker compose up -d
 
update-deps: ## 依存関係を更新
	docker compose exec app pnpm update
	docker compose exec app pnpm install --frozen-lockfile

#!/bin/bash
# scripts/setup.sh - プロジェクト初期セットアップ
 
set -euo pipefail
 
echo "=== Project Setup ==="
 
# 1. 環境変数ファイルのコピー
if [ ! -f .env ]; then
    echo "Creating .env file..."
    cp .env.example .env
    echo "  Please edit .env with your settings"
fi
 
# 2. Docker Compose ビルド
echo "Building Docker images..."
docker compose build
 
# 3. サービス起動
echo "Starting services..."
docker compose up -d db redis
 
# 4. DB が起動するまで待機
echo "Waiting for database..."
until docker compose exec -T db pg_isready -U postgres 2>/dev/null; do
    printf "."
    sleep 1
done
echo " Ready!"
 
# 5. マイグレーション実行
echo "Running migrations..."
docker compose run --rm app npx prisma migrate deploy
 
# 6. シードデータ投入
echo "Seeding database..."
docker compose run --rm app npx prisma db seed
 
# 7. 全サービス起動
echo "Starting all services..."
docker compose up -d
 
echo ""
echo "=== Setup Complete ==="
echo "  App: http://localhost:3000"
echo "  DB:  localhost:5432"
echo ""
echo "Run 'make dev' or 'docker compose up -d' to start."

#!/bin/bash
# .git/hooks/pre-commit
# コミット前にコンテナ内で lint + typecheck を実行
 
echo "Running pre-commit checks..."
 
# lint チェック
if ! docker compose exec -T app npm run lint --quiet 2>/dev/null; then
    echo "Lint check failed. Please fix the errors and try again."
    exit 1
fi
 
# 型チェック
if ! docker compose exec -T app npm run typecheck 2>/dev/null; then
    echo "Type check failed. Please fix the errors and try again."
    exit 1
fi
 
echo "Pre-commit checks passed."

// .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Docker: Up",
      "type": "shell",
      "command": "docker compose up -d",
      "group": "build",
      "presentation": {
        "reveal": "silent"
      }
    },
    {
      "label": "Docker: Down",
      "type": "shell",
      "command": "docker compose down",
      "group": "build"
    },
    {
      "label": "Docker: Logs",
      "type": "shell",
      "command": "docker compose logs -f --tail=100",
      "group": "build",
      "isBackground": true
    },
    {
      "label": "Docker: Test",
      "type": "shell",
      "command": "docker compose --profile test run --rm test",
      "group": "test"
    },
    {
      "label": "Docker: Shell",
      "type": "shell",
      "command": "docker compose exec app sh",
      "group": "none"
    },
    {
      "label": "Docker: DB Reset",
      "type": "shell",
      "command": "docker compose exec app npx prisma migrate reset --force",
      "group": "none",
      "problemMatcher": []
    }
  ]
}

// .devcontainer/devcontainer.json
{
  "name": "My App Dev Container",
  "dockerComposeFile": ["../docker-compose.yml", "docker-compose.devcontainer.yml"],
  "service": "app",
  "workspaceFolder": "/app",
 
  "features": {
    "ghcr.io/devcontainers/features/git:1": {},
    "ghcr.io/devcontainers/features/github-cli:1": {}
  },
 
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "Prisma.prisma",
        "ms-vscode.vscode-typescript-next"
      ],
      "settings": {
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "esbenp.prettier-vscode",
        "terminal.integrated.defaultProfile.linux": "zsh"
      }
    }
  },
 
  "forwardPorts": [3000, 5432, 6379],
 
  "postCreateCommand": "pnpm install && npx prisma generate",
 
  "remoteUser": "node"
}

# .devcontainer/docker-compose.devcontainer.yml
services:
  app:
    build:
      context: ..
      dockerfile: Dockerfile.dev
    volumes:
      - ..:/app:cached
      - node_modules:/app/node_modules
    command: sleep infinity   # Dev Container はシェルを使うため
    environment:
      DATABASE_URL: postgresql://postgres:postgres@db:5432/myapp_dev
      REDIS_URL: redis://redis:6379
 
volumes:
  node_modules:

# docker-compose.yml - 完全な開発環境
services:
  # --- フロントエンド ---
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - frontend_node_modules:/app/node_modules
    environment:
      VITE_API_URL: http://localhost:8080
      VITE_HMR_HOST: localhost
    command: pnpm dev --host
 
  # --- バックエンド API ---
  api:
    build:
      context: ./backend
      dockerfile: Dockerfile.dev
    ports:
      - "8080:8080"
      - "9229:9229"    # デバッガポート
    volumes:
      - ./backend:/app
      - backend_node_modules:/app/node_modules
    environment:
      NODE_ENV: development
      DATABASE_URL: postgresql://postgres:postgres@db:5432/myapp_dev
      REDIS_URL: redis://redis:6379
      SMTP_HOST: mailhog
      SMTP_PORT: 1025
      S3_ENDPOINT: http://minio:9000
      S3_ACCESS_KEY: minioadmin
      S3_SECRET_KEY: minioadmin
      S3_BUCKET: uploads
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    command: >
      node --inspect=0.0.0.0:9229 node_modules/.bin/tsx watch src/index.ts
 
  # --- データベース ---
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: myapp_dev
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    ports:
      - "5432:5432"    # 開発時は外部からアクセス可能にする
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./scripts/init.sql:/docker-entrypoint-initdb.d/init.sql
 
  # --- Redis ---
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
 
  # --- オブジェクトストレージ (S3 互換) ---
  minio:
    image: minio/minio:latest
    ports:
      - "9000:9000"
      - "9001:9001"    # Console
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    volumes:
      - minio_data:/data
    command: server /data --console-address ":9001"
 
  # --- メールキャッチャー ---
  mailhog:
    image: mailhog/mailhog:latest
    profiles: ["debug"]
    ports:
      - "1025:1025"    # SMTP
      - "8025:8025"    # Web UI
 
  # --- DB 管理ツール ---
  pgadmin:
    image: dpage/pgadmin4:latest
    profiles: ["debug"]
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@example.com
      PGADMIN_DEFAULT_PASSWORD: admin
    ports:
      - "5050:80"
 
  # --- Redis 管理ツール ---
  redis-commander:
    image: rediscommander/redis-commander:latest
    profiles: ["debug"]
    environment:
      REDIS_HOSTS: local:redis:6379
    ports:
      - "8081:8081"
 
volumes:
  frontend_node_modules:
  backend_node_modules:
  pgdata:
  redis_data:
  minio_data:

# NG: 本番用 Dockerfile をそのまま開発に使用
FROM node:20-alpine
WORKDIR /app
COPY . .               # 全ファイルコピー → バインドマウントと競合
RUN npm ci --production # devDependencies がない
CMD ["node", "dist/index.js"]  # ビルド済み前提
 
# OK: マルチステージで開発ステージを用意
FROM node:20-alpine AS development
WORKDIR /app
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install  # devDependencies も含む
# COPY は省略 → バインドマウントでソースを注入
CMD ["pnpm", "dev"]

# NG: クリーンアップを忘れる
steps:
  - run: docker compose up -d
  - run: npm test
  # docker compose down を忘れている → 次回実行時にポート競合
 
# OK: always ステップでクリーンアップを保証
steps:
  - run: docker compose -f docker-compose.ci.yml up -d
  - run: npm test
  - name: Cleanup
    if: always()  # テスト失敗時も必ず実行
    run: docker compose -f docker-compose.ci.yml down -v --remove-orphans

# NG: デバッガポートが本番で公開されたまま
services:
  app:
    ports:
      - "3000:3000"
      - "9229:9229"    # デバッガポート → 本番では絶対に不可
    command: node --inspect=0.0.0.0:9229 dist/index.js
 
# OK: デバッガポートは開発 override のみ
# docker-compose.yml (ベース)
services:
  app:
    ports:
      - "3000:3000"
    command: node dist/index.js
 
# docker-compose.override.yml (開発)
services:
  app:
    ports:
      - "9229:9229"
    command: node --inspect=0.0.0.0:9229 node_modules/.bin/tsx watch src/index.ts

# NG: ホストの node_modules がコンテナ内を上書き
services:
  app:
    volumes:
      - .:/app        # node_modules も含まれてしまう
    # → ホスト(macOS)のバイナリがLinuxコンテナで動かない
 
# OK: node_modules はボリュームで分離
services:
  app:
    volumes:
      - .:/app
      - node_modules:/app/node_modules   # コンテナ専用
volumes:
  node_modules:

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()