vasp-cli 0.1.2 → 0.1.4

package/templates/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/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/templates/shared/bunfig.toml.hbs

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

package/templates/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/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/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/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/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/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/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/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/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() },
+  )

package/templates/templates/shared/server/routes/queries/_query.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)
+  .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}}

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

@@ -0,0 +1,30 @@
+import { Elysia } from 'elysia'
+
+// In-process subscriber set for '{{name}}' channel
+// Swap this for a Redis adapter in production multi-instance deployments
+const subscribers = new Set()
+
+/**
+ * Publish a realtime event to all connected subscribers of '{{name}}'.
+ * Called automatically by CRUD mutation handlers.
+ */
+export function publish{{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) }
+  }
+}
+
+export const {{camelCase name}}Channel = new Elysia()
+  .ws('/ws/{{camelCase name}}', {
+    open(ws) {
+      subscribers.add(ws)
+    },
+    message(ws, msg) {
+      // Echo back for debugging; extend for room-based subscriptions
+      ws.send(JSON.stringify({ ack: msg }))
+    },
+    close(ws) {
+      subscribers.delete(ws)
+    },
+  })

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

@@ -0,0 +1,9 @@
+import { Elysia } from 'elysia'
+{{#each realtimes}}
+import { {{camelCase name}}Channel } from './{{camelCase name}}.{{../ext}}'
+{{/each}}
+
+export const realtimeRoutes = new Elysia()
+{{#each realtimes}}
+  .use({{camelCase name}}Channel)
+{{/each}}

package/templates/templates/shared/tsconfig.json.hbs

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
+    "paths": {
+      "@src/*": ["./src/*"],
+      "@vasp-framework/client": ["./src/vasp/client/index.ts"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue", "server/**/*.ts", "drizzle/**/*.ts"],
+  "exclude": ["node_modules", "dist", ".vasp-gen"]
+}

package/templates/templates/spa/js/index.html.hbs

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{appTitle}}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

package/templates/templates/spa/js/src/App.vue.hbs

@@ -0,0 +1,3 @@
+<template>
+  <RouterView />
+</template>

package/templates/templates/spa/js/src/main.js.hbs

@@ -0,0 +1,9 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import router from './router/index.js'
+import { vaspPlugin } from './vasp/plugin.js'
+
+const app = createApp(App)
+app.use(router)
+app.use(vaspPlugin)
+app.mount('#app')

package/templates/templates/spa/js/src/router/index.js.hbs

@@ -0,0 +1,41 @@
+import { createRouter, createWebHistory } from 'vue-router'
+{{#if hasAuth}}
+import { useAuth } from '../vasp/auth.js'
+{{/if}}
+
+const routes = [
+{{#each routes}}
+  {
+    path: '{{path}}',
+    component: () => import('{{lookup ../pagesMap to}}'),
+  },
+{{/each}}
+{{#if hasAuth}}
+  {
+    path: '/login',
+    component: () => import('../pages/Login.vue'),
+  },
+  {
+    path: '/register',
+    component: () => import('../pages/Register.vue'),
+  },
+{{/if}}
+]
+
+const router = createRouter({
+  history: createWebHistory(),
+  routes,
+})
+
+{{#if hasAuth}}
+router.beforeEach(async (to) => {
+  const { user, checkAuth } = useAuth()
+  await checkAuth()
+  const publicPaths = ['/login', '/register']
+  if (!user.value && !publicPaths.includes(to.path)) {
+    return '/login'
+  }
+})
+{{/if}}
+
+export default router

package/templates/templates/spa/js/src/vasp/auth.js.hbs

@@ -0,0 +1,45 @@
+import { ref } from 'vue'
+import { $fetch } from 'ofetch'
+
+const user = ref(null)
+let checked = false
+
+const API = import.meta.env.VITE_API_URL || '/api'
+
+export function useAuth() {
+  async function checkAuth() {
+    if (checked) return
+    checked = true
+    try {
+      user.value = await $fetch(`${API}/auth/me`, { credentials: 'include' })
+    } catch {
+      user.value = null
+    }
+  }
+
+  async function login(username, password) {
+    user.value = await $fetch(`${API}/auth/login`, {
+      method: 'POST',
+      body: { username, password },
+      credentials: 'include',
+    })
+    return user.value
+  }
+
+  async function register(username, password, email) {
+    user.value = await $fetch(`${API}/auth/register`, {
+      method: 'POST',
+      body: { username, password, email },
+      credentials: 'include',
+    })
+    return user.value
+  }
+
+  async function logout() {
+    await $fetch(`${API}/auth/logout`, { method: 'POST', credentials: 'include' })
+    user.value = null
+    checked = false
+  }
+
+  return { user, checkAuth, login, register, logout }
+}

package/templates/templates/spa/js/src/vasp/client/actions.js.hbs

@@ -0,0 +1,15 @@
+// Auto-generated by Vasp — do not edit
+import { useVasp } from '@vasp-framework/runtime'
+
+{{#each actions}}
+/**
+ * Call the '{{name}}' action on the Vasp backend.
+ * @param {unknown} args - Arguments to pass to the action function
+ * @returns {Promise<unknown>}
+ */
+export async function {{camelCase name}}(args) {
+  const { $vasp } = useVasp()
+  return $vasp.action('{{camelCase name}}', args)
+}
+
+{{/each}}

package/templates/templates/spa/js/src/vasp/client/crud.js.hbs

@@ -0,0 +1,30 @@
+// Auto-generated by Vasp — do not edit
+import { $fetch } from 'ofetch'
+
+const API = import.meta.env.VITE_API_URL || '/api'
+
+{{#each cruds}}
+/**
+ * CRUD helpers for the '{{entity}}' entity.
+ */
+export function use{{pascalCase entity}}Crud() {
+  const base = `${API}/crud/{{camelCase entity}}`
+
+  return {
+{{#if (includes operations "list")}}
+    list: () => $fetch(base, { credentials: 'include' }),
+{{/if}}
+{{#if (includes operations "create")}}
+    create: (data) => $fetch(base, { method: 'POST', body: data, credentials: 'include' }),
+{{/if}}
+    get: (id) => $fetch(`${base}/${id}`, { credentials: 'include' }),
+{{#if (includes operations "update")}}
+    update: (id, data) => $fetch(`${base}/${id}`, { method: 'PUT', body: data, credentials: 'include' }),
+{{/if}}
+{{#if (includes operations "delete")}}
+    remove: (id) => $fetch(`${base}/${id}`, { method: 'DELETE', credentials: 'include' }),
+{{/if}}
+  }
+}
+
+{{/each}}

package/templates/templates/spa/js/src/vasp/client/index.js.hbs

@@ -0,0 +1,16 @@
+// Auto-generated by Vasp — do not edit directly
+// Re-run `vasp build` or restart `vasp start` to regenerate
+
+export { useVasp } from '@vasp-framework/runtime'
+{{#each queries}}
+export { {{camelCase name}} } from './queries.js'
+{{/each}}
+{{#each actions}}
+export { {{camelCase name}} } from './actions.js'
+{{/each}}
+{{#each cruds}}
+export { use{{pascalCase entity}}Crud } from './crud.js'
+{{/each}}
+{{#if hasRealtime}}
+export { useRealtime } from './realtime.js'
+{{/if}}

package/templates/templates/spa/js/src/vasp/client/queries.js.hbs

@@ -0,0 +1,15 @@
+// Auto-generated by Vasp — do not edit
+import { useVasp } from '@vasp-framework/runtime'
+
+{{#each queries}}
+/**
+ * Call the '{{name}}' query on the Vasp backend.
+ * @param {unknown} [args] - Arguments to pass to the query function
+ * @returns {Promise<unknown>}
+ */
+export async function {{camelCase name}}(args) {
+  const { $vasp } = useVasp()
+  return $vasp.query('{{camelCase name}}', args)
+}
+
+{{/each}}