@kood/claude-code 0.2.1 → 0.2.3

package/dist/index.js

@@ -404,7 +404,7 @@ var init = async (options) => {
 
 // src/index.ts
 var program = new Command();
-program.name("claude-code").description("Claude Code documentation installer for projects").version("0.2.1");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.2.3");
 program.option(
   "-t, --template <names>",
   "template names (comma-separated: tanstack-start,hono)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kood/claude-code",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Claude Code documentation installer for projects",
   "type": "module",
   "bin": "./dist/index.js",

package/templates/hono/docs/library/drizzle/cloudflare-d1.md

@@ -0,0 +1,247 @@
+# Drizzle - Cloudflare D1
+
+> SQLite 기반 서버리스 데이터베이스
+
+---
+
+## 주의사항
+
+```
+D1은 트랜잭션 미지원 (ACID 보장 X)
+Drizzle Kit 마이그레이션 → wrangler CLI로 적용
+```
+
+---
+
+## Quick Setup
+
+### 설치
+
+```bash
+npm install drizzle-orm
+npm install -D drizzle-kit wrangler
+```
+
+### 스키마 정의
+
+```typescript
+// src/db/schema.ts
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
+
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  email: text('email').notNull().unique(),
+  name: text('name'),
+})
+
+export type User = typeof users.$inferSelect
+export type NewUser = typeof users.$inferInsert
+```
+
+### drizzle.config.ts
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'sqlite',
+  schema: './src/db/schema.ts',
+  out: './drizzle/migrations',
+  driver: 'd1-http',
+  dbCredentials: {
+    accountId: process.env.CLOUDFLARE_ACCOUNT_ID!,
+    databaseId: process.env.CLOUDFLARE_DATABASE_ID!,
+    token: process.env.CLOUDFLARE_D1_TOKEN!,
+  },
+})
+```
+
+### Hono + D1
+
+```typescript
+import { Hono } from 'hono'
+import { drizzle } from 'drizzle-orm/d1'
+import * as schema from './db/schema'
+
+type Bindings = { DB: D1Database }
+
+const app = new Hono<{ Bindings: Bindings }>()
+
+app.get('/users', async (c) => {
+  const db = drizzle(c.env.DB, { schema })
+  const users = await db.select().from(schema.users)
+  return c.json(users)
+})
+
+export default app
+```
+
+---
+
+## D1 데이터베이스 생성
+
+```bash
+npx wrangler d1 create my-database
+# database_id = "xxxx-xxxx-xxxx-xxxx"
+```
+
+### wrangler.jsonc
+
+```jsonc
+{
+  "name": "hono-d1-app",
+  "main": "src/index.ts",
+  "compatibility_date": "2025-01-01",
+  "compatibility_flags": ["nodejs_compat"],
+  "d1_databases": [{
+    "binding": "DB",
+    "database_name": "my-database",
+    "database_id": "YOUR_DATABASE_ID",
+    "migrations_dir": "drizzle/migrations"
+  }]
+}
+```
+
+---
+
+## 마이그레이션 워크플로우
+
+```bash
+# 1. 마이그레이션 파일 생성
+npx drizzle-kit generate
+
+# 2. 로컬 적용
+npx wrangler d1 migrations apply my-database --local
+
+# 3. 원격 적용
+npx wrangler d1 migrations apply my-database --remote
+```
+
+---
+
+## 완전한 CRUD API
+
+```typescript
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import { z } from 'zod'
+import { HTTPException } from 'hono/http-exception'
+import { drizzle } from 'drizzle-orm/d1'
+import { eq } from 'drizzle-orm'
+import * as schema from './db/schema'
+
+type Bindings = { DB: D1Database }
+type Variables = { db: ReturnType<typeof drizzle> }
+
+const app = new Hono<{ Bindings: Bindings; Variables: Variables }>()
+
+// Drizzle 미들웨어
+app.use('*', async (c, next) => {
+  c.set('db', drizzle(c.env.DB, { schema }))
+  await next()
+})
+
+app.get('/users', async (c) => {
+  const db = c.get('db')
+  const users = await db.select().from(schema.users)
+  return c.json(users)
+})
+
+app.post('/users',
+  zValidator('json', z.object({ email: z.email(), name: z.string().optional() })),
+  async (c) => {
+    const db = c.get('db')
+    const data = c.req.valid('json')
+
+    const existing = await db.select().from(schema.users).where(eq(schema.users.email, data.email))
+    if (existing.length > 0) {
+      throw new HTTPException(409, { message: 'Email already exists' })
+    }
+
+    const [user] = await db.insert(schema.users).values(data).returning()
+    return c.json(user, 201)
+  }
+)
+
+app.get('/users/:id', async (c) => {
+  const db = c.get('db')
+  const id = Number(c.req.param('id'))
+
+  const [user] = await db.select().from(schema.users).where(eq(schema.users.id, id))
+  if (!user) {
+    throw new HTTPException(404, { message: 'User not found' })
+  }
+
+  return c.json(user)
+})
+
+app.put('/users/:id',
+  zValidator('json', z.object({ name: z.string() })),
+  async (c) => {
+    const db = c.get('db')
+    const id = Number(c.req.param('id'))
+    const data = c.req.valid('json')
+
+    const [user] = await db.update(schema.users)
+      .set(data)
+      .where(eq(schema.users.id, id))
+      .returning()
+
+    if (!user) {
+      throw new HTTPException(404, { message: 'User not found' })
+    }
+
+    return c.json(user)
+  }
+)
+
+app.delete('/users/:id', async (c) => {
+  const db = c.get('db')
+  const id = Number(c.req.param('id'))
+
+  await db.delete(schema.users).where(eq(schema.users.id, id))
+  return c.json({ success: true })
+})
+
+export default app
+```
+
+---
+
+## 로컬 개발
+
+```bash
+# Worker 실행
+npx wrangler dev
+
+# D1 조회
+npx wrangler d1 execute my-database --local \
+  --command "SELECT * FROM users;"
+```
+
+---
+
+## 배포
+
+```bash
+npx drizzle-kit generate
+npx wrangler d1 migrations apply my-database --remote
+npx wrangler deploy
+```
+
+---
+
+## 제한사항
+
+| 항목 | D1 |
+|------|-----|
+| 트랜잭션 | 미지원 |
+| 마이그레이션 | wrangler 사용 |
+| 접속 방식 | HTTP (D1 binding) |
+
+---
+
+## 관련 문서
+
+- [Drizzle 개요](./index.md)
+- [Cloudflare 배포](../../deployment/cloudflare.md)

package/templates/hono/docs/library/drizzle/config.md

@@ -0,0 +1,167 @@
+# Drizzle - Config 파일
+
+> drizzle.config.ts 설정
+
+---
+
+## 기본 설정
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+})
+```
+
+---
+
+## 파일 위치
+
+```
+프로젝트/
+├── drizzle.config.ts     # 프로젝트 루트
+├── drizzle/
+│   └── migrations/       # 마이그레이션 파일
+├── src/
+│   └── db/
+│       ├── index.ts      # Drizzle client
+│       └── schema/       # 스키마 정의
+│           ├── index.ts
+│           ├── user.ts
+│           └── post.ts
+```
+
+---
+
+## PostgreSQL
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+})
+```
+
+---
+
+## MySQL
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'mysql',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+})
+```
+
+---
+
+## SQLite
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'sqlite',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: './sqlite.db',
+  },
+})
+```
+
+---
+
+## Cloudflare D1
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'sqlite',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  driver: 'd1-http',
+  dbCredentials: {
+    accountId: process.env.CLOUDFLARE_ACCOUNT_ID!,
+    databaseId: process.env.CLOUDFLARE_DATABASE_ID!,
+    token: process.env.CLOUDFLARE_D1_TOKEN!,
+  },
+})
+```
+
+---
+
+## 설정 옵션
+
+| 옵션 | 설명 |
+|------|------|
+| `dialect` | DB 종류 (postgresql, mysql, sqlite) |
+| `schema` | 스키마 파일 경로 |
+| `out` | 마이그레이션 출력 폴더 |
+| `dbCredentials` | DB 연결 정보 |
+| `driver` | 드라이버 (d1-http 등) |
+| `verbose` | 상세 로그 출력 |
+| `strict` | 엄격 모드 |
+
+---
+
+## 환경변수 로드
+
+```typescript
+// drizzle.config.ts
+import 'dotenv/config'
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema/index.ts',
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+})
+```
+
+---
+
+## 다중 스키마 파일
+
+```typescript
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema/*.ts',  // glob 패턴
+  out: './drizzle/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+})
+```
+
+---
+
+## 관련 문서
+
+- [Drizzle 개요](./index.md)
+- [Cloudflare D1](./cloudflare-d1.md)

