@punks/cli 0.1.16 → 1.0.0

package/dist/skills/frameworks/elysia/elysiajs/integrations/drizzle.md

@@ -0,0 +1,258 @@
+# Drizzle Integration
+Elysia + Drizzle integration guide
+
+## What It Is
+Headless TypeScript ORM. Convert Drizzle schema → Elysia validation models via `drizzle-typebox`.
+
+## Flow
+```
+Drizzle → drizzle-typebox → Elysia validation → OpenAPI + Eden Treaty
+```
+
+## Installation
+```bash
+bun add drizzle-orm drizzle-typebox
+```
+
+### Pin TypeBox Version
+Prevent Symbol conflicts:
+```bash
+grep "@sinclair/typebox" node_modules/elysia/package.json
+```
+
+Add to `package.json`:
+```json
+{
+  "overrides": {
+    "@sinclair/typebox": "0.32.4"
+  }
+}
+```
+
+## Drizzle Schema
+```typescript
+// src/database/schema.ts
+import { pgTable, varchar, timestamp } from 'drizzle-orm/pg-core'
+import { createId } from '@paralleldrive/cuid2'
+
+export const user = pgTable('user', {
+  id: varchar('id').$defaultFn(() => createId()).primaryKey(),
+  username: varchar('username').notNull().unique(),
+  password: varchar('password').notNull(),
+  email: varchar('email').notNull().unique(),
+  salt: varchar('salt', { length: 64 }).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const table = { user } as const
+export type Table = typeof table
+```
+
+## drizzle-typebox
+```typescript
+import { t } from 'elysia'
+import { createInsertSchema } from 'drizzle-typebox'
+import { table } from './database/schema'
+
+const _createUser = createInsertSchema(table.user, {
+  email: t.String({ format: 'email' })  // Replace with Elysia type
+})
+
+new Elysia()
+  .post('/sign-up', ({ body }) => {}, {
+    body: t.Omit(_createUser, ['id', 'salt', 'createdAt'])
+  })
+```
+
+## Type Instantiation Error
+**Error**: "Type instantiation is possibly infinite"
+
+**Cause**: Circular reference when nesting drizzle-typebox into Elysia schema.
+
+**Fix**: Explicitly define type between them:
+```typescript
+// ✅ Works
+const _createUser = createInsertSchema(table.user, {
+  email: t.String({ format: 'email' })
+})
+const createUser = t.Omit(_createUser, ['id', 'salt', 'createdAt'])
+
+// ❌ Infinite loop
+const createUser = t.Omit(
+  createInsertSchema(table.user, { email: t.String({ format: 'email' }) }),
+  ['id', 'salt', 'createdAt']
+)
+```
+
+Always declare variable for drizzle-typebox then reference it.
+
+## Utility Functions
+Copy as-is for simplified usage:
+```typescript
+// src/database/utils.ts
+/**
+ * @lastModified 2025-02-04
+ * @see https://elysiajs.com/recipe/drizzle.html#utility
+ */
+
+import { Kind, type TObject } from '@sinclair/typebox'
+import {
+    createInsertSchema,
+    createSelectSchema,
+    BuildSchema,
+} from 'drizzle-typebox'
+
+import { table } from './schema'
+import type { Table } from 'drizzle-orm'
+
+type Spread<
+    T extends TObject | Table,
+    Mode extends 'select' | 'insert' | undefined,
+> =
+    T extends TObject<infer Fields>
+        ? {
+              [K in keyof Fields]: Fields[K]
+          }
+        : T extends Table
+          ? Mode extends 'select'
+              ? BuildSchema<
+                    'select',
+                    T['_']['columns'],
+                    undefined
+                >['properties']
+              : Mode extends 'insert'
+                ? BuildSchema<
+                      'insert',
+                      T['_']['columns'],
+                      undefined
+                  >['properties']
+                : {}
+          : {}
+
+/**
+ * Spread a Drizzle schema into a plain object
+ */
+export const spread = <
+    T extends TObject | Table,
+    Mode extends 'select' | 'insert' | undefined,
+>(
+    schema: T,
+    mode?: Mode,
+): Spread<T, Mode> => {
+    const newSchema: Record<string, unknown> = {}
+    let table
+
+    switch (mode) {
+        case 'insert':
+        case 'select':
+            if (Kind in schema) {
+                table = schema
+                break
+            }
+
+            table =
+                mode === 'insert'
+                    ? createInsertSchema(schema)
+                    : createSelectSchema(schema)
+
+            break
+
+        default:
+            if (!(Kind in schema)) throw new Error('Expect a schema')
+            table = schema
+    }
+
+    for (const key of Object.keys(table.properties))
+        newSchema[key] = table.properties[key]
+
+    return newSchema as any
+}
+
+/**
+ * Spread a Drizzle Table into a plain object
+ *
+ * If `mode` is 'insert', the schema will be refined for insert
+ * If `mode` is 'select', the schema will be refined for select
+ * If `mode` is undefined, the schema will be spread as is, models will need to be refined manually
+ */
+export const spreads = <
+    T extends Record<string, TObject | Table>,
+    Mode extends 'select' | 'insert' | undefined,
+>(
+    models: T,
+    mode?: Mode,
+): {
+    [K in keyof T]: Spread<T[K], Mode>
+} => {
+    const newSchema: Record<string, unknown> = {}
+    const keys = Object.keys(models)
+
+    for (const key of keys) newSchema[key] = spread(models[key], mode)
+
+    return newSchema as any
+}
+```
+
+Usage:
+```typescript
+// ✅ Using spread
+const user = spread(table.user, 'insert')
+const createUser = t.Object({
+  id: user.id,
+  username: user.username,
+  password: user.password
+})
+
+// ⚠️ Using t.Pick
+const _createUser = createInsertSchema(table.user)
+const createUser = t.Pick(_createUser, ['id', 'username', 'password'])
+```
+
+## Table Singleton Pattern
+```typescript
+// src/database/model.ts
+import { table } from './schema'
+import { spreads } from './utils'
+
+export const db = {
+  insert: spreads({ user: table.user }, 'insert'),
+  select: spreads({ user: table.user }, 'select')
+} as const
+```
+
+Usage:
+```typescript
+// src/index.ts
+import { db } from './database/model'
+const { user } = db.insert
+
+new Elysia()
+  .post('/sign-up', ({ body }) => {}, {
+    body: t.Object({
+      id: user.username,
+      username: user.username,
+      password: user.password
+    })
+  })
+```
+
+## Refinement
+```typescript
+// src/database/model.ts
+import { createInsertSchema, createSelectSchema } from 'drizzle-typebox'
+
+export const db = {
+  insert: spreads({
+    user: createInsertSchema(table.user, {
+      email: t.String({ format: 'email' })
+    })
+  }, 'insert'),
+  select: spreads({
+    user: createSelectSchema(table.user, {
+      email: t.String({ format: 'email' })
+    })
+  }, 'select')
+} as const
+```
+
+`spread` skips refined schemas.

