vasp-cli 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vasp-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The Vasp CLI — declarative full-stack framework for Vue developers",
   "license": "Apache-2.0",
   "type": "module",
@@ -10,16 +10,14 @@
   "files": [
     "dist",
     "starters",
+    "templates",
     "README.md"
   ],
   "scripts": {
-    "build": "bun build ./bin/vasp.ts --target=bun --outfile=dist/vasp --minify --banner='#!/usr/bin/env bun' && chmod +x dist/vasp",
+    "build": "bun build ./bin/vasp.ts --target=bun --outfile=dist/vasp --minify --banner='#!/usr/bin/env bun' && chmod +x dist/vasp && cp -r ../../templates ./templates",
     "test": "vitest run"
   },
   "dependencies": {
-    "@vasp-framework/core": "workspace:*",
-    "@vasp-framework/generator": "workspace:*",
-    "@vasp-framework/parser": "workspace:*",
     "picocolors": "^1.1.0"
   },
   "devDependencies": {

package/templates/shared/.env.example.hbs

@@ -0,0 +1,14 @@
+DATABASE_URL=postgres://user:password@localhost:5432/{{kebabCase appName}}
+PORT={{backendPort}}
+VITE_API_URL=http://localhost:{{backendPort}}/api
+{{#if hasAuth}}
+JWT_SECRET=change-me-in-production
+{{#if (includes authMethods "google")}}
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+{{/if}}
+{{#if (includes authMethods "github")}}
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+{{/if}}
+{{/if}}

package/templates/shared/.gitignore.hbs

@@ -0,0 +1,8 @@
+node_modules
+dist
+.output
+.nuxt
+.vasp-gen
+.env
+.env.local
+*.log

package/templates/shared/auth/client/Login.vue.hbs

@@ -0,0 +1,46 @@
+<template>
+  <div class="auth-form">
+    <h2>Login</h2>
+    <form @submit.prevent="handleLogin">
+      <input v-model="username" type="text" placeholder="Username" required />
+      <input v-model="password" type="password" placeholder="Password" required />
+      <button type="submit" :disabled="loading">
+        \{{ loading ? 'Logging in...' : 'Login' }}
+      </button>
+      <p v-if="error" class="error">\{{ error }}</p>
+    </form>
+    <p>Don't have an account? <RouterLink to="/register">Register</RouterLink></p>
+{{#if (includes authMethods "google")}}
+    <a href="/auth/google" class="oauth-btn">Continue with Google</a>
+{{/if}}
+{{#if (includes authMethods "github")}}
+    <a href="/auth/github" class="oauth-btn">Continue with GitHub</a>
+{{/if}}
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue'
+import { useRouter } from 'vue-router'
+import { useAuth } from '../vasp/auth.js'
+
+const router = useRouter()
+const { login } = useAuth()
+const username = ref('')
+const password = ref('')
+const loading = ref(false)
+const error = ref('')
+
+async function handleLogin() {
+  loading.value = true
+  error.value = ''
+  try {
+    await login(username.value, password.value)
+    router.push('/')
+  } catch (err) {
+    error.value = err?.data?.error || 'Login failed'
+  } finally {
+    loading.value = false
+  }
+}
+</script>

package/templates/shared/auth/client/Register.vue.hbs

@@ -0,0 +1,42 @@
+<template>
+  <div class="auth-form">
+    <h2>Create Account</h2>
+    <form @submit.prevent="handleRegister">
+      <input v-model="username" type="text" placeholder="Username" required />
+      <input v-model="email" type="email" placeholder="Email (optional)" />
+      <input v-model="password" type="password" placeholder="Password (min 8 chars)" required />
+      <button type="submit" :disabled="loading">
+        \{{ loading ? 'Creating account...' : 'Register' }}
+      </button>
+      <p v-if="error" class="error">\{{ error }}</p>
+    </form>
+    <p>Already have an account? <RouterLink to="/login">Login</RouterLink></p>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue'
+import { useRouter } from 'vue-router'
+import { useAuth } from '../vasp/auth.js'
+
+const router = useRouter()
+const { register } = useAuth()
+const username = ref('')
+const email = ref('')
+const password = ref('')
+const loading = ref(false)
+const error = ref('')
+
+async function handleRegister() {
+  loading.value = true
+  error.value = ''
+  try {
+    await register(username.value, password.value, email.value || undefined)
+    router.push('/')
+  } catch (err) {
+    error.value = err?.data?.error || 'Registration failed'
+  } finally {
+    loading.value = false
+  }
+}
+</script>

package/templates/shared/auth/server/index.hbs

@@ -0,0 +1,51 @@
+import { Elysia } from 'elysia'
+import { jwt } from '@elysiajs/jwt'
+import { cookie } from '@elysiajs/cookie'
+import { db } from '../db/client.{{ext}}'
+import { users } from '../../drizzle/schema.{{ext}}'
+import { eq } from 'drizzle-orm'
+{{#if (includes authMethods "usernameAndPassword")}}
+import { usernameAndPasswordRoutes } from './providers/usernameAndPassword.{{ext}}'
+{{/if}}
+{{#if (includes authMethods "google")}}
+import { googleRoutes } from './providers/google.{{ext}}'
+{{/if}}
+{{#if (includes authMethods "github")}}
+import { githubRoutes } from './providers/github.{{ext}}'
+{{/if}}
+
+const JWT_SECRET = process.env.JWT_SECRET || 'change-me-in-production'
+
+export const authPlugin = new Elysia({ name: 'auth-plugin' })
+  .use(jwt({ name: 'jwt', secret: JWT_SECRET }))
+  .use(cookie())
+
+export const authRoutes = new Elysia({ prefix: '/auth' })
+  .use(authPlugin)
+{{#if (includes authMethods "usernameAndPassword")}}
+  .use(usernameAndPasswordRoutes)
+{{/if}}
+{{#if (includes authMethods "google")}}
+  .use(googleRoutes)
+{{/if}}
+{{#if (includes authMethods "github")}}
+  .use(githubRoutes)
+{{/if}}
+  .get('/me', async ({ jwt, cookie: { token }, set }) => {
+    const payload = await jwt.verify(token?.value ?? '')
+    if (!payload || typeof payload.userId !== 'number') {
+      set.status = 401
+      return { error: 'Unauthorized' }
+    }
+    const [user] = await db.select().from(users).where(eq(users.id, payload.userId)).limit(1)
+    if (!user) {
+      set.status = 401
+      return { error: 'User not found' }
+    }
+    const { passwordHash: _ph, ...safeUser } = user
+    return safeUser
+  })
+  .post('/logout', ({ cookie: { token }, set }) => {
+    token?.remove()
+    return { ok: true }
+  })

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

@@ -0,0 +1,33 @@
+import { Elysia } from 'elysia'
+import { jwt } from '@elysiajs/jwt'
+import { cookie } from '@elysiajs/cookie'
+import { db } from '../db/client.{{ext}}'
+import { users } from '../../drizzle/schema.{{ext}}'
+import { eq } from 'drizzle-orm'
+
+const JWT_SECRET = process.env.JWT_SECRET || 'change-me-in-production'
+
+/**
+ * requireAuth — Elysia plugin that verifies the JWT cookie and injects `user` into the context.
+ * Use on any route that requires authentication.
+ *
+ * @example
+ * new Elysia().use(requireAuth).get('/protected', ({ user }) => user)
+ */
+export const requireAuth = new Elysia({ name: 'require-auth' })
+  .use(jwt({ name: 'jwt', secret: JWT_SECRET }))
+  .use(cookie())
+  .derive(async ({ jwt, cookie: { token }, set }) => {
+    const payload = await jwt.verify(token?.value ?? '')
+    if (!payload || typeof payload.userId !== 'number') {
+      set.status = 401
+      throw new Error('Unauthorized')
+    }
+    const [user] = await db.select().from(users).where(eq(users.id, payload.userId)).limit(1)
+    if (!user) {
+      set.status = 401
+      throw new Error('User not found')
+    }
+    const { passwordHash: _ph, ...safeUser } = user
+    return { user: safeUser }
+  })

package/templates/shared/auth/server/providers/github.hbs

@@ -0,0 +1,48 @@
+import { Elysia } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+import { users } from '../../../drizzle/schema.{{ext}}'
+import { eq } from 'drizzle-orm'
+import { authPlugin } from '../index.{{ext}}'
+
+const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID || ''
+const GITHUB_CLIENT_SECRET = process.env.GITHUB_CLIENT_SECRET || ''
+const REDIRECT_URI = process.env.GITHUB_REDIRECT_URI || 'http://localhost:{{backendPort}}/auth/github/callback'
+
+export const githubRoutes = new Elysia()
+  .use(authPlugin)
+  .get('/github', ({ set }) => {
+    const params = new URLSearchParams({
+      client_id: GITHUB_CLIENT_ID,
+      redirect_uri: REDIRECT_URI,
+      scope: 'read:user user:email',
+    })
+    set.redirect = `https://github.com/login/oauth/authorize?${params}`
+  })
+  .get('/github/callback', async ({ query, jwt, cookie: { token }, set }) => {
+    const { code } = query
+    if (!code) { set.status = 400; return { error: 'Missing code' } }
+
+    const tokenRes = await fetch('https://github.com/login/oauth/access_token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+      body: JSON.stringify({ client_id: GITHUB_CLIENT_ID, client_secret: GITHUB_CLIENT_SECRET, code }),
+    })
+    const { access_token } = await tokenRes.json()
+
+    const userRes = await fetch('https://api.github.com/user', {
+      headers: { Authorization: `Bearer ${access_token}`, Accept: 'application/json' },
+    })
+    const ghUser = await userRes.json()
+    const githubId = String(ghUser.id)
+    const email = ghUser.email || `${ghUser.login}@github.local`
+
+    let [user] = await db.select().from(users).where(eq(users.githubId, githubId)).limit(1)
+    if (!user) {
+      ;[user] = await db.insert(users).values({ username: ghUser.login, email, githubId }).returning()
+    }
+    if (!user) { set.status = 500; return { error: 'Failed to create user' } }
+
+    const tokenValue = await jwt.sign({ userId: user.id })
+    token.set({ value: tokenValue, httpOnly: true, sameSite: 'lax', path: '/' })
+    set.redirect = '/'
+  })

package/templates/shared/auth/server/providers/google.hbs

@@ -0,0 +1,53 @@
+import { Elysia } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+import { users } from '../../../drizzle/schema.{{ext}}'
+import { eq } from 'drizzle-orm'
+import { authPlugin } from '../index.{{ext}}'
+
+const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID || ''
+const GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET || ''
+const REDIRECT_URI = process.env.GOOGLE_REDIRECT_URI || 'http://localhost:{{backendPort}}/auth/google/callback'
+
+export const googleRoutes = new Elysia()
+  .use(authPlugin)
+  .get('/google', ({ set }) => {
+    const params = new URLSearchParams({
+      client_id: GOOGLE_CLIENT_ID,
+      redirect_uri: REDIRECT_URI,
+      response_type: 'code',
+      scope: 'openid email profile',
+    })
+    set.redirect = `https://accounts.google.com/o/oauth2/v2/auth?${params}`
+  })
+  .get('/google/callback', async ({ query, jwt, cookie: { token }, set }) => {
+    const { code } = query
+    if (!code) { set.status = 400; return { error: 'Missing code' } }
+
+    // Exchange code for tokens
+    const tokenRes = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        code,
+        client_id: GOOGLE_CLIENT_ID,
+        client_secret: GOOGLE_CLIENT_SECRET,
+        redirect_uri: REDIRECT_URI,
+        grant_type: 'authorization_code',
+      }),
+    })
+    const tokenData = await tokenRes.json()
+    const idToken = tokenData.id_token
+    const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString())
+    const googleId = payload.sub
+    const email = payload.email
+
+    let [user] = await db.select().from(users).where(eq(users.googleId, googleId)).limit(1)
+    if (!user) {
+      ;[user] = await db.insert(users).values({ username: email, email, googleId }).returning()
+    }
+    if (!user) { set.status = 500; return { error: 'Failed to create user' } }
+
+    const tokenValue = await jwt.sign({ userId: user.id })
+    token.set({ value: tokenValue, httpOnly: true, sameSite: 'lax', path: '/' })
+    set.redirect = '/'
+  })

package/templates/shared/auth/server/providers/usernameAndPassword.hbs

@@ -0,0 +1,69 @@
+import { Elysia, t } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+import { users } from '../../../drizzle/schema.{{ext}}'
+import { eq } from 'drizzle-orm'
+import { authPlugin } from '../index.{{ext}}'
+
+async function hashPassword(password{{#if isTypeScript}}: string{{/if}}) {
+  const encoder = new TextEncoder()
+  const data = encoder.encode(password)
+  const hash = await crypto.subtle.digest('SHA-256', data)
+  return Buffer.from(hash).toString('hex')
+}
+
+async function verifyPassword(password{{#if isTypeScript}}: string{{/if}}, hash{{#if isTypeScript}}: string{{/if}}) {
+  return (await hashPassword(password)) === hash
+}
+
+export const usernameAndPasswordRoutes = new Elysia()
+  .use(authPlugin)
+  .post(
+    '/register',
+    async ({ body, jwt, cookie: { token }, set }) => {
+      const existing = await db.select().from(users).where(eq(users.username, body.username)).limit(1)
+      if (existing.length > 0) {
+        set.status = 400
+        return { error: 'Username already taken' }
+      }
+      const passwordHash = await hashPassword(body.password)
+      const [user] = await db
+        .insert(users)
+        .values({ username: body.username, email: body.email ?? null, passwordHash })
+        .returning()
+      if (!user) {
+        set.status = 500
+        return { error: 'Failed to create user' }
+      }
+      const tokenValue = await jwt.sign({ userId: user.id })
+      token.set({ value: tokenValue, httpOnly: true, sameSite: 'lax', path: '/' })
+      const { passwordHash: _ph, ...safeUser } = user
+      return safeUser
+    },
+    {
+      body: t.Object({
+        username: t.String({ minLength: 3 }),
+        password: t.String({ minLength: 8 }),
+        email: t.Optional(t.String({ format: 'email' })),
+      }),
+    },
+  )
+  .post(
+    '/login',
+    async ({ body, jwt, cookie: { token }, set }) => {
+      const [user] = await db.select().from(users).where(eq(users.username, body.username)).limit(1)
+      if (!user || !user.passwordHash || !(await verifyPassword(body.password, user.passwordHash))) {
+        set.status = 401
+        return { error: 'Invalid username or password' }
+      }
+      const tokenValue = await jwt.sign({ userId: user.id })
+      token.set({ value: tokenValue, httpOnly: true, sameSite: 'lax', path: '/' })
+      const { passwordHash: _ph, ...safeUser } = user
+      return safeUser
+    },
+    {
+      body: t.Object({
+        username: t.String(),
+        password: t.String(),
+      }),
+    },
+  )

package/templates/shared/bunfig.toml.hbs

@@ -0,0 +1,2 @@
+[install]
+exact = false

package/templates/shared/drizzle/schema.hbs

@@ -0,0 +1,37 @@
+import { pgTable, serial, text, timestamp, boolean } from 'drizzle-orm/pg-core'
+{{#if isTypeScript}}
+import type { InferSelectModel, InferInsertModel } from 'drizzle-orm'
+{{/if}}
+
+{{#if hasAuth}}
+// Users table — generated by Vasp auth system
+export const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  username: text('username').notNull().unique(),
+  email: text('email').unique(),
+  passwordHash: text('password_hash'),
+  googleId: text('google_id').unique(),
+  githubId: text('github_id').unique(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+})
+{{#if isTypeScript}}
+export type User = InferSelectModel<typeof users>
+export type NewUser = InferInsertModel<typeof users>
+{{/if}}
+
+{{/if}}
+{{#each cruds}}
+// {{entity}} table — add your columns below
+export const {{camelCase entity}}s = pgTable('{{camelCase entity}}s', {
+  id: serial('id').primaryKey(),
+  // TODO: Add your {{entity}} columns here
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+})
+{{#if ../isTypeScript}}
+export type {{pascalCase entity}} = InferSelectModel<typeof {{camelCase entity}}s>
+export type New{{pascalCase entity}} = InferInsertModel<typeof {{camelCase entity}}s>
+{{/if}}
+
+{{/each}}

package/templates/shared/jobs/_job.hbs

@@ -0,0 +1,24 @@
+import { getBoss } from './boss.{{ext}}'
+import { {{namedExport}} } from '{{importPath fnSource ext}}'
+
+const JOB_NAME = '{{camelCase name}}'
+
+/**
+ * Register the '{{name}}' job worker with PgBoss.
+ * Called once on server startup.
+ */
+export async function register{{pascalCase name}}Worker() {
+  const boss = await getBoss()
+  await boss.work(JOB_NAME, async (job) => {
+    await {{namedExport}}(job.data)
+  })
+}
+
+/**
+ * Schedule a '{{name}}' job.
+ * @param {unknown} data - Data to pass to the job handler
+ */
+export async function schedule{{pascalCase name}}(data) {
+  const boss = await getBoss()
+  return boss.send(JOB_NAME, data)
+}

package/templates/shared/jobs/boss.hbs

@@ -0,0 +1,15 @@
+import PgBoss from 'pg-boss'
+
+const connectionString = process.env.DATABASE_URL
+if (!connectionString) throw new Error('DATABASE_URL is required for PgBoss job queue')
+
+// Singleton PgBoss instance shared across all job workers
+let boss = null
+
+export async function getBoss() {
+  if (!boss) {
+    boss = new PgBoss(connectionString)
+    await boss.start()
+  }
+  return boss
+}

package/templates/shared/package.json.hbs

@@ -0,0 +1,32 @@
+{
+  "name": "{{kebabCase appName}}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vasp start",
+    "build": "vasp build",
+    "dev:server": "bun --hot server/index.{{ext}}",
+    "dev:client": "{{#if isSpa}}vite{{else}}nuxt dev{{/if}}"
+  },
+  "dependencies": {
+    "@vasp-framework/runtime": "^0.1.0",
+    "elysia": "^1.1.0",
+    "@elysiajs/cors": "^1.1.0",
+    "@elysiajs/static": "^1.1.0",
+    "drizzle-orm": "^0.36.0",
+    "postgres": "^3.4.0",
+    "ofetch": "^1.3.4",
+    "vue": "^3.5.0"{{#if isSpa}},
+    "vue-router": "^4.4.0"{{else}},
+    "nuxt": "^4.0.0"{{/if}}{{#if hasJobs}},
+    "pg-boss": "^10.0.0"{{/if}}
+  },
+  "devDependencies": {
+    "drizzle-kit": "^0.28.0"{{#if isSpa}},
+    "@vitejs/plugin-vue": "^5.2.0",
+    "vite": "^6.0.0"{{/if}}{{#if isTypeScript}},
+    "typescript": "^5.6.0",
+    "vue-tsc": "^2.0.0"{{/if}}
+  }
+}

package/templates/shared/server/db/client.hbs

@@ -0,0 +1,12 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+import * as schema from '../../drizzle/schema.{{ext}}'
+
+const connectionString = process.env.DATABASE_URL
+
+if (!connectionString) {
+  throw new Error('DATABASE_URL environment variable is required')
+}
+
+const client = postgres(connectionString)
+export const db = drizzle(client, { schema })

package/templates/shared/server/index.hbs

@@ -0,0 +1,52 @@
+import { Elysia } from 'elysia'
+import { cors } from '@elysiajs/cors'
+import { staticPlugin } from '@elysiajs/static'
+import { db } from './db/client.{{ext}}'
+{{#if hasAuth}}
+import { authRoutes } from './auth/index.{{ext}}'
+{{/if}}
+{{#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 cruds}}
+import { {{camelCase entity}}CrudRoutes } from './routes/crud/{{camelCase entity}}.{{../ext}}'
+{{/each}}
+{{#if hasRealtime}}
+import { realtimeRoutes } from './routes/realtime/index.{{ext}}'
+{{/if}}
+{{#each jobs}}
+import { {{camelCase name}}ScheduleRoute } from './routes/jobs/{{camelCase name}}Schedule.{{../ext}}'
+{{/each}}
+
+const PORT = Number(process.env.PORT) || {{backendPort}}
+
+const app = new Elysia()
+  .use(cors({
+    origin: process.env.CORS_ORIGIN || 'http://localhost:{{frontendPort}}',
+    credentials: true,
+  }))
+  .get('/api/health', () => ({ status: 'ok', version: '{{vaspVersion}}' }))
+{{#if hasAuth}}
+  .use(authRoutes)
+{{/if}}
+{{#each queries}}
+  .use({{camelCase name}}Route)
+{{/each}}
+{{#each actions}}
+  .use({{camelCase name}}Route)
+{{/each}}
+{{#each cruds}}
+  .use({{camelCase entity}}CrudRoutes)
+{{/each}}
+{{#if hasRealtime}}
+  .use(realtimeRoutes)
+{{/if}}
+{{#each jobs}}
+  .use({{camelCase name}}ScheduleRoute)
+{{/each}}
+  .listen(PORT)
+
+console.log(`🚀 Vasp backend running at http://localhost:${PORT}`)

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

@@ -0,0 +1,20 @@
+import { Elysia } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+{{#if requiresAuth}}
+import { requireAuth } from '../../auth/middleware.{{ext}}'
+{{/if}}
+import { {{namedExport}} } from '{{importPath fnSource ext}}'
+
+export const {{camelCase name}}Route = new Elysia()
+{{#if requiresAuth}}
+  .use(requireAuth)
+  .post('/api/actions/{{camelCase name}}', async ({ body, user }) => {
+    const result = await {{namedExport}}({ db, user, args: body })
+    return result
+  })
+{{else}}
+  .post('/api/actions/{{camelCase name}}', async ({ body }) => {
+    const result = await {{namedExport}}({ db, args: body })
+    return result
+  })
+{{/if}}

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

@@ -0,0 +1,42 @@
+import { Elysia, t } from 'elysia'
+import { db } from '../../db/client.{{ext}}'
+import { eq } from 'drizzle-orm'
+import { {{camelCase entity}}s } from '../../../drizzle/schema.{{ext}}'
+{{#if hasAuth}}
+import { requireAuth } from '../../auth/middleware.{{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)
+  })
+{{/if}}
+{{#if (includes operations "create")}}
+  .post('/', async ({ body }) => {
+    const [created] = await db.insert({{camelCase entity}}s).values(body).returning()
+    return created
+  })
+{{/if}}
+  .get('/:id', async ({ params: { id }, set }) => {
+    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' } }
+    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' } }
+    return updated
+  })
+{{/if}}
+{{#if (includes operations "delete")}}
+  .delete('/:id', async ({ params: { id }, set }) => {
+    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' } }
+    return { ok: true }
+  })
+{{/if}}

package/templates/shared/server/routes/jobs/_schedule.hbs

@@ -0,0 +1,12 @@
+import { Elysia, t } from 'elysia'
+import { schedule{{pascalCase name}} } from '../../../jobs/{{camelCase name}}.{{ext}}'
+
+export const {{camelCase name}}ScheduleRoute = new Elysia()
+  .post(
+    '/api/jobs/{{camelCase name}}/schedule',
+    async ({ body }) => {
+      const id = await schedule{{pascalCase name}}(body)
+      return { jobId: id }
+    },
+    { body: t.Unknown() },
+  )