package/templates/hono/docs/library/drizzle/index.md

@@ -0,0 +1,259 @@
+# Drizzle ORM - Database ORM
+
+> Type-safe, lightweight TypeScript ORM
+
+@config.md
+@cloudflare-d1.md
+
+---
+
+## 설치
+
+```bash
+npm install drizzle-orm pg
+npm install -D drizzle-kit @types/pg
+```
+
+---
+
+## 스키마 정의
+
+### 폴더 구조
+
+```
+src/
+├── db/
+│   ├── index.ts       # Drizzle client
+│   └── schema/
+│       ├── index.ts   # export all
+│       ├── user.ts    # User 테이블
+│       └── post.ts    # Post 테이블
+```
+
+### user.ts
+
+```typescript
+import { pgTable, serial, text, timestamp, boolean } from 'drizzle-orm/pg-core'
+
+// 사용자 테이블
+export const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  email: text('email').notNull().unique(),  // 로그인 이메일
+  name: text('name'),                        // 표시 이름
+  verified: boolean('verified').notNull().default(false),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+  updatedAt: timestamp('updated_at').notNull().defaultNow(),
+})
+
+// 타입 추론
+export type User = typeof users.$inferSelect
+export type NewUser = typeof users.$inferInsert
+```
+
+---
+
+## Drizzle Client
+
+```typescript
+// src/db/index.ts
+import { drizzle } from 'drizzle-orm/node-postgres'
+import * as schema from './schema'
+
+export const db = drizzle(process.env.DATABASE_URL!, { schema })
+```
+
+---
+
+## CRUD
+
+### Create
+
+```typescript
+import { db } from '@/db'
+import { users } from '@/db/schema'
+
+const user = await db.insert(users).values({
+  email: 'user@example.com',
+  name: 'John',
+}).returning()
+
+// Batch insert
+await db.insert(users).values([
+  { email: 'user1@example.com', name: 'User 1' },
+  { email: 'user2@example.com', name: 'User 2' },
+])
+```
+
+### Read
+
+```typescript
+import { eq, and, or, gt, like, desc, asc } from 'drizzle-orm'
+
+// 전체 조회
+const allUsers = await db.select().from(users)
+
+// 조건 조회
+const user = await db.select().from(users).where(eq(users.id, 1))
+
+// 복합 조건
+const filtered = await db.select().from(users).where(
+  and(
+    eq(users.verified, true),
+    gt(users.createdAt, new Date('2024-01-01'))
+  )
+)
+
+// 정렬 + 페이지네이션
+const paginated = await db.select().from(users)
+  .orderBy(desc(users.createdAt))
+  .limit(10)
+  .offset(0)
+
+// 특정 필드만 선택
+const emails = await db.select({ email: users.email }).from(users)
+```
+
+### Update
+
+```typescript
+await db.update(users)
+  .set({ name: 'Updated Name' })
+  .where(eq(users.id, 1))
+
+// Upsert
+await db.insert(users)
+  .values({ email: 'user@example.com', name: 'John' })
+  .onConflictDoUpdate({
+    target: users.email,
+    set: { name: 'John Updated' },
+  })
+```
+
+### Delete
+
+```typescript
+await db.delete(users).where(eq(users.id, 1))
+await db.delete(users).where(eq(users.verified, false))
+```
+
+---
+
+## 필터링 연산자
+
+```typescript
+import { eq, ne, gt, gte, lt, lte, like, ilike, inArray, isNull, between, and, or, not } from 'drizzle-orm'
+
+// 비교
+where(eq(users.id, 1))           // =
+where(ne(users.id, 1))           // !=
+where(gt(users.age, 18))         // >
+where(gte(users.age, 18))        // >=
+where(lt(users.age, 65))         // <
+where(lte(users.age, 65))        // <=
+
+// 문자열
+where(like(users.name, '%John%'))
+where(ilike(users.name, '%john%'))  // 대소문자 무시
+
+// 배열
+where(inArray(users.id, [1, 2, 3]))
+
+// NULL
+where(isNull(users.deletedAt))
+
+// 범위
+where(between(users.age, 18, 65))
+
+// 논리
+where(and(eq(users.role, 'admin'), eq(users.verified, true)))
+where(or(eq(users.role, 'admin'), eq(users.role, 'moderator')))
+where(not(eq(users.role, 'guest')))
+```
+
+---
+
+## 트랜잭션
+
+```typescript
+const result = await db.transaction(async (tx) => {
+  const [user] = await tx.insert(users)
+    .values({ email: 'user@example.com' })
+    .returning()
+
+  await tx.insert(posts).values({ title: 'First Post', authorId: user.id })
+
+  return user
+})
+
+// 롤백
+await db.transaction(async (tx) => {
+  const [account] = await tx.select().from(accounts).where(eq(accounts.id, 1))
+  if (account.balance < 100) {
+    tx.rollback()  // 예외 발생, 트랜잭션 롤백
+  }
+  await tx.update(accounts).set({ balance: account.balance - 100 }).where(eq(accounts.id, 1))
+})
+```
+
+---
+
+## Hono와 함께 사용
+
+```typescript
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import { z } from 'zod'
+import { HTTPException } from 'hono/http-exception'
+import { eq } from 'drizzle-orm'
+import { db } from '@/db'
+import { users } from '@/db/schema'
+
+const app = new Hono()
+
+app.post('/users',
+  zValidator('json', z.object({ email: z.email(), name: z.string().optional() })),
+  async (c) => {
+    const data = c.req.valid('json')
+
+    const existing = await db.select().from(users).where(eq(users.email, data.email))
+    if (existing.length > 0) {
+      throw new HTTPException(409, { message: 'Email already exists' })
+    }
+
+    const [user] = await db.insert(users).values(data).returning()
+    return c.json({ user }, 201)
+  }
+)
+
+app.get('/users/:id', async (c) => {
+  const id = Number(c.req.param('id'))
+  const [user] = await db.select().from(users).where(eq(users.id, id))
+
+  if (!user) {
+    throw new HTTPException(404, { message: 'User not found' })
+  }
+
+  return c.json({ user })
+})
+
+export default app
+```
+
+---
+
+## CLI 명령어
+
+```bash
+npx drizzle-kit generate    # 마이그레이션 생성
+npx drizzle-kit migrate     # 마이그레이션 실행
+npx drizzle-kit push        # 스키마 동기화 (개발용)
+npx drizzle-kit pull        # DB에서 스키마 가져오기
+npx drizzle-kit studio      # GUI 실행
+```
+
+---
+
+## 관련 문서
+
+- [Config 파일](./config.md) - drizzle.config.ts 설정
+- [Cloudflare D1](./cloudflare-d1.md)