vasp-cli 0.3.1 → 0.9.0

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

@@ -1,51 +0,0 @@
-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/templates/shared/auth/server/middleware.hbs

@@ -1,33 +0,0 @@
-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/templates/shared/auth/server/providers/github.hbs

@@ -1,48 +0,0 @@
-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/templates/shared/auth/server/providers/google.hbs

@@ -1,53 +0,0 @@
-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/templates/shared/auth/server/providers/usernameAndPassword.hbs

@@ -1,69 +0,0 @@
-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/templates/shared/bunfig.toml.hbs

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

package/templates/templates/shared/drizzle/schema.hbs

@@ -1,48 +0,0 @@
-import { pgTable, serial, text, integer, boolean, timestamp, doublePrecision } 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 crudsWithFields}}
-{{#if hasEntity}}
-// {{entity}} table — generated from entity block
-export const {{camelCase entity}}s = pgTable('{{camelCase entity}}s', {
-{{#each fields}}
-  {{camelCase name}}: {{{drizzleColumn name type modifiers}}},
-{{/each}}
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  updatedAt: timestamp('updated_at').defaultNow().notNull(),
-})
-{{else}}
-// {{entity}} table — no entity block found, 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}}
-{{#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/templates/shared/jobs/_job.hbs

@@ -1,34 +0,0 @@
-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)
-  })
-{{#if hasSchedule}}
-
-  // Register cron schedule: {{schedule}}
-  await boss.schedule(JOB_NAME, '{{schedule}}', {})
-{{/if}}
-}
-
-/**
- * Schedule a '{{name}}' job on demand.
- * @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, {
-    retryLimit: Number(process.env.JOB_RETRY_LIMIT) || 3,
-    retryDelay: Number(process.env.JOB_RETRY_DELAY) || 60,
-    retryBackoff: true,
-    expireInMinutes: Number(process.env.JOB_EXPIRE_MINUTES) || 15,
-  })
-}

package/templates/templates/shared/jobs/boss.hbs

@@ -1,15 +0,0 @@
-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/templates/shared/package.json.hbs

@@ -1,35 +0,0 @@
-{
-  "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}}",
-    "db:generate": "bunx drizzle-kit generate",
-    "db:migrate": "bunx drizzle-kit migrate",
-    "db:studio": "bunx drizzle-kit studio"
-  },
-  "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/templates/shared/server/db/client.hbs

@@ -1,12 +0,0 @@
-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/templates/shared/server/index.hbs

@@ -1,60 +0,0 @@
-import { Elysia } from 'elysia'
-import { cors } from '@elysiajs/cors'
-import { staticPlugin } from '@elysiajs/static'
-import { db } from './db/client.{{ext}}'
-import { rateLimit } from './middleware/rateLimit.{{ext}}'
-{{#if isSsr}}
-import { csrfProtection } from './middleware/csrf.{{ext}}'
-{{/if}}
-{{#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,
-  }))
-  .use(rateLimit())
-{{#if isSsr}}
-  .use(csrfProtection())
-{{/if}}
-  .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/templates/shared/server/routes/actions/_action.hbs

@@ -1,20 +0,0 @@
-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/templates/shared/server/routes/crud/_crud.hbs

@@ -1,86 +0,0 @@
-import { Elysia, t } from 'elysia'
-import { db } from '../../db/client.{{ext}}'
-import { eq, sql, asc, desc, and, ilike } from 'drizzle-orm'
-import { {{camelCase entity}}s } from '../../../drizzle/schema.{{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 ({ query }) => {
-    const limit = Math.min(Math.max(Number(query.limit) || 20, 1), 100)
-    const offset = Math.max(Number(query.offset) || 0, 0)
-
-    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 { data, total: countResult[0]?.count ?? 0, limit, offset }
-  })
-{{/if}}
-{{#if (includes operations "create")}}
-  .post('/', async ({ body }) => {
-    const [created] = await db.insert({{camelCase entity}}s).values(body).returning()
-{{#if hasRealtime}}
-    publish{{pascalCase entity}}('created', created)
-{{/if}}
-    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' } }
-{{#if hasRealtime}}
-    publish{{pascalCase entity}}('updated', updated)
-{{/if}}
-    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' } }
-{{#if hasRealtime}}
-    publish{{pascalCase entity}}('deleted', deleted)
-{{/if}}
-    return { ok: true }
-  })
-{{/if}}

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

@@ -1,12 +0,0 @@
-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() },
-  )

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

@@ -1,20 +0,0 @@
-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)
-  .get('/api/queries/{{camelCase name}}', async ({ query, user }) => {
-    const result = await {{namedExport}}({ db, user, args: query })
-    return result
-  })
-{{else}}
-  .get('/api/queries/{{camelCase name}}', async ({ query }) => {
-    const result = await {{namedExport}}({ db, args: query })
-    return result
-  })
-{{/if}}