create-mantiq 0.5.11 → 0.5.13

package/package.json

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

package/skeleton/.env.example

@@ -1,12 +1,57 @@
-APP_NAME=skeleton
+# Application
+APP_NAME=MantiqJS
 APP_ENV=local
 APP_DEBUG=true
+APP_KEY=
 APP_URL=http://localhost:3000
 APP_PORT=3000
-APP_KEY=
 
+# Database
 DB_CONNECTION=sqlite
 DB_DATABASE=database/database.sqlite
+# DB_HOST=127.0.0.1
+# DB_PORT=5432
+# DB_USERNAME=postgres
+# DB_PASSWORD=
 
-LOG_CHANNEL=stack
+# Session
+SESSION_DRIVER=memory
+SESSION_LIFETIME=120
+SESSION_COOKIE=mantiq_session
+
+# Cache
+CACHE_STORE=memory
+# REDIS_HOST=127.0.0.1
+# REDIS_PORT=6379
+# REDIS_PASSWORD=
+
+# Queue
 QUEUE_CONNECTION=sync
+
+# Mail
+MAIL_MAILER=log
+MAIL_FROM_ADDRESS=hello@example.com
+MAIL_FROM_NAME=${APP_NAME}
+# MAIL_HOST=localhost
+# MAIL_PORT=587
+# MAIL_USERNAME=
+# MAIL_PASSWORD=
+
+# Logging
+LOG_CHANNEL=stack
+
+# Hashing
+HASH_DRIVER=bcrypt
+BCRYPT_ROUNDS=10
+
+# Broadcasting
+BROADCAST_DRIVER=bun
+
+# Filesystem
+FILESYSTEM_DISK=local
+
+# Search
+# ALGOLIA_APP_ID=
+# ALGOLIA_SECRET=
+# MEILISEARCH_HOST=http://127.0.0.1:7700
+# MEILISEARCH_KEY=

package/skeleton/config/broadcasting.ts