package/dist/skills/frameworks/elysia/elysiajs/integrations/expo.md

@@ -0,0 +1,95 @@
+# Expo Integration
+Run Elysia on Expo (React Native)
+
+## What It Is
+Create API routes in Expo app (SDK 50+, App Router v3).
+
+## Setup
+1. Create `app/[...slugs]+api.ts`
+2. Define Elysia server
+3. Export `Elysia.fetch` as HTTP methods
+
+```typescript
+// app/[...slugs]+api.ts
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+  .get('/', 'hello Expo')
+  .post('/', ({ body }) => body, {
+    body: t.Object({ name: t.String() })
+  })
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+## Prefix for Non-Root
+If placed in `app/api/[...slugs]+api.ts`, set prefix:
+```typescript
+const app = new Elysia({ prefix: '/api' })
+  .get('/', 'Hello Expo')
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+Ensures routing works in any location.
+
+## Eden (End-to-End Type Safety)
+1. Export type:
+```typescript
+// app/[...slugs]+api.ts
+const app = new Elysia()
+  .get('/', 'Hello Nextjs')
+  .post('/user', ({ body }) => body, {
+    body: treaty.schema('User', { name: 'string' })
+  })
+
+export type app = typeof app
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+2. Create client:
+```typescript
+// lib/eden.ts
+import { treaty } from '@elysiajs/eden'
+import type { app } from '../app/[...slugs]+api'
+
+export const api = treaty<app>('localhost:3000/api')
+```
+
+3. Use in components:
+```tsx
+// app/page.tsx
+import { api } from '../lib/eden'
+
+export default async function Page() {
+  const message = await api.get()
+  return <h1>Hello, {message}</h1>
+}
+```
+
+## Deployment
+- Deploy as normal Elysia app OR
+- Use experimental Expo server runtime
+
+With Expo runtime:
+```bash
+expo export
+# Creates dist/server/_expo/functions/[...slugs]+api.js
+```
+
+Edge function, not normal server (no port allocation).
+
+### Adapters
+- Express
+- Netlify
+- Vercel
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/nextjs.md

@@ -0,0 +1,103 @@
+
+# Next.js Integration
+
+## What It Is
+Run Elysia on Next.js App Router.
+
+## Setup
+1. Create `app/api/[[...slugs]]/route.ts`
+2. Define Elysia + export handlers:
+```typescript
+// app/api/[[...slugs]]/route.ts
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia({ prefix: '/api' })
+  .get('/', 'Hello Nextjs')
+  .post('/', ({ body }) => body, {
+    body: t.Object({ name: t.String() })
+  })
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+WinterCG compliance - works as normal Next.js API route.
+
+## Prefix for Non-Root
+If placed in `app/user/[[...slugs]]/route.ts`, set prefix:
+```typescript
+const app = new Elysia({ prefix: '/user' })
+  .get('/', 'Hello Nextjs')
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+## Eden (End-to-End Type Safety)
+Isomorphic fetch pattern:
+- Server: Direct calls (no network)
+- Client: Network calls
+
+1. Export type:
+```typescript
+// app/api/[[...slugs]]/route.ts
+export const app = new Elysia({ prefix: '/api' })
+  .get('/', 'Hello Nextjs')
+  .post('/user', ({ body }) => body, {
+    body: treaty.schema('User', { name: 'string' })
+  })
+
+export type app = typeof app
+
+export const GET = app.fetch
+export const POST = app.fetch
+```
+
+2. Create client:
+```typescript
+// lib/eden.ts
+import { treaty } from '@elysiajs/eden'
+import type { app } from '../app/api/[[...slugs]]/route'
+
+export const api =
+  typeof process !== 'undefined'
+    ? treaty(app).api
+    : treaty<typeof app>('localhost:3000').api
+```
+
+Use `typeof process` not `typeof window` (window undefined at build time → hydration error).
+
+3. Use in components:
+```tsx
+// app/page.tsx
+import { api } from '../lib/eden'
+
+export default async function Page() {
+  const message = await api.get()
+  return <h1>Hello, {message}</h1>
+}
+```
+
+Works with server/client components + ISR.
+
+## React Query
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+function App() {
+  const { data: response } = useQuery({
+    queryKey: ['get'],
+    queryFn: () => getTreaty().get()
+  })
+  
+  return response?.data
+}
+```
+
+Works with all React Query features.
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/nodejs.md

