create-mantiq 0.7.0 → 0.7.2

package/stubs/noauth/database/migrations/001_create_users_table.ts.stub

@@ -0,0 +1,17 @@
+import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class CreateUsersTable extends Migration {
+  override async up(schema: SchemaBuilder) {
+    await schema.create('users', (t) => {
+      t.id()
+      t.string('name', 100)
+      t.string('email', 150).unique()
+      t.timestamps()
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.dropIfExists('users')
+  }
+}

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

@@ -0,0 +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() }))
+
+  // Users CRUD — no auth middleware
+  router.get('/users', [UserController, 'index'])
+  router.post('/users', [UserController, 'store', StoreUserRequest])
+  router.put('/users/:id', [UserController, 'update', UpdateUserRequest])
+  router.delete('/users/:id', [UserController, 'destroy'])
+}

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

@@ -0,0 +1,15 @@
+import type { Router } from '@mantiq/core'
+import { HomeController } from '../app/Http/Controllers/HomeController.ts'
+import { PageController } from '../app/Http/Controllers/PageController.ts'
+
+export default function (router: Router) {
+  router.get('/', [HomeController, 'index'])
+
+  router.get('/dashboard', [PageController, 'dashboard'])
+  router.get('/users', [PageController, 'users'])
+
+  // Account settings
+  router.get('/account/profile', [PageController, 'profile'])
+  router.get('/account/security', [PageController, 'security'])
+  router.get('/account/preferences', [PageController, 'preferences'])
+}

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