@@ -0,0 +1,93 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Realtime Enabled
+  |--------------------------------------------------------------------------
+  |
+  | Master switch for the realtime server. When disabled, WebSocket and
+  | SSE endpoints are not registered and broadcast events are no-ops.
+  |
+  */
+  enabled: true,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Broadcast Driver
+  |--------------------------------------------------------------------------
+  |
+  | The default broadcast driver for sending real-time events to clients.
+  | The 'bun' driver works in-process with zero dependencies. Use 'redis'
+  | for multi-server deployments.
+  |
+  | Supported: 'bun', 'redis', 'log', 'null'
+  |
+  */
+  driver: env('BROADCAST_DRIVER', 'bun'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | WebSocket Server
+  |--------------------------------------------------------------------------
+  |
+  | Bun's native WebSocket server handles real-time connections. Clients
+  | connect to ws://host:port/<path>. The server sends heartbeat pings
+  | and closes idle connections after the timeout.
+  |
+  */
+  websocket: {
+    path: '/ws',
+    maxConnectionsPerUser: 10,  // Per-user limit (0 = unlimited)
+    maxConnections: 0,          // Total limit (0 = unlimited)
+    heartbeatInterval: 25_000,  // Ping interval (ms)
+    heartbeatTimeout: 10_000,   // Close if no pong after (ms)
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Server-Sent Events (SSE) Fallback
+  |--------------------------------------------------------------------------
+  |
+  | SSE provides a fallback for clients that can't use WebSockets
+  | (corporate proxies, older browsers). One-directional: server → client.
+  |
+  */
+  sse: {
+    enabled: true,
+    path: '/_sse',
+    keepAliveInterval: 15_000,  // Keep-alive ping interval (ms)
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Presence Channels
+  |--------------------------------------------------------------------------
+  |
+  | Presence channels track which users are currently subscribed.
+  | memberTtl controls how long a disconnected user stays in the member
+  | list before being removed (handles brief network interruptions).
+  |
+  */
+  presence: {
+    memberTtl: 30_000,  // Remove member after disconnect (ms)
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Redis Driver
+  |--------------------------------------------------------------------------
+  |
+  | When using the 'redis' broadcast driver, events are published to
+  | Redis pub/sub. This allows multiple server instances to broadcast
+  | to each other's connected clients.
+  |
+  */
+  redis: {
+    host: env('REDIS_HOST', '127.0.0.1'),
+    port: Number(env('REDIS_PORT', '6379')),
+    password: env('REDIS_PASSWORD', ''),
+    prefix: 'mantiq_realtime:',
+  },
+}

package/skeleton/routes/channels.ts

@@ -0,0 +1,23 @@
+/**
+ * Broadcast Channels
+ *
+ * Define authorization callbacks for broadcast channels here.
+ * Private and presence channels require authentication.
+ *
+ * @example
+ *   import { broadcast } from '@mantiq/core'
+ *
+ *   // Private channel — only the owner can listen
+ *   broadcast.channel('orders.{orderId}', (user, orderId) => {
+ *     return user.id === Order.find(orderId)?.user_id
+ *   })
+ *
+ *   // Presence channel — returns user info for member tracking
+ *   broadcast.channel('chat.{roomId}', (user, roomId) => {
+ *     return { id: user.id, name: user.name }
+ *   })
+ */
+
+export default function () {
+  // Define your broadcast channel authorization here
+}

package/skeleton/routes/console.ts

@@ -0,0 +1,24 @@
+/**
+ * Console Routes
+ *
+ * Define scheduled tasks and console-only commands here.
+ * These are loaded automatically by the Discoverer.
+ *
+ * @example
+ *   import { schedule } from '@mantiq/core'
+ *
+ *   // Run every hour
+ *   schedule.command('heartbeat:prune').hourly()
+ *
+ *   // Run daily at midnight
+ *   schedule.command('queue:prune-failed').daily()
+ *
+ *   // Custom closure
+ *   schedule.call(async () => {
+ *     console.log('Running cleanup...')
+ *   }).everyFiveMinutes()
+ */
+
+export default function () {
+  // Define your scheduled tasks here
+}

package/src/templates.ts

@@ -93,27 +93,68 @@ export function getTemplates(ctx: TemplateContext): Record<string, string> {
   }, null, 2) + '\n'
 
   // ── .env (dynamic — APP_KEY generated) ─────────────────────────────────
-  templates['.env'] = `APP_NAME=${ctx.name}
+  const envBody = (appKey: string) => `# Application
+APP_NAME=${ctx.name}
 APP_ENV=local
 APP_DEBUG=true
-APP_KEY=${ctx.appKey}
+APP_KEY=${appKey}
 APP_URL=http://localhost:3000
+APP_PORT=3000
 
+# Database
 DB_CONNECTION=sqlite
 DB_DATABASE=database/database.sqlite
-${ctx.kit ? '\nVITE_DEV_SERVER_URL=http://localhost:5173' : ''}
-`
+# DB_HOST=127.0.0.1
+# DB_PORT=5432
+# DB_USERNAME=postgres
+# DB_PASSWORD=
 
-  templates['.env.example'] = `APP_NAME=${ctx.name}
-APP_ENV=local
-APP_DEBUG=true
-APP_KEY=
-APP_URL=http://localhost:3000
+# Session
+SESSION_DRIVER=memory
+SESSION_LIFETIME=120
+SESSION_COOKIE=mantiq_session
 
-DB_CONNECTION=sqlite
-DB_DATABASE=database/database.sqlite
-${ctx.kit ? '\nVITE_DEV_SERVER_URL=http://localhost:5173' : ''}
+# Cache
+CACHE_STORE=memory
+# REDIS_HOST=127.0.0.1
+# REDIS_PORT=6379
+# REDIS_PASSWORD=
+
+# Queue
+QUEUE_CONNECTION=sync
+
+# Mail
+MAIL_MAILER=log
+MAIL_FROM_ADDRESS=hello@example.com
+MAIL_FROM_NAME=\${APP_NAME}
+# MAIL_HOST=localhost
+# MAIL_PORT=587
+# MAIL_USERNAME=
+# MAIL_PASSWORD=
+
+# Logging
+LOG_CHANNEL=stack
+
+# Hashing
+HASH_DRIVER=bcrypt
+BCRYPT_ROUNDS=10
+
+# Broadcasting
+BROADCAST_DRIVER=bun
+
+# Filesystem
+FILESYSTEM_DISK=local
+
+# Search
+# ALGOLIA_APP_ID=
+# ALGOLIA_SECRET=
+# MEILISEARCH_HOST=http://127.0.0.1:7700
+# MEILISEARCH_KEY=
+${ctx.kit ? '\n# Vite\nVITE_DEV_SERVER_URL=http://localhost:5173' : ''}
 `
 
+  templates['.env'] = envBody(ctx.appKey)
+  templates['.env.example'] = envBody('')
+
   return templates
 }

package/src/terminal.ts

@@ -33,6 +33,8 @@ export class Terminal {
     write(`   ${EMERALD}●${R}  ${BOLD}mantiq${R}   ${GRAY}│${R}   ${DIM}The Bun framework for artisans${R}\n`)
     write(`\n`)
     write(`   ${GRAY}───────────────────────────────────────────────${R}\n`)
+    const version = require('../package.json').version
+    write(`   ${DIM}v${version}${R}\n`)
     write('\n\n')
   }
 

package/stubs/manifest.json

@@ -1402,6 +1402,14 @@
       {
         "stub": "routes/web.ts.stub",
         "target": "routes/web.ts"
+      },
+      {
+        "stub": "routes/api.ts.stub",
+        "target": "routes/api.ts"
+      },
+      {
+        "stub": "config/app.ts.stub",
+        "target": "config/app.ts"
       }
     ],
     "placeholders": {

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/shared/config/app.ts.stub

@@ -0,0 +1,36 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Application Name
+  |--------------------------------------------------------------------------
+  */
+  name: env('APP_NAME', 'MantiqJS'),
+  env: env('APP_ENV', 'production'),
+  debug: env('APP_DEBUG', false),
+  key: env('APP_KEY', ''),
+  url: env('APP_URL', 'http://localhost:3000'),
+  port: Number(env('APP_PORT', '3000')),
+  basePath: import.meta.dir + '/..',
+
+  /*
+  |--------------------------------------------------------------------------
+  | Middleware Groups
+  |--------------------------------------------------------------------------
+  |
+  | Middleware groups are applied automatically based on the route file:
+  |   routes/web.ts → 'web' group (stateful: sessions, CSRF, cookies)
+  |   routes/api.ts → 'api' group (stateful: sessions, cookies — for SPA)
+  |
+  | The 'api' group includes sessions so the SPA can use cookie-based auth
+  | for API calls. CSRF is not included — the SPA sends the X-XSRF-TOKEN
+  | header instead (set by the web group on page load).
+  |
+  */
+  middlewareGroups: {
+    web: ['cors', 'encrypt.cookies', 'session', 'csrf'],
+    api: ['cors', 'encrypt.cookies', 'session', 'throttle'],
+  },
+}

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

@@ -0,0 +1,14 @@
+import type { Router } from '@mantiq/core'
+import { json } from '@mantiq/core'
+import { UserController } from '../app/Http/Controllers/UserController.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)
+  router.get('/users', [UserController, 'index']).middleware('auth')
+  router.post('/users', [UserController, 'store']).middleware('auth')
+  router.put('/users/:id', [UserController, 'update']).middleware('auth')
+  router.delete('/users/:id', [UserController, 'destroy']).middleware('auth')
+}

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

@@ -1,9 +1,7 @@
 import type { Router } from '@mantiq/core'
-import { json } 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 { UserController } from '../app/Http/Controllers/UserController.ts'
 
 export default function (router: Router) {
   router.get('/', [HomeController, 'index'])
@@ -22,11 +20,4 @@ export default function (router: Router) {
   router.post('/login', [AuthController, 'login'])
   router.post('/register', [AuthController, 'register'])
   router.post('/logout', [AuthController, 'logout']).middleware('auth')
-
-  // API endpoints (stateful — session auth via cookies)
-  router.get('/api/ping', () => json({ status: 'ok', timestamp: new Date().toISOString() }))
-  router.get('/api/users', [UserController, 'index']).middleware('auth')
-  router.post('/api/users', [UserController, 'store']).middleware('auth')
-  router.put('/api/users/:id', [UserController, 'update']).middleware('auth')
-  router.delete('/api/users/:id', [UserController, 'destroy']).middleware('auth')
 }