@@ -0,0 +1,64 @@
+# Node.js Integration
+Run Elysia on Node.js
+
+## What It Is
+Runtime adapter to run Elysia on Node.js.
+
+## Installation
+```bash
+bun add elysia @elysiajs/node
+```
+
+## Setup
+Apply node adapter:
+```typescript
+import { Elysia } from 'elysia'
+import { node } from '@elysiajs/node'
+
+const app = new Elysia({ adapter: node() })
+  .get('/', () => 'Hello Elysia')
+  .listen(3000)
+```
+
+## Additional Setup (Recommended)
+Install `tsx` for hot-reload:
+```bash
+bun add -d tsx @types/node typescript
+```
+
+Scripts in `package.json`:
+```json
+{
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc src/index.ts --outDir dist",
+    "start": "NODE_ENV=production node dist/index.js"
+  }
+}
+```
+
+- **dev**: Hot-reload dev mode
+- **build**: Production build
+- **start**: Production server
+
+Create `tsconfig.json`:
+```bash
+tsc --init
+```
+
+Update strict mode:
+```json
+{
+  "compilerOptions": {
+    "strict": true
+  }
+}
+```
+
+Provides hot-reload + JSX support similar to `bun dev`.
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/nuxt.md

@@ -0,0 +1,67 @@
+# Nuxt Integration
+
+## What It Is
+Community plugin `nuxt-elysia` for Nuxt API routes with Eden Treaty.
+
+## Installation
+```bash
+bun add elysia @elysiajs/eden
+bun add -d nuxt-elysia
+```
+
+## Setup
+1. Add to Nuxt config:
+```typescript
+export default defineNuxtConfig({
+  modules: ['nuxt-elysia']
+})
+```
+
+2. Create `api.ts` at project root:
+```typescript
+// api.ts
+export default () => new Elysia()
+  .get('/hello', () => ({ message: 'Hello world!' }))
+```
+
+3. Use Eden Treaty:
+```vue
+<template>
+  <div>
+    <p>{{ data.message }}</p>
+  </div>
+</template>
+<script setup lang="ts">
+const { $api } = useNuxtApp()
+
+const { data } = await useAsyncData(async () => {
+  const { data, error } = await $api.hello.get()
+  
+  if (error) throw new Error('Failed to call API')
+  
+  return data
+})
+</script>
+```
+
+Auto-setup on Nuxt API route.
+
+## Prefix
+Default: `/_api`. Customize:
+```typescript
+export default defineNuxtConfig({
+  nuxtElysia: {
+    path: '/api'
+  }
+})
+```
+
+Mounts on `/api` instead of `/_api`.
+
+See [nuxt-elysia](https://github.com/tkesgar/nuxt-elysia) for more config.
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/prisma.md

@@ -0,0 +1,93 @@
+
+# Prisma Integration
+Elysia + Prisma integration guide
+
+## What It Is
+Type-safe ORM. Generate Elysia validation models from Prisma schema via `prismabox`.
+
+## Flow
+```
+Prisma → prismabox → Elysia validation → OpenAPI + Eden Treaty
+```
+
+## Installation
+```bash
+bun add @prisma/client prismabox && \
+bun add -d prisma
+```
+
+## Prisma Schema
+Add `prismabox` generator:
+```prisma
+// prisma/schema.prisma
+generator client {
+  provider = "prisma-client"
+  output   = "../generated/prisma"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+generator prismabox {
+  provider = "prismabox"
+  typeboxImportDependencyName = "elysia"
+  typeboxImportVariableName = "t"
+  inputModel = true
+  output   = "../generated/prismabox"
+}
+
+model User {
+  id    String  @id @default(cuid())
+  email String  @unique
+  name  String?
+  posts Post[]
+}
+
+model Post {
+  id        String  @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean @default(false)
+  author    User    @relation(fields: [authorId], references: [id])
+  authorId  String
+}
+```
+
+Generates:
+- `User` → `generated/prismabox/User.ts`
+- `Post` → `generated/prismabox/Post.ts`
+
+## Using Generated Models
+```typescript
+// src/index.ts
+import { Elysia, t } from 'elysia'
+import { PrismaClient } from '../generated/prisma'
+import { UserPlain, UserPlainInputCreate } from '../generated/prismabox/User'
+
+const prisma = new PrismaClient()
+
+new Elysia()
+  .put('/', async ({ body }) =>
+    prisma.user.create({ data: body }), {
+      body: UserPlainInputCreate,
+      response: UserPlain
+    }
+  )
+  .get('/id/:id', async ({ params: { id }, status }) => {
+    const user = await prisma.user.findUnique({ where: { id } })
+    
+    if (!user) return status(404, 'User not found')
+    
+    return user
+  }, {
+    response: {
+      200: UserPlain,
+      404: t.String()
+    }
+  })
+  .listen(3000)
+```
+
+Reuses DB schema in Elysia validation models.