vasp-cli 0.3.1 → 0.9.0

package/templates/shared/server/index.hbs

@@ -2,15 +2,34 @@ import { Elysia } from 'elysia'
 import { cors } from '@elysiajs/cors'
 import { staticPlugin } from '@elysiajs/static'
 import { db } from './db/client.{{ext}}'
+import { logger } from './middleware/logger.{{ext}}'
+import { rateLimit } from './middleware/rateLimit.{{ext}}'
+import { errorHandler } from './middleware/errorHandler.{{ext}}'
+import { vaspDiagnosticRoutes } from './routes/_vasp.{{ext}}'
+{{#if isSsr}}
+import { csrfProtection } from './middleware/csrf.{{ext}}'
+{{/if}}
 {{#if hasAuth}}
 import { authRoutes } from './auth/index.{{ext}}'
 {{/if}}
+{{#each middlewares}}
+{{#if (eq scope "global")}}
+{{#if (eq fn.kind "default")}}
+import {{importAlias}} from '{{importPath fnSource ../ext}}'
+{{else}}
+import { {{importName fn}} as {{importAlias}} } from '{{importPath fnSource ../ext}}'
+{{/if}}
+{{/if}}
+{{/each}}
 {{#each queries}}
 import { {{camelCase name}}Route } from './routes/queries/{{camelCase name}}.{{../ext}}'
 {{/each}}
 {{#each actions}}
 import { {{camelCase name}}Route } from './routes/actions/{{camelCase name}}.{{../ext}}'
 {{/each}}
+{{#each apis}}
+import { {{camelCase name}}ApiRoute } from './routes/api/{{camelCase name}}.{{../ext}}'
+{{/each}}
 {{#each cruds}}
 import { {{camelCase entity}}CrudRoutes } from './routes/crud/{{camelCase entity}}.{{../ext}}'
 {{/each}}
@@ -23,21 +42,50 @@ import { {{camelCase name}}ScheduleRoute } from './routes/jobs/{{camelCase name}
 
 const PORT = Number(process.env.PORT) || {{backendPort}}
 
+const REQUIRED_ENV_VARS = [{{#each requiredEnvVars}}'{{this}}'{{#unless @last}}, {{/unless}}{{/each}}]
+const missingEnvVars = REQUIRED_ENV_VARS.filter((name) => {
+  const value = process.env[name]
+  return typeof value !== 'string' || value.trim() === ''
+})
+
+if (missingEnvVars.length > 0) {
+  console.error('❌ Missing required environment variables:')
+  for (const key of missingEnvVars) {
+    console.error(`  - ${key}`)
+  }
+  process.exit(1)
+}
+
 const app = new Elysia()
+  .use(logger())
+  .use(errorHandler())
   .use(cors({
     origin: process.env.CORS_ORIGIN || 'http://localhost:{{frontendPort}}',
     credentials: true,
   }))
+  .use(rateLimit())
+{{#if isSsr}}
+  .use(csrfProtection())
+{{/if}}
   .get('/api/health', () => ({ status: 'ok', version: '{{vaspVersion}}' }))
+  .use(vaspDiagnosticRoutes)
 {{#if hasAuth}}
   .use(authRoutes)
 {{/if}}
+{{#each middlewares}}
+{{#if (eq scope "global")}}
+  .use({{importAlias}})
+{{/if}}
+{{/each}}
 {{#each queries}}
   .use({{camelCase name}}Route)
 {{/each}}
 {{#each actions}}
   .use({{camelCase name}}Route)
 {{/each}}
+{{#each apis}}
+  .use({{camelCase name}}ApiRoute)
+{{/each}}
 {{#each cruds}}
   .use({{camelCase entity}}CrudRoutes)
 {{/each}}

package/templates/shared/server/middleware/errorHandler.hbs

@@ -0,0 +1,75 @@
+import { Elysia } from 'elysia'
+
+/**
+ * Standard error class for Vasp API routes.
+ * Throw this from any route handler — the errorHandler middleware will
+ * catch it and return a structured `{ ok: false, error: { ... } }` envelope.
+ *
+ * @example throw new VaspError('NOT_FOUND', 'Recipe not found', 404)
+ */
+export class VaspError extends Error {
+  constructor(
+    code{{#if isTypeScript}}: string{{/if}},
+    message{{#if isTypeScript}}: string{{/if}},
+    statusCode{{#if isTypeScript}}: number{{/if}} = 400,
+    hint{{#if isTypeScript}}?: string{{/if}},
+  ) {
+    super(message)
+    this.name = 'VaspError'
+    this.code = code
+    this.statusCode = statusCode
+    this.hint = hint
+  }
+}
+
+/**
+ * Global error handler + response envelope middleware.
+ *
+ * - `onError`       → catches thrown errors and returns `{ ok: false, error: { code, message, hint? } }`
+ * - `onAfterHandle` → wraps successful responses in `{ ok: true, data: ... }`
+ */
+export function errorHandler() {
+  return new Elysia({ name: 'vasp-error-handler' })
+    .onError({ as: 'global' }, ({ code, error, set }) => {
+      // VaspError — structured, expected error
+      if (error instanceof VaspError) {
+        set.status = error.statusCode
+        return {
+          ok: false,
+          error: {
+            code: error.code,
+            message: error.message,
+            ...(error.hint ? { hint: error.hint } : {}),
+          },
+        }
+      }
+
+      // Elysia built-in NOT_FOUND
+      if (code === 'NOT_FOUND') {
+        set.status = 404
+        return { ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } }
+      }
+
+      // Elysia validation error
+      if (code === 'VALIDATION') {
+        set.status = 400
+        return {
+          ok: false,
+          error: { code: 'VALIDATION_FAILED', message: error.message },
+        }
+      }
+
+      // Unexpected error — log and mask
+      console.error('[server error]', error)
+      set.status = 500
+      return {
+        ok: false,
+        error: { code: 'INTERNAL_ERROR', message: 'Internal server error' },
+      }
+    })
+    .onAfterHandle({ as: 'global' }, ({ response }) => {
+      // Already wrapped (e.g. from onError or explicit envelope)
+      if (response && typeof response === 'object' && 'ok' in response) return
+      return { ok: true, data: response }
+    })
+}

package/templates/shared/server/middleware/logger.hbs

@@ -0,0 +1,74 @@
+import { Elysia } from 'elysia'
+import crypto from 'node:crypto'
+
+const isDev = process.env.NODE_ENV !== 'production'
+
+const colors{{#if isTypeScript}}: Record<string, string>{{/if}} = {
+  GET: '\x1b[32m',    // green
+  POST: '\x1b[34m',   // blue
+  PUT: '\x1b[33m',    // yellow
+  PATCH: '\x1b[33m',  // yellow
+  DELETE: '\x1b[31m', // red
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+}
+
+function colorMethod(method{{#if isTypeScript}}: string{{/if}}){{#if isTypeScript}}: string{{/if}} {
+  return `${colors[method] ?? ''}${method}${colors.reset}`
+}
+
+function statusColor(status{{#if isTypeScript}}: number{{/if}}){{#if isTypeScript}}: string{{/if}} {
+  if (status < 300) return '\x1b[32m'
+  if (status < 400) return '\x1b[36m'
+  if (status < 500) return '\x1b[33m'
+  return '\x1b[31m'
+}
+
+/**
+ * Request tracing & logging middleware.
+ *
+ * - Assigns a unique `x-request-id` header to every request (UUID v4).
+ * - Logs method, path, status, and duration in dev mode.
+ * - The request ID is available in handlers via `store.requestId`.
+ */
+export function logger() {
+  return new Elysia({ name: 'vasp-logger' })
+    .derive({ as: 'scoped' }, ({ request }) => {
+      const requestId = request.headers.get('x-request-id') || crypto.randomUUID()
+      return { requestId, requestStart: performance.now() }
+    })
+    .onAfterHandle({ as: 'scoped' }, ({ request, requestId, requestStart, set }) => {
+      set.headers['x-request-id'] = requestId
+
+      if (!isDev) return
+
+      const duration = (performance.now() - requestStart).toFixed(1)
+      const url = new URL(request.url)
+      const status = typeof set.status === 'number' ? set.status : 200
+      const sc = statusColor(status)
+      console.log(
+        `${colors.dim}[${new Date().toISOString()}]${colors.reset} ` +
+        `${colorMethod(request.method)} ${url.pathname} ` +
+        `${sc}${status}${colors.reset} ${colors.dim}${duration}ms${colors.reset} ` +
+        `${colors.dim}rid:${requestId.slice(0, 8)}${colors.reset}`,
+      )
+    })
+    .onError({ as: 'scoped' }, ({ request, requestId, requestStart, set, error }) => {
+      set.headers['x-request-id'] = requestId
+
+      if (!isDev) return
+
+      const duration = (performance.now() - requestStart).toFixed(1)
+      const url = new URL(request.url)
+      const status = typeof set.status === 'number' ? set.status : 500
+      const sc = statusColor(status)
+      console.log(
+        `${colors.dim}[${new Date().toISOString()}]${colors.reset} ` +
+        `${colorMethod(request.method)} ${url.pathname} ` +
+        `${sc}${status}${colors.reset} ${colors.dim}${duration}ms${colors.reset} ` +
+        `${colors.dim}rid:${requestId.slice(0, 8)}${colors.reset} ` +
+        `${colors.bold}\x1b[31m${error.message}${colors.reset}`,
+      )
+    })
+}

package/templates/{templates/shared → shared}/server/middleware/rateLimit.hbs

@@ -1,4 +1,5 @@
 import { Elysia } from 'elysia'
+import { VaspError } from './errorHandler.{{ext}}'
 
 const MAX_REQUESTS = Number(process.env.RATE_LIMIT_MAX) || 100
 const WINDOW_MS = Number(process.env.RATE_LIMIT_WINDOW_MS) || 60_000
@@ -37,8 +38,7 @@ export function rateLimit() {
       set.headers['x-ratelimit-remaining'] = String(Math.max(0, MAX_REQUESTS - entry.count))
 
       if (entry.count > MAX_REQUESTS) {
-        set.status = 429
-        return { error: 'Too many requests. Please try again later.' }
+        throw new VaspError('RATE_LIMITED', 'Too many requests. Please try again later.', 429)
       }
     })
 }

package/templates/shared/server/routes/_vasp.hbs

@@ -0,0 +1,37 @@
+import { Elysia } from 'elysia'
+
+const isDev = process.env.NODE_ENV !== 'production'
+
+/**
+ * Vasp internal diagnostic routes.
+ *
+ * GET /api/_vasp/health — always available; returns uptime and version
+ * GET /api/_vasp/debug  — only in dev (NODE_ENV !== 'production'); returns process info
+ */
+export const vaspDiagnosticRoutes = new Elysia({ prefix: '/api/_vasp' })
+  .get('/health', ({ set }) => {
+    set.headers['cache-control'] = 'no-store'
+    return {
+      ok: true,
+      status: 'healthy',
+      version: '{{vaspVersion}}',
+      uptime: process.uptime(),
+      timestamp: new Date().toISOString(),
+    }
+  })
+  .get('/debug', ({ set }) => {
+    if (!isDev) {
+      set.status = 404
+      return { ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } }
+    }
+
+    set.headers['cache-control'] = 'no-store'
+    return {
+      ok: true,
+      env: process.env.NODE_ENV ?? 'unknown',
+      nodeVersion: process.version,
+      memoryMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+      pid: process.pid,
+      cwd: process.cwd(),
+    }
+  })

package/templates/shared/server/routes/actions/_action.hbs

@@ -1,13 +1,17 @@
 import { Elysia } from 'elysia'
 import { db } from '../../db/client.{{ext}}'
 {{#if requiresAuth}}
-import { requireAuth } from '../../auth/middleware.{{ext}}'
+import { requireAuth{{#if hasRoles}}, requireRole{{/if}} } from '../../auth/middleware.{{ext}}'
 {{/if}}
 import { {{namedExport}} } from '{{importPath fnSource ext}}'
 
 export const {{camelCase name}}Route = new Elysia()
 {{#if requiresAuth}}
+{{#if hasRoles}}
+  .use(requireRole([{{#each roles}}'{{this}}'{{#unless @last}}, {{/unless}}{{/each}}]))
+{{else}}
   .use(requireAuth)
+{{/if}}
   .post('/api/actions/{{camelCase name}}', async ({ body, user }) => {
     const result = await {{namedExport}}({ db, user, args: body })
     return result

package/templates/shared/server/routes/api/_api.hbs

@@ -0,0 +1,24 @@
+import { Elysia } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+{{#if requiresAuth}}
+import { requireAuth{{#if hasRoles}}, requireRole{{/if}} } from '../../auth/middleware.{{ext}}'
+{{/if}}
+import { {{namedExport}} } from '{{importPath fnSource ext}}'
+
+export const {{camelCase name}}ApiRoute = new Elysia()
+{{#if requiresAuth}}
+{{#if hasRoles}}
+  .use(requireRole([{{#each roles}}'{{this}}'{{#unless @last}}, {{/unless}}{{/each}}]))
+{{else}}
+  .use(requireAuth)
+{{/if}}
+  .{{lowerCase method}}('{{path}}', async ({ params, query, body, request, user, set }) => {
+    const result = await {{namedExport}}({ db, user, args: { params, query, body, request, set } })
+    return result
+  })
+{{else}}
+  .{{lowerCase method}}('{{path}}', async ({ params, query, body, request, set }) => {
+    const result = await {{namedExport}}({ db, args: { params, query, body, request, set } })
+    return result
+  })
+{{/if}}

package/templates/shared/server/routes/crud/_crud.hbs

@@ -1,42 +1,134 @@
 import { Elysia, t } from 'elysia'
 import { db } from '../../db/client.{{ext}}'
-import { eq } from 'drizzle-orm'
+import { safeParse } from 'valibot'
+import { eq, sql, asc, desc, and } from 'drizzle-orm'
 import { {{camelCase entity}}s } from '../../../drizzle/schema.{{ext}}'
+import { Create{{pascalCase entity}}Schema, Update{{pascalCase entity}}Schema } from '../../../shared/validation.{{ext}}'
+import { VaspError } from '../../middleware/errorHandler.{{ext}}'
 {{#if hasAuth}}
 import { requireAuth } from '../../auth/middleware.{{ext}}'
 {{/if}}
+{{#if hasRealtime}}
+import { publish{{pascalCase entity}} } from '../realtime/{{camelCase realtimeName}}.{{ext}}'
+{{/if}}
 
 export const {{camelCase entity}}CrudRoutes = new Elysia({ prefix: '/api/crud/{{camelCase entity}}' })
 {{#if hasAuth}}
   .use(requireAuth)
 {{/if}}
 {{#if (includes operations "list")}}
-  .get('/', async () => {
-    return db.select().from({{camelCase entity}}s)
+  .get('/', async ({ query }) => {
+    const limit = Math.min(Math.max(Number(query.limit) || 20, 1), 100)
+    const offset = Math.max(Number(query.offset) || 0, 0)
+
+{{#if hasRelations}}
+    const items = await db.query.{{camelCase entity}}s.findMany({
+      with: {
+{{#each withRelations}}
+        {{camelCase name}}: true,
+{{/each}}
+      },
+      limit,
+      offset,
+    })
+    const [countResult] = await db.select({ count: sql`count(*)::int` }).from({{camelCase entity}}s)
+    return { items, total: countResult?.count ?? 0, limit, offset }
+{{else}}
+    const table = {{camelCase entity}}s
+
+    // Multi-column sorting: orderBy=col1,col2 & dir=asc,desc
+    const orderByFields = (query.orderBy ?? 'id').split(',')
+    const directions = (query.dir ?? 'asc').split(',')
+    const orderClauses = orderByFields.map((field, i) => {
+      const col = table[field.trim()] ?? table.id
+      const dirFn = (directions[i] ?? directions[0] ?? 'asc').trim() === 'desc' ? desc : asc
+      return dirFn(col)
+    })
+
+    // Build WHERE conditions from filter.* query params
+    const conditions = []
+    for (const [key, value] of Object.entries(query)) {
+      if (!key.startsWith('filter.')) continue
+      const field = key.slice(7)
+      if (!table[field]) continue
+      conditions.push(eq(table[field], value))
+    }
+    const where = conditions.length > 0 ? and(...conditions) : undefined
+
+    const baseQuery = db.select().from(table)
+    const countQuery = db.select({ count: sql`count(*)::int` }).from(table)
+
+    const [data, countResult] = await Promise.all([
+      (where ? baseQuery.where(where) : baseQuery).orderBy(...orderClauses).limit(limit).offset(offset),
+      where ? countQuery.where(where) : countQuery,
+    ])
+
+    return { items: data, total: countResult[0]?.count ?? 0, limit, offset }
+{{/if}}
   })
 {{/if}}
 {{#if (includes operations "create")}}
   .post('/', async ({ body }) => {
-    const [created] = await db.insert({{camelCase entity}}s).values(body).returning()
+    const parsed = safeParse(Create{{pascalCase entity}}Schema, body)
+    if (!parsed.success) {
+      const firstIssue = parsed.issues?.[0]
+      throw new VaspError(
+        'VALIDATION_FAILED',
+        firstIssue?.message ?? 'Invalid request payload',
+        400,
+      )
+    }
+
+    const [created] = await db.insert({{camelCase entity}}s).values(parsed.output).returning()
+{{#if hasRealtime}}
+    publish{{pascalCase entity}}('created', created)
+{{/if}}
     return created
   })
 {{/if}}
-  .get('/:id', async ({ params: { id }, set }) => {
+  .get('/:id', async ({ params: { id } }) => {
+{{#if hasRelations}}
+    const item = await db.query.{{camelCase entity}}s.findFirst({
+      where: (t, { eq }) => eq(t.id, Number(id)),
+      with: {
+{{#each withRelations}}
+        {{camelCase name}}: true,
+{{/each}}
+      },
+    })
+{{else}}
     const [item] = await db.select().from({{camelCase entity}}s).where(eq({{camelCase entity}}s.id, Number(id))).limit(1)
-    if (!item) { set.status = 404; return { error: 'Not found' } }
+{{/if}}
+    if (!item) throw new VaspError('NOT_FOUND', '{{pascalCase entity}} not found', 404)
     return item
   })
 {{#if (includes operations "update")}}
-  .put('/:id', async ({ params: { id }, body, set }) => {
-    const [updated] = await db.update({{camelCase entity}}s).set(body).where(eq({{camelCase entity}}s.id, Number(id))).returning()
-    if (!updated) { set.status = 404; return { error: 'Not found' } }
+  .put('/:id', async ({ params: { id }, body }) => {
+    const parsed = safeParse(Update{{pascalCase entity}}Schema, body)
+    if (!parsed.success) {
+      const firstIssue = parsed.issues?.[0]
+      throw new VaspError(
+        'VALIDATION_FAILED',
+        firstIssue?.message ?? 'Invalid request payload',
+        400,
+      )
+    }
+
+    const [updated] = await db.update({{camelCase entity}}s).set(parsed.output).where(eq({{camelCase entity}}s.id, Number(id))).returning()
+    if (!updated) throw new VaspError('NOT_FOUND', '{{pascalCase entity}} not found', 404)
+{{#if hasRealtime}}
+    publish{{pascalCase entity}}('updated', updated)
+{{/if}}
     return updated
   })
 {{/if}}
 {{#if (includes operations "delete")}}
-  .delete('/:id', async ({ params: { id }, set }) => {
+  .delete('/:id', async ({ params: { id } }) => {
     const [deleted] = await db.delete({{camelCase entity}}s).where(eq({{camelCase entity}}s.id, Number(id))).returning()
-    if (!deleted) { set.status = 404; return { error: 'Not found' } }
+    if (!deleted) throw new VaspError('NOT_FOUND', '{{pascalCase entity}} not found', 404)
+{{#if hasRealtime}}
+    publish{{pascalCase entity}}('deleted', deleted)
+{{/if}}
     return { ok: true }
   })
 {{/if}}

package/templates/shared/server/routes/queries/_query.hbs

@@ -1,13 +1,17 @@
 import { Elysia } from 'elysia'
 import { db } from '../../db/client.{{ext}}'
 {{#if requiresAuth}}
-import { requireAuth } from '../../auth/middleware.{{ext}}'
+import { requireAuth{{#if hasRoles}}, requireRole{{/if}} } from '../../auth/middleware.{{ext}}'
 {{/if}}
 import { {{namedExport}} } from '{{importPath fnSource ext}}'
 
 export const {{camelCase name}}Route = new Elysia()
 {{#if requiresAuth}}
+{{#if hasRoles}}
+  .use(requireRole([{{#each roles}}'{{this}}'{{#unless @last}}, {{/unless}}{{/each}}]))
+{{else}}
   .use(requireAuth)
+{{/if}}
   .get('/api/queries/{{camelCase name}}', async ({ query, user }) => {
     const result = await {{namedExport}}({ db, user, args: query })
     return result

package/templates/shared/server/routes/realtime/_channel.hbs

@@ -1,30 +1,78 @@
 import { Elysia } from 'elysia'
+{{#if ../hasAuth}}
+import jwt from '@elysiajs/jwt'
+{{/if}}
 
-// In-process subscriber set for '{{name}}' channel
-// Swap this for a Redis adapter in production multi-instance deployments
-const subscribers = new Set()
+// Room-based subscriber map for '{{name}}' channel
+// Each room key maps to a set of connected WebSocket clients
+const rooms = new Map()
+
+function getRoom(roomId) {
+  if (!rooms.has(roomId)) rooms.set(roomId, new Set())
+  return rooms.get(roomId)
+}
 
 /**
- * Publish a realtime event to all connected subscribers of '{{name}}'.
+ * Publish a realtime event to all subscribers in a specific room of '{{name}}'.
  * Called automatically by CRUD mutation handlers.
  */
-export function publish{{pascalCase name}}(event, data) {
+export function publish{{pascalCase name}}(event, data, roomId = 'default') {
+  const room = rooms.get(roomId)
+  if (!room) return
+  const message = JSON.stringify({ channel: '{{camelCase name}}', room: roomId, event, data })
+  for (const ws of room) {
+    try { ws.send(message) } catch { room.delete(ws) }
+  }
+}
+
+/**
+ * Broadcast to all rooms of '{{name}}'.
+ */
+export function broadcast{{pascalCase name}}(event, data) {
   const message = JSON.stringify({ channel: '{{camelCase name}}', event, data })
-  for (const ws of subscribers) {
-    try { ws.send(message) } catch { subscribers.delete(ws) }
+  for (const [, room] of rooms) {
+    for (const ws of room) {
+      try { ws.send(message) } catch { room.delete(ws) }
+    }
   }
 }
 
 export const {{camelCase name}}Channel = new Elysia()
+{{#if ../hasAuth}}
+  .use(jwt({ name: 'jwt', secret: process.env.JWT_SECRET || 'vasp-dev-secret' }))
+{{/if}}
   .ws('/ws/{{camelCase name}}', {
+{{#if ../hasAuth}}
+    async beforeHandle({ jwt: jwtPlugin, request }) {
+      const url = new URL(request.url)
+      const token = url.searchParams.get('token')
+      if (!token) return new Response('Unauthorized', { status: 401 })
+      const payload = await jwtPlugin.verify(token)
+      if (!payload) return new Response('Unauthorized', { status: 401 })
+    },
+{{/if}}
     open(ws) {
-      subscribers.add(ws)
+      const room = ws.data?.query?.room ?? 'default'
+      getRoom(room).add(ws)
+      ws.data._room = room
     },
     message(ws, msg) {
-      // Echo back for debugging; extend for room-based subscriptions
+      // Client can switch rooms via { action: 'join', room: 'roomId' }
+      try {
+        const parsed = typeof msg === 'string' ? JSON.parse(msg) : msg
+        if (parsed.action === 'join' && parsed.room) {
+          const oldRoom = ws.data._room
+          if (oldRoom) rooms.get(oldRoom)?.delete(ws)
+          ws.data._room = parsed.room
+          getRoom(parsed.room).add(ws)
+          ws.send(JSON.stringify({ ack: 'joined', room: parsed.room }))
+          return
+        }
+      } catch { /* ignore parse errors */ }
       ws.send(JSON.stringify({ ack: msg }))
     },
     close(ws) {
-      subscribers.delete(ws)
+      const room = ws.data?._room
+      if (room) rooms.get(room)?.delete(ws)
     },
   })

package/templates/shared/shared/types.hbs

@@ -0,0 +1,58 @@
+// Auto-generated by Vasp — entity interfaces derived from .vasp schema
+// Re-run `vasp build` or restart `vasp start` to regenerate
+
+{{#each entities}}
+export interface {{pascalCase name}} {
+{{#each fields}}
+{{#if isRelation}}
+{{#if isArray}}
+  {{name}}: {{pascalCase relatedEntity}}[]
+{{else}}
+  {{name}}: {{pascalCase relatedEntity}}{{#if nullable}} | null{{/if}}
+  {{name}}Id: number{{#if nullable}} | null{{/if}}
+{{/if}}
+{{else}}
+  {{name}}: {{tsFieldType type enumValues}}{{#if nullable}} | null{{/if}}
+{{/if}}
+{{/each}}
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface Create{{pascalCase name}}Input {
+{{#each fields}}
+{{#if isRelation}}
+{{#unless isArray}}
+  {{name}}Id{{#if nullable}}?{{/if}}: number
+{{/unless}}
+{{else}}
+{{#unless (includes modifiers "id")}}
+  {{name}}{{#if nullable}}?{{/if}}: {{tsFieldType type enumValues}}{{#if nullable}} | null{{/if}}
+{{/unless}}
+{{/if}}
+{{/each}}
+}
+
+export interface Update{{pascalCase name}}Input {
+{{#each fields}}
+{{#if isRelation}}
+{{#unless isArray}}
+  {{name}}Id?: number{{#if nullable}} | null{{/if}}
+{{/unless}}
+{{else}}
+{{#unless (includes modifiers "id")}}
+  {{name}}?: {{tsFieldType type enumValues}}{{#if nullable}} | null{{/if}}
+{{/unless}}
+{{/if}}
+{{/each}}
+}
+
+{{/each}}
+{{#each queries}}
+export type {{pascalCase name}}Args = Record<string, unknown>
+export type {{pascalCase name}}Return = unknown
+{{/each}}
+{{#each actions}}
+export type {{pascalCase name}}Args = Record<string, unknown>
+export type {{pascalCase name}}Return = unknown
+{{/each}}

package/templates/shared/shared/validation.hbs

@@ -0,0 +1,20 @@
+import * as v from 'valibot'
+
+{{#each entities}}
+export const Create{{pascalCase name}}Schema = v.object({
+{{#each fields}}
+{{#if isRelation}}
+{{#unless isArray}}
+  {{name}}Id: {{valibotSchema "Int" nullable true}},
+{{/unless}}
+{{else}}
+{{#unless (includes modifiers "id")}}
+  {{name}}: {{valibotSchema type nullable true enumValues}},
+{{/unless}}
+{{/if}}
+{{/each}}
+})
+
+export const Update{{pascalCase name}}Schema = v.partial(Create{{pascalCase name}}Schema)
+
+{{/each}}

package/templates/shared/tests/actions/_action.test.js.hbs

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest'
+
+describe('{{pascalCase name}} action', () => {
+  it('adds generated action test scaffold', () => {
+    expect(true).toBe(true)
+  })
+})