@@ -0,0 +1,68 @@
+<script lang="ts">
+  import { onMount, onDestroy, setContext } from 'svelte'
+
+  let {
+    pages = {},
+    initialData = {},
+  }: {
+    pages?: Record<string, any>
+    initialData?: Record<string, any>
+  } = $props()
+
+  const windowData = typeof window !== 'undefined' ? (window as Record<string, any>).__MANTIQ_DATA__ ?? {} : {}
+  const bootstrapData = (() => initialData ?? windowData)()
+
+  let currentPage = $state<string>(bootstrapData._page ?? 'Dashboard')
+  let pageData = $state<Record<string, any>>(bootstrapData)
+
+  const PageComponent = $derived(pages[currentPage] ?? null)
+
+  // Initialize theme immediately to prevent flash
+  if (typeof window !== 'undefined') {
+    const theme = localStorage.getItem('theme') ||
+      (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
+    document.documentElement.classList.toggle('dark', theme === 'dark')
+  }
+
+  async function navigate(href: string) {
+    const res = await fetch(href, {
+      headers: { 'X-Mantiq': 'true', Accept: 'application/json' },
+    })
+
+    const newData = await res.json()
+    currentPage = newData._page
+    pageData = newData
+    history.pushState(null, '', newData._url)
+  }
+
+  setContext('navigate', navigate)
+
+  const spaRoutes = ['/dashboard', '/users']
+
+  function handleClick(e: MouseEvent) {
+    const anchor = (e.target as HTMLElement).closest('a')
+    const href = anchor?.getAttribute('href')
+    if (!href?.startsWith('/') || anchor?.target || e.ctrlKey || e.metaKey) return
+    if (!spaRoutes.some(r => href === r || href.startsWith(r + '?'))) return
+    e.preventDefault()
+    navigate(href)
+  }
+
+  function handlePop() { navigate(location.pathname) }
+
+  onMount(() => {
+    document.addEventListener('click', handleClick)
+    window.addEventListener('popstate', handlePop)
+  })
+
+  onDestroy(() => {
+    if (typeof window !== 'undefined') {
+      document.removeEventListener('click', handleClick)
+      window.removeEventListener('popstate', handlePop)
+    }
+  })
+</script>
+
+{#if PageComponent}
+  <PageComponent {...pageData} {navigate} />
+{/if}

package/stubs/noauth/svelte/src/pages.ts.stub

@@ -0,0 +1,7 @@
+import Dashboard from './pages/Dashboard.svelte'
+import Users from './pages/Users.svelte'
+
+export const pages: Record<string, any> = {
+  Dashboard,
+  Users,
+}

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

@@ -0,0 +1,62 @@
+<script setup lang="ts">
+import { ref, shallowRef, onMounted, onUnmounted, provide } from 'vue'
+
+const props = defineProps<{
+  pages: Record<string, any>
+  initialData?: Record<string, any>
+}>()
+
+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 ?? 'Dashboard')
+const pageData = ref<Record<string, any>>(initial)
+const PageComponent = shallowRef(props.pages[currentPage.value] ?? null)
+
+async function navigate(href: string) {
+  const res = await fetch(href, {
+    headers: { 'X-Mantiq': 'true', Accept: 'application/json' },
+  })
+
+  const newData = await res.json()
+  currentPage.value = newData._page
+  pageData.value = newData
+  PageComponent.value = props.pages[newData._page] ?? null
+  history.pushState(null, '', newData._url)
+}
+
+provide('navigate', navigate)
+
+const spaRoutes = ['/dashboard', '/users']
+
+function handleClick(e: MouseEvent) {
+  const anchor = (e.target as HTMLElement).closest('a')
+  const href = anchor?.getAttribute('href')
+  if (!href?.startsWith('/') || anchor?.target || e.ctrlKey || e.metaKey) return
+  if (!spaRoutes.some(r => href === r || href.startsWith(r + '?'))) return
+  e.preventDefault()
+  navigate(href)
+}
+
+function handlePop() { navigate(location.pathname + location.search) }
+
+onMounted(() => {
+  document.addEventListener('click', handleClick)
+  window.addEventListener('popstate', handlePop)
+
+  // Initialize theme: localStorage > system preference > dark default
+  const theme = localStorage.getItem('theme') ||
+    (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
+  document.documentElement.classList.toggle('dark', theme === 'dark')
+})
+
+onUnmounted(() => {
+  document.removeEventListener('click', handleClick)
+  window.removeEventListener('popstate', handlePop)
+})
+</script>
+
+<template>
+  <component :is="PageComponent" v-bind="pageData" :navigate="navigate" v-if="PageComponent" />
+</template>

package/stubs/noauth/vue/src/pages.ts.stub

@@ -0,0 +1,7 @@
+import Dashboard from './pages/Dashboard.vue'
+import Users from './pages/Users.vue'
+
+export const pages: Record<string, any> = {
+  Dashboard,
+  Users,
+}

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,8 +17,8 @@ function initTheme() {
 initTheme()
 
 export function MantiqApp({ pages, initialData }: MantiqAppProps) {
-  const windowData = typeof window !== 'undefined' ? (window as any).__MANTIQ_DATA__ : {}
-  const initial = initialData ?? windowData
+  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/components/layout/search-dialog.tsx.stub

@@ -7,7 +7,7 @@ import {
   Lock,
   Palette,
   BookOpen,
-  Github,
+  ExternalLink,
   FileText,
   ArrowRight,
 } from 'lucide-react'
@@ -30,7 +30,7 @@ const pages = [
   { title: 'Security', url: '/account/security', icon: Lock, group: 'Settings' },
   { title: 'Preferences', url: '/account/preferences', icon: Palette, group: 'Settings' },
   { title: 'Documentation', url: 'https://github.com/mantiqjs/mantiq#readme', icon: BookOpen, group: 'Links', external: true },
-  { title: 'GitHub', url: 'https://github.com/mantiqjs/mantiq', icon: Github, group: 'Links', external: true },
+  { title: 'GitHub', url: 'https://github.com/mantiqjs/mantiq', icon: ExternalLink, group: 'Links', external: true },
 ]
 
 export function SearchDialog({ open, onOpenChange, navigate }: SearchDialogProps) {

package/stubs/react/src/components/layout/sidebar-data.ts.stub

@@ -6,7 +6,7 @@ import {
   Lock,
   Palette,
   BookOpen,
-  Github,
+  ExternalLink,
   type LucideIcon,
 } from 'lucide-react'
 
@@ -36,7 +36,7 @@ export const sidebarData: NavGroup[] = [
     title: 'Documentation',
     items: [
       { title: 'Docs', url: 'https://github.com/mantiqjs/mantiq#readme', icon: BookOpen, external: true },
-      { title: 'GitHub', url: 'https://github.com/mantiqjs/mantiq', icon: Github, external: true },
+      { title: 'GitHub', url: 'https://github.com/mantiqjs/mantiq', icon: ExternalLink, external: true },
     ],
   },
   {

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

@@ -1,17 +1,41 @@
-export async function api<T = any>(url: string, opts: RequestInit = {}): Promise<{ ok: boolean; status: number; data: T }> {
-  const res = await fetch(url, { ...opts, headers: { Accept: 'application/json', ...opts.headers } })
+function getCookie(name: string): string | null {
+  const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`))
+  return match ? decodeURIComponent(match[1]!) : null
+}
+
+type ApiResult<T> = { ok: true; status: number; data: T } | { ok: false; status: number; data: any }
+
+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
+  if (opts.method && !['GET', 'HEAD', 'OPTIONS'].includes(opts.method)) {
+    const xsrf = getCookie('XSRF-TOKEN')
+    if (xsrf) headers['X-XSRF-TOKEN'] = xsrf
+  }
+
+  const res = await fetch(url, { ...opts, credentials: 'same-origin', headers })
 
   // 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 }
+  return { ok: true, status: res.status, data }
+}
+
+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<T = any>(url: string, body: object) {
+  return api<T>(url, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
 }
 
-export function post(url: string, body: object) {
-  return api(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+export function del<T = any>(url: string) {
+  return api<T>(url, { method: 'DELETE' })
 }

package/stubs/react/src/pages/Login.tsx.stub

@@ -11,8 +11,8 @@ interface LoginProps {
 }
 
 export default function Login({ appName = 'Mantiq', navigate }: LoginProps) {
-  const [email, setEmail] = useState('admin@example.com')
-  const [password, setPassword] = useState('password')
+  const [email, setEmail] = useState('')
+  const [password, setPassword] = useState('')
   const [error, setError] = useState('')
   const [loading, setLoading] = useState(false)
 
@@ -81,7 +81,7 @@ export default function Login({ appName = 'Mantiq', navigate }: LoginProps) {
                 value={email}
                 onChange={(e) => setEmail(e.target.value)}
                 required
-                placeholder="admin@example.com"
+                placeholder="you@example.com"
                 autoComplete="email"
               />
             </div>

package/stubs/react/src/pages/users/dialogs.tsx.stub

@@ -1,4 +1,5 @@
 import { useState, useEffect } from 'react'
+import { post, put, del } from '@/lib/api'
 import {
   Dialog,
   DialogContent,
@@ -50,15 +51,8 @@ export function AddUserDialog({
     setSubmitting(true)
     setError('')
     try {
-      const res = await fetch('/api/users', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(form),
-      })
-      if (!res.ok) {
-        const data = await res.json().catch(() => null)
-        throw new Error(data?.message ?? `Request failed (${res.status})`)
-      }
+      const { ok, data } = await post('/api/users', form)
+      if (!ok) throw new Error(data?.error ?? 'Request failed')
       reset()
       onOpenChange(false)
       onSuccess()
@@ -165,15 +159,8 @@ export function EditUserDialog({
     setSubmitting(true)
     setError('')
     try {
-      const res = await fetch(`/api/users/${user.id}`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(form),
-      })
-      if (!res.ok) {
-        const data = await res.json().catch(() => null)
-        throw new Error(data?.message ?? `Request failed (${res.status})`)
-      }
+      const { ok, data } = await put(`/api/users/${user.id}`, form)
+      if (!ok) throw new Error(data?.error ?? 'Request failed')
       onOpenChange(false)
       onSuccess()
     } catch (err: any) {
@@ -252,14 +239,8 @@ export function DeleteUserDialog({
     setSubmitting(true)
     setError('')
     try {
-      const res = await fetch(`/api/users/${user.id}`, {
-        method: 'DELETE',
-        headers: { 'Content-Type': 'application/json' },
-      })
-      if (!res.ok) {
-        const data = await res.json().catch(() => null)
-        throw new Error(data?.message ?? `Request failed (${res.status})`)
-      }
+      const { ok, data } = await del(`/api/users/${user.id}`)
+      if (!ok) throw new Error(data?.error ?? 'Request failed')
       onOpenChange(false)
       onSuccess()
     } catch (err: any) {

package/stubs/react/vite.config.ts.stub

@@ -1,10 +1,33 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
+import { mantiq } from '@mantiq/vite'
 import path from 'path'
+import { writeFileSync, unlinkSync } from 'node:fs'
 
-export default defineConfig({
-  plugins: [react(), tailwindcss()],
+export default defineConfig(async () => ({
+  plugins: [
+    react(),
+    tailwindcss(),
+    // Auto-discovers @mantiq/* plugins (Studio admin panel, etc.)
+    ...await mantiq(),
+    // Write public/hot so the backend knows the dev server is running
+    {
+      name: 'mantiq-hot',
+      configureServer(server) {
+        const hotPath = path.resolve(__dirname, 'public/hot')
+        server.httpServer?.once('listening', () => {
+          const addr = server.httpServer!.address()
+          const url = typeof addr === 'string' ? addr : `http://localhost:${addr?.port}`
+          writeFileSync(hotPath, url)
+        })
+        const cleanup = () => { try { unlinkSync(hotPath) } catch {} }
+        process.on('exit', cleanup)
+        process.on('SIGINT', () => { cleanup(); process.exit() })
+        process.on('SIGTERM', () => { cleanup(); process.exit() })
+      },
+    },
+  ],
   publicDir: false,
   resolve: {
     alias: {
@@ -19,4 +42,4 @@ export default defineConfig({
       input: ['src/main.tsx', 'src/style.css'],
     },
   },
-})
+}))

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

