create-mantiq 0.5.16 → 0.5.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-mantiq",
-  "version": "0.5.16",
+  "version": "0.5.17",
   "description": "Scaffold a new MantiqJS application",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -188,6 +188,10 @@ if (kit) {
     { stub: 'api-only/routes/api.ts.stub', target: 'routes/api.ts' },
     { stub: 'shared/app/Http/Controllers/ApiAuthController.ts.stub', target: 'app/Http/Controllers/ApiAuthController.ts' },
     { stub: 'shared/app/Http/Controllers/UserController.ts.stub', target: 'app/Http/Controllers/UserController.ts' },
+    { stub: 'shared/app/Http/Requests/RegisterRequest.ts.stub', target: 'app/Http/Requests/RegisterRequest.ts' },
+    { stub: 'shared/app/Http/Requests/LoginRequest.ts.stub', target: 'app/Http/Requests/LoginRequest.ts' },
+    { stub: 'shared/app/Http/Requests/StoreUserRequest.ts.stub', target: 'app/Http/Requests/StoreUserRequest.ts' },
+    { stub: 'shared/app/Http/Requests/UpdateUserRequest.ts.stub', target: 'app/Http/Requests/UpdateUserRequest.ts' },
     { stub: 'shared/database/seeders/DatabaseSeeder.ts.stub', target: 'database/seeders/DatabaseSeeder.ts' },
     { stub: 'shared/database/factories/UserFactory.ts.stub', target: 'database/factories/UserFactory.ts' },
   ]

package/stubs/api-only/routes/api.ts.stub

@@ -2,19 +2,23 @@ import type { Router } from '@mantiq/core'
 import { json } from '@mantiq/core'
 import { ApiAuthController } from '../app/Http/Controllers/ApiAuthController.ts'
 import { UserController } from '../app/Http/Controllers/UserController.ts'
+import { RegisterRequest } from '../app/Http/Requests/RegisterRequest.ts'
+import { LoginRequest } from '../app/Http/Requests/LoginRequest.ts'
+import { StoreUserRequest } from '../app/Http/Requests/StoreUserRequest.ts'
+import { UpdateUserRequest } from '../app/Http/Requests/UpdateUserRequest.ts'
 
 export default function (router: Router) {
   router.get('/ping', () => json({ status: 'ok', timestamp: new Date().toISOString() }))
 
-  // Token auth — register/login return a bearer token
-  router.post('/register', [ApiAuthController, 'register'])
-  router.post('/login', [ApiAuthController, 'login'])
+  // Token auth — FormRequest auto-validates, controller receives validated data
+  router.post('/register', [ApiAuthController, 'register', RegisterRequest])
+  router.post('/login', [ApiAuthController, 'login', LoginRequest])
   router.post('/logout', [ApiAuthController, 'logout']).middleware('auth:api')
   router.get('/user', [ApiAuthController, 'user']).middleware('auth:api')
 
   // Users CRUD (protected)
   router.get('/users', [UserController, 'index']).middleware('auth:api')
-  router.post('/users', [UserController, 'store']).middleware('auth:api')
-  router.put('/users/:id', [UserController, 'update']).middleware('auth:api')
+  router.post('/users', [UserController, 'store', StoreUserRequest]).middleware('auth:api')
+  router.put('/users/:id', [UserController, 'update', UpdateUserRequest]).middleware('auth:api')
   router.delete('/users/:id', [UserController, 'destroy']).middleware('auth:api')
 }

package/stubs/manifest.json

@@ -1399,6 +1399,22 @@
         "stub": "app/Http/Controllers/UserController.ts.stub",
         "target": "app/Http/Controllers/UserController.ts"
       },