@@ -0,0 +1,57 @@
+import type { MantiqRequest } from '@mantiq/core'
+import { json, hash, hashCheck, abort } from '@mantiq/core'
+import { auth } from '@mantiq/auth'
+import { User } from '../../Models/User.ts'
+
+/**
+ * Sanctum-style token authentication for API-only apps.
+ * Issues bearer tokens instead of session cookies.
+ */
+export class ApiAuthController {
+  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: data.name,
+      email: data.email,
+      password: await hash(data.password),
+    })
+
+    const { plainTextToken } = await user.createToken(data.device_name ?? 'api')
+
+    return json({ message: 'Registered.', user: user.toObject(), token: plainTextToken }, 201)
+  }
+
+  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!.createToken(data.device_name ?? 'api')
+
+    return json({ message: 'Logged in.', user: user!.toObject(), token: plainTextToken })
+  }
+
+  async logout(request: MantiqRequest): Promise<Response> {
+    const manager = auth()
+    manager.setRequest(request)
+    const user = await manager.guard('api').user()
+
+    if (user) {
+      const token = user.currentAccessToken?.()
+      if (token) await token.delete()
+    }
+
+    return json({ message: 'Token revoked.' })
+  }
+
+  async user(request: MantiqRequest): Promise<Response> {
+    const manager = auth()
+    manager.setRequest(request)
+    const user = await manager.guard('api').user()
+    if (!user) abort(401, 'Unauthenticated.')
+
+    return json({ user: user!.toObject() })
+  }
+}

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