+      {
+        "stub": "app/Http/Requests/RegisterRequest.ts.stub",
+        "target": "app/Http/Requests/RegisterRequest.ts"
+      },
+      {
+        "stub": "app/Http/Requests/LoginRequest.ts.stub",
+        "target": "app/Http/Requests/LoginRequest.ts"
+      },
+      {
+        "stub": "app/Http/Requests/StoreUserRequest.ts.stub",
+        "target": "app/Http/Requests/StoreUserRequest.ts"
+      },
+      {
+        "stub": "app/Http/Requests/UpdateUserRequest.ts.stub",
+        "target": "app/Http/Requests/UpdateUserRequest.ts"
+      },
       {
         "stub": "routes/web.ts.stub",
         "target": "routes/web.ts"

package/stubs/react/src/App.tsx.stub

@@ -1,5 +1,7 @@
 import { useState, useCallback, useEffect } from 'react'
 
+declare global { interface Window { __MANTIQ_DATA__?: Record<string, any> } }
+
 interface MantiqAppProps {
   pages: Record<string, React.ComponentType<any>>
   initialData?: Record<string, any>
@@ -15,7 +17,7 @@ function initTheme() {
 initTheme()
 
 export function MantiqApp({ pages, initialData }: MantiqAppProps) {
-  const windowData = typeof window !== 'undefined' ? (window as any).__MANTIQ_DATA__ : {}
+  const windowData = typeof window !== 'undefined' ? window.__MANTIQ_DATA__ : {}
   const initial = initialData ?? windowData
   const [page, setPage] = useState<string>(initial._page ?? 'Login')
   const [data, setData] = useState<Record<string, any>>(initial)

package/stubs/react/src/lib/api.ts.stub

@@ -3,7 +3,9 @@ function getCookie(name: string): string | null {
   return match ? decodeURIComponent(match[1]!) : null
 }
 
-export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<{ ok: boolean; status: number; data: T }> {
+type ApiResult<T> = { ok: true; status: number; data: T } | { ok: false; status: number; data: null }
+
+export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<ApiResult<T>> {
   const headers: Record<string, string> = { Accept: 'application/json', ...(opts.headers as Record<string, string>) }
 
   // Attach XSRF token for CSRF protection on mutating requests
@@ -17,22 +19,23 @@ export async function api<T = any>(url: string, opts: RequestInit = {}): Promise
   // Session expired — redirect to login
   if (res.status === 401 || res.status === 419) {
     window.location.href = '/login'
-    return { ok: false, status: res.status, data: null as any }
+    return { ok: false, status: res.status, data: null }
   }
 
   const ct = res.headers.get('content-type') ?? ''
   const data = ct.includes('json') ? await res.json() : null
-  return { ok: res.ok, status: res.status, data }
+  if (!res.ok) return { ok: false, status: res.status, data: null }
+  return { ok: true, status: res.status, data }
 }
 
-export function post(url: string, body: object) {
-  return api(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function post<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function put(url: string, body: object) {
-  return api(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function put<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function del(url: string) {
-  return api(url, { method: 'DELETE' })
+export function del<T = any>(url: string) {
+  return api<T>(url, { method: 'DELETE' })
 }

package/stubs/shared/app/Http/Controllers/ApiAuthController.ts.stub

@@ -8,33 +8,27 @@ import { User } from '../../Models/User.ts'
  * Issues bearer tokens instead of session cookies.
  */
 export class ApiAuthController {
-  async register(request: MantiqRequest): Promise<Response> {
-    const body = await request.input() as { name?: string; email?: string; password?: string; device_name?: string }
-    if (!body.name || !body.email || !body.password) abort(422, 'Name, email and password are required.')
-    if (body.password!.length < 6) abort(422, 'Password must be at least 6 characters.')
-    if (await User.where('email', body.email).first()) abort(422, 'A user with this email already exists.')
+  async register(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
+    if (await User.where('email', data.email).first()) abort(422, 'A user with this email already exists.')
 
     const user = await User.create({
-      name: body.name,
-      email: body.email,
-      password: await hash(body.password!),
+      name: data.name,
+      email: data.email,
+      password: await hash(data.password),
     })
 
-    const { plainTextToken } = await (user as any).createToken(body.device_name ?? 'api')
+    const { plainTextToken } = await user.createToken(data.device_name ?? 'api')
 
     return json({ message: 'Registered.', user: user.toObject(), token: plainTextToken }, 201)
   }
 
-  async login(request: MantiqRequest): Promise<Response> {
-    const body = await request.input() as { email?: string; password?: string; device_name?: string }
-    if (!body.email || !body.password) abort(422, 'Email and password are required.')
-
-    const user = await User.where('email', body.email).first()
-    if (!user || !(await hashCheck(body.password!, user.getAuthPassword()))) {
+  async login(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
+    const user = await User.where('email', data.email).first()
+    if (!user || !(await hashCheck(data.password, user.getAuthPassword()))) {
       abort(401, 'Invalid credentials.')
     }
 
-    const { plainTextToken } = await (user as any).createToken(body.device_name ?? 'api')
+    const { plainTextToken } = await user!.createToken(data.device_name ?? 'api')
 
     return json({ message: 'Logged in.', user: user!.toObject(), token: plainTextToken })
   }
@@ -45,7 +39,7 @@ export class ApiAuthController {
     const user = await manager.guard('api').user()
 
     if (user) {
-      const token = (user as any).currentAccessToken?.()
+      const token = user.currentAccessToken?.()
       if (token) await token.delete()
     }
 
@@ -58,6 +52,6 @@ export class ApiAuthController {
     const user = await manager.guard('api').user()
     if (!user) abort(401, 'Unauthenticated.')
 
-    return json({ user: (user as any).toObject() })
+    return json({ user: user!.toObject() })
   }
 }

package/stubs/shared/app/Http/Controllers/AuthController.ts.stub

@@ -1,44 +1,37 @@
 import type { MantiqRequest } from '@mantiq/core'
-import { json, hash, hashCheck, abort } from '@mantiq/core'
+import { json, hash, abort } from '@mantiq/core'
 import { auth } from '@mantiq/auth'
 import { User } from '../../Models/User.ts'
 
 export class AuthController {
-  async register(request: MantiqRequest): Promise<Response> {
-    const body = await request.input() as { name?: string; email?: string; password?: string }
-    if (!body.name || !body.email || !body.password) abort(422, 'Name, email and password are required.')
-    if (body.password!.length < 6) abort(422, 'Password must be at least 6 characters.')
-
-    if (await User.where('email', body.email).first()) abort(422, 'A user with this email already exists.')
+  async register(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
+    if (await User.where('email', data.email).first()) abort(422, 'A user with this email already exists.')
 
     const user = await User.create({
-      name: body.name,
-      email: body.email,
-      password: await hash(body.password!),
+      name: data.name,
+      email: data.email,
+      password: await hash(data.password),
     })
 
     const manager = auth()
     manager.setRequest(request)
-    await manager.login(user as any)
+    await manager.login(user)
 
     return json({ message: 'Registered.', user: user.toObject() }, 201)
   }
 
-  async login(request: MantiqRequest): Promise<Response> {
-    const body = await request.input() as { email?: string; password?: string; remember?: boolean }
-    if (!body.email || !body.password) abort(422, 'Email and password are required.')
-
+  async login(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
     const manager = auth()
     manager.setRequest(request)
 
     const success = await manager.attempt(
-      { email: body.email!, password: body.password! },
-      body.remember ?? false,
+      { email: data.email, password: data.password },
+      data.remember ?? false,
     )
     if (!success) abort(401, 'Invalid credentials.')
 
     const user = await manager.user()
-    return json({ message: 'Logged in.', user })
+    return json({ message: 'Logged in.', user: user?.toObject() })
   }
 
   async logout(request: MantiqRequest): Promise<Response> {

package/stubs/shared/app/Http/Controllers/PageController.ts.stub

@@ -10,9 +10,9 @@ async function getUser(request: MantiqRequest) {
   const user = await manager.user()
   if (!user) return null
   return {
-    id: (user as any).getAttribute?.('id') ?? user.getAuthIdentifier(),
-    name: (user as any).getAttribute?.('name') ?? '',
-    email: (user as any).getAttribute?.('email') ?? '',
+    id: user.getAttribute('id') ?? user.getAuthIdentifier(),
+    name: user.getAttribute('name') ?? '',
+    email: user.getAttribute('email') ?? '',
   }
 }
 

package/stubs/shared/app/Http/Controllers/UserController.ts.stub

@@ -11,47 +11,41 @@ export class UserController {
     const sortDir = request.query('dir') === 'asc' ? 'asc' : 'desc'
 
     const baseQuery = () => search
-      ? User.query().where('name', 'LIKE', `%${search}%`).orWhere('email', 'LIKE', `%${search}%`)
+      ? User.where('name', 'LIKE', `%${search}%`).orWhere('email', 'LIKE', `%${search}%`)
       : User.query()
 
-    const total = await (User.query() as any).count() as number
-    const filteredTotal = await (baseQuery() as any).count() as number
-    const users = await (baseQuery() as any)
+    const total = await User.count()
+    const filteredTotal = await baseQuery().count()
+    const users = await baseQuery()
       .orderBy(sortBy, sortDir)
       .limit(perPage)
       .offset((page - 1) * perPage)
-      .get() as any[]
+      .get()
 
     return json({
-      data: users.map((u: any) => u.toObject()),
+      data: users.map(u => u.toObject()),
       meta: { total, filtered_total: filteredTotal, page, per_page: perPage, last_page: Math.ceil(filteredTotal / perPage) },
     })
   }
 
-  async store(request: MantiqRequest): Promise<Response> {
-    const body = await request.input() as Record<string, any>
-    if (!body?.name || !body?.email || !body?.password) abort(422, 'Name, email and password are required.')
-
-    const existing = await User.where('email', body.email).first()
-    if (existing) abort(422, 'Email already exists.')
+  async store(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
+    if (await User.where('email', data.email).first()) abort(422, 'Email already exists.')
 
     const user = await User.create({
-      name: body.name,
-      email: body.email,
-      password: await hash(body.password),
+      name: data.name,
+      email: data.email,
+      password: await hash(data.password),
     })
 
     return json({ data: user.toObject() }, 201)
   }
 
-  async update(request: MantiqRequest): Promise<Response> {
+  async update(request: MantiqRequest, data: Record<string, any>): Promise<Response> {
     const user = await User.find(Number(request.param('id')))
     if (!user) abort(404, 'User not found.')
-
-    const body = await request.input() as Record<string, any>
-    if (body.name) user.setAttribute('name', body.name)
-    if (body.email) user.setAttribute('email', body.email)
-    if (body.password) user.setAttribute('password', await hash(body.password))
+    if (data.name) user.setAttribute('name', data.name)
+    if (data.email) user.setAttribute('email', data.email)
+    if (data.password) user.setAttribute('password', await hash(data.password))
 
     await user.save()
     return json({ data: user.toObject() })

package/stubs/shared/app/Http/Requests/LoginRequest.ts.stub

@@ -0,0 +1,10 @@
+import { FormRequest } from '@mantiq/validation'
+
+export class LoginRequest extends FormRequest {
+  rules() {
+    return {
+      email: 'required|email',
+      password: 'required|string',
+    }
+  }
+}

package/stubs/shared/app/Http/Requests/RegisterRequest.ts.stub

@@ -0,0 +1,11 @@
+import { FormRequest } from '@mantiq/validation'
+
+export class RegisterRequest extends FormRequest {
+  rules() {
+    return {
+      name: 'required|string|max:255',
+      email: 'required|email|max:255',
+      password: 'required|string|min:6',
+    }
+  }
+}

package/stubs/shared/app/Http/Requests/StoreUserRequest.ts.stub

@@ -0,0 +1,11 @@
+import { FormRequest } from '@mantiq/validation'
+
+export class StoreUserRequest extends FormRequest {
+  rules() {
+    return {
+      name: 'required|string|max:255',
+      email: 'required|email|max:255',
+      password: 'required|string|min:6',
+    }
+  }
+}

package/stubs/shared/app/Http/Requests/UpdateUserRequest.ts.stub

@@ -0,0 +1,11 @@
+import { FormRequest } from '@mantiq/validation'
+
+export class UpdateUserRequest extends FormRequest {
+  rules() {
+    return {
+      name: 'string|max:255',
+      email: 'email|max:255',
+      password: 'string|min:6',
+    }
+  }
+}

package/stubs/shared/routes/api.ts.stub

@@ -1,14 +1,16 @@
 import type { Router } from '@mantiq/core'
 import { json } from '@mantiq/core'
 import { UserController } from '../app/Http/Controllers/UserController.ts'
+import { StoreUserRequest } from '../app/Http/Requests/StoreUserRequest.ts'
+import { UpdateUserRequest } from '../app/Http/Requests/UpdateUserRequest.ts'
 
 export default function (router: Router) {
   // Public
   router.get('/ping', () => json({ status: 'ok', timestamp: new Date().toISOString() }))
 
-  // Protected — session auth via cookies (stateful API for SPA)
+  // Protected — FormRequest auto-validates before controller runs
   router.get('/users', [UserController, 'index']).middleware('auth')
-  router.post('/users', [UserController, 'store']).middleware('auth')
-  router.put('/users/:id', [UserController, 'update']).middleware('auth')
+  router.post('/users', [UserController, 'store', StoreUserRequest]).middleware('auth')
+  router.put('/users/:id', [UserController, 'update', UpdateUserRequest]).middleware('auth')
   router.delete('/users/:id', [UserController, 'destroy']).middleware('auth')
 }

package/stubs/shared/routes/web.ts.stub

@@ -2,6 +2,8 @@ import type { Router } from '@mantiq/core'
 import { HomeController } from '../app/Http/Controllers/HomeController.ts'
 import { PageController } from '../app/Http/Controllers/PageController.ts'
 import { AuthController } from '../app/Http/Controllers/AuthController.ts'
+import { RegisterRequest } from '../app/Http/Requests/RegisterRequest.ts'
+import { LoginRequest } from '../app/Http/Requests/LoginRequest.ts'
 
 export default function (router: Router) {
   router.get('/', [HomeController, 'index'])
@@ -16,8 +18,8 @@ export default function (router: Router) {
   router.get('/account/security', [PageController, 'security']).middleware('auth')
   router.get('/account/preferences', [PageController, 'preferences']).middleware('auth')
 
-  // Auth actions
-  router.post('/login', [AuthController, 'login'])
-  router.post('/register', [AuthController, 'register'])
+  // Auth actions — FormRequest auto-validates before controller runs
+  router.post('/login', [AuthController, 'login', LoginRequest])
+  router.post('/register', [AuthController, 'register', RegisterRequest])
   router.post('/logout', [AuthController, 'logout']).middleware('auth')
 }

package/stubs/svelte/src/App.svelte.stub

@@ -9,7 +9,7 @@
     initialData?: Record<string, any>
   } = $props()
 
-  const windowData = typeof window !== 'undefined' ? (window as any).__MANTIQ_DATA__ : {}
+  const windowData = typeof window !== 'undefined' ? (window as Record<string, any>).__MANTIQ_DATA__ ?? {} : {}
   const bootstrapData = (() => initialData ?? windowData)()
 
   let currentPage = $state<string>(bootstrapData._page ?? 'Login')

package/stubs/svelte/src/lib/api.ts.stub

@@ -3,7 +3,9 @@ function getCookie(name: string): string | null {
   return match ? decodeURIComponent(match[1]!) : null
 }
 
-export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<{ ok: boolean; status: number; data: T }> {
+type ApiResult<T> = { ok: true; status: number; data: T } | { ok: false; status: number; data: null }
+
+export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<ApiResult<T>> {
   const headers: Record<string, string> = { Accept: 'application/json', ...(opts.headers as Record<string, string>) }
 
   // Attach XSRF token for CSRF protection on mutating requests
@@ -17,22 +19,23 @@ export async function api<T = any>(url: string, opts: RequestInit = {}): Promise
   // Session expired — redirect to login
   if (res.status === 401 || res.status === 419) {
     window.location.href = '/login'
-    return { ok: false, status: res.status, data: null as any }
+    return { ok: false, status: res.status, data: null }
   }
 
   const ct = res.headers.get('content-type') ?? ''
   const data = ct.includes('json') ? await res.json() : null
-  return { ok: res.ok, status: res.status, data }
+  if (!res.ok) return { ok: false, status: res.status, data: null }
+  return { ok: true, status: res.status, data }
 }
 
-export function post(url: string, body: object) {
-  return api(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function post<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function put(url: string, body: object) {
-  return api(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function put<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function del(url: string) {
-  return api(url, { method: 'DELETE' })
+export function del<T = any>(url: string) {
+  return api<T>(url, { method: 'DELETE' })
 }

package/stubs/svelte/src/main.ts.stub

@@ -1,10 +1,12 @@
+declare global { interface Window { __MANTIQ_DATA__?: Record<string, any> } }
+
 import './style.css'
 import { mount } from 'svelte'
 import App from './App.svelte'
 import { pages } from './pages.ts'
 
 const target = document.getElementById('app')!
-const data = (window as any).__MANTIQ_DATA__ ?? {}
+const data = window.__MANTIQ_DATA__ ?? {}
 
 // Clear SSR content and mount fresh — avoids hydration mismatches
 // with shadcn-svelte sidebar components

package/stubs/vue/src/App.vue.stub

@@ -6,7 +6,8 @@ const props = defineProps<{
   initialData?: Record<string, any>
 }>()
 
-const windowData = typeof window !== 'undefined' ? (window as any).__MANTIQ_DATA__ : {}
+declare global { interface Window { __MANTIQ_DATA__?: Record<string, any> } }
+const windowData = typeof window !== 'undefined' ? window.__MANTIQ_DATA__ ?? {} : {}
 const initial = props.initialData ?? windowData
 
 const currentPage = ref<string>(initial._page ?? 'Login')

package/stubs/vue/src/lib/api.ts.stub

@@ -3,7 +3,9 @@ function getCookie(name: string): string | null {
   return match ? decodeURIComponent(match[1]!) : null
 }
 
-export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<{ ok: boolean; status: number; data: T }> {
+type ApiResult<T> = { ok: true; status: number; data: T } | { ok: false; status: number; data: null }
+
+export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<ApiResult<T>> {
   const headers: Record<string, string> = { Accept: 'application/json', ...(opts.headers as Record<string, string>) }
 
   // Attach XSRF token for CSRF protection on mutating requests
@@ -17,22 +19,23 @@ export async function api<T = any>(url: string, opts: RequestInit = {}): Promise
   // Session expired — redirect to login
   if (res.status === 401 || res.status === 419) {
     window.location.href = '/login'
-    return { ok: false, status: res.status, data: null as any }
+    return { ok: false, status: res.status, data: null }
   }
 
   const ct = res.headers.get('content-type') ?? ''
   const data = ct.includes('json') ? await res.json() : null
-  return { ok: res.ok, status: res.status, data }
+  if (!res.ok) return { ok: false, status: res.status, data: null }
+  return { ok: true, status: res.status, data }
 }
 
-export function post(url: string, body: object) {
-  return api(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function post<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function put(url: string, body: object) {
-  return api(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function put<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function del(url: string) {
-  return api(url, { method: 'DELETE' })
+export function del<T = any>(url: string) {
+  return api<T>(url, { method: 'DELETE' })
 }

package/stubs/vue/src/main.ts.stub

@@ -1,10 +1,12 @@
+declare global { interface Window { __MANTIQ_DATA__?: Record<string, any> } }
+
 import './style.css'
 import { createApp, createSSRApp } from 'vue'
 import App from './App.vue'
 import { pages } from './pages.ts'
 
 const root = document.getElementById('app')!
-const data = (window as any).__MANTIQ_DATA__ ?? {}
+const data = window.__MANTIQ_DATA__ ?? {}
 
 const app = root.innerHTML.trim()
   ? createSSRApp(App, { pages, initialData: data })