@@ -1,67 +1,43 @@
 import type { MantiqRequest } from '@mantiq/core'
-import { MantiqResponse, HashManager } 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) {
-      return MantiqResponse.json({ error: 'Name, email and password are required.' }, 422)
-    }
-    if (body.password.length < 6) {
-      return MantiqResponse.json({ error: 'Password must be at least 6 characters.' }, 422)
-    }
-
-    const existing = await User.where('email', body.email).first()
-    if (existing) {
-      return MantiqResponse.json({ error: 'A user with this email already exists.' }, 422)
-    }
-
-    const hasher = new HashManager({ bcrypt: { rounds: 10 } })
-    const hashed = await hasher.make(body.password)
+  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: hashed,
+      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 MantiqResponse.json({ message: 'Registered.', user: user.toObject() }, 201)
+    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) {
-      return MantiqResponse.json({ error: 'Email and password are required.' }, 422)
-    }
-
+  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) {
-      return MantiqResponse.json({ error: 'Invalid credentials.' }, 401)
-    }
+    if (!success) abort(401, 'Invalid credentials.')
 
     const user = await manager.user()
-    return MantiqResponse.json({ message: 'Logged in.', user })
+    return json({ message: 'Logged in.', user: user?.toObject() })
   }
 
   async logout(request: MantiqRequest): Promise<Response> {
     const manager = auth()
     manager.setRequest(request)
     await manager.logout()
-    return MantiqResponse.json({ message: 'Logged out.' })
+    return json({ message: 'Logged out.' })
   }
 }

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

@@ -0,0 +1,61 @@
+import type { MantiqRequest } from '@mantiq/core'
+import { json, abort, hash } from '@mantiq/core'
+import { User } from '../../Models/User.ts'
+
+export class UserController {
+  async index(request: MantiqRequest): Promise<Response> {
+    const search = request.query('search') ?? ''
+    const page = Math.max(1, Number(request.query('page') ?? 1))
+    const perPage = Math.min(100, Math.max(1, Number(request.query('per_page') ?? 10)))
+    const sortBy = request.query('sort') ?? 'created_at'
+    const sortDir = request.query('dir') === 'asc' ? 'asc' : 'desc'
+
+    const baseQuery = () => search
+      ? User.where('name', 'LIKE', `%${search}%`).orWhere('email', 'LIKE', `%${search}%`)
+      : User.query()
+
+    const total = await User.count()
+    const filteredTotal = await baseQuery().count()
+    const users = await baseQuery()
+      .orderBy(sortBy, sortDir)
+      .limit(perPage)
+      .offset((page - 1) * perPage)
+      .get()
+
+    return json({
+      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, 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: data.name,
+      email: data.email,
+      password: await hash(data.password),
+    })
+
+    return json({ data: user.toObject() }, 201)
+  }
+
+  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.')
+    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() })
+  }
+
+  async destroy(request: MantiqRequest): Promise<Response> {
+    const user = await User.find(Number(request.param('id')))
+    if (!user) abort(404, 'User not found.')
+
+    await user.delete()
+    return json({ success: true })
+  }
+}

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

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