create-mantiq 0.7.0 → 0.7.2

package/skeleton/config/notify.ts

@@ -0,0 +1,141 @@
+// import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Notification Channels
+  |--------------------------------------------------------------------------
+  |
+  | Configure notification delivery channels. Built-in channels:
+  | mail, database, broadcast, slack, sms, telegram, discord, webhook,
+  | whatsapp, firebase, imessage, rcs
+  |
+  | "mail", "database", and "broadcast" work out of the box with no
+  | additional config. The channels below require external credentials.
+  |
+  */
+  channels: {
+
+    /*
+    |----------------------------------------------------------------------
+    | Slack
+    |----------------------------------------------------------------------
+    |
+    | Send notifications to Slack via webhook URL or Bot API token.
+    | Webhook: paste the Incoming Webhook URL from Slack.
+    | Bot: create a Slack App and use the Bot User OAuth Token.
+    |
+    */
+    // slack: {
+    //   webhookUrl: env('SLACK_WEBHOOK_URL', ''),
+    //   token: env('SLACK_BOT_TOKEN', ''),
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | SMS (Twilio / Vonage)
+    |----------------------------------------------------------------------
+    |
+    | Send SMS notifications via Twilio or Vonage (Nexmo).
+    |
+    | Supported drivers: 'twilio', 'vonage'
+    |
+    */
+    // sms: {
+    //   driver: 'twilio' as const,
+    //   twilio: {
+    //     sid: env('TWILIO_SID', ''),
+    //     token: env('TWILIO_TOKEN', ''),
+    //     from: env('TWILIO_FROM', ''),
+    //   },
+    //   // vonage: {
+    //   //   apiKey: env('VONAGE_API_KEY', ''),
+    //   //   apiSecret: env('VONAGE_API_SECRET', ''),
+    //   //   from: env('VONAGE_FROM', ''),
+    //   // },
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | Telegram
+    |----------------------------------------------------------------------
+    |
+    | Send notifications via Telegram Bot API.
+    | Create a bot with @BotFather and paste the token here.
+    |
+    */
+    // telegram: {
+    //   botToken: env('TELEGRAM_BOT_TOKEN', ''),
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | Discord
+    |----------------------------------------------------------------------
+    |
+    | Send notifications to Discord channels via webhook URL.
+    | Create a webhook in Channel Settings → Integrations → Webhooks.
+    |
+    | Note: Discord webhookUrl is set per-notification, not globally.
+    |
+    */
+
+    /*
+    |----------------------------------------------------------------------
+    | WhatsApp (Meta Business API)
+    |----------------------------------------------------------------------
+    |
+    | Send WhatsApp messages via the Meta Business Platform API.
+    | Requires a verified WhatsApp Business Account.
+    |
+    */
+    // whatsapp: {
+    //   accessToken: env('WHATSAPP_ACCESS_TOKEN', ''),
+    //   phoneNumberId: env('WHATSAPP_PHONE_NUMBER_ID', ''),
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | Firebase Cloud Messaging (FCM)
+    |----------------------------------------------------------------------
+    |
+    | Send push notifications to mobile and web apps via Firebase.
+    | Provide either a static accessToken or a serviceAccountKey JSON
+    | string for automatic token generation.
+    |
+    */
+    // firebase: {
+    //   projectId: env('FIREBASE_PROJECT_ID', ''),
+    //   serviceAccountKey: env('FIREBASE_SERVICE_ACCOUNT_KEY', ''),
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | Apple iMessage (Business Chat)
+    |----------------------------------------------------------------------
+    |
+    | Send iMessage notifications via Apple Business Chat service.
+    | Requires an Apple Business Chat account and service endpoint.
+    |
+    */
+    // imessage: {
+    //   serviceUrl: env('IMESSAGE_SERVICE_URL', ''),
+    //   authToken: env('IMESSAGE_AUTH_TOKEN', ''),
+    // },
+
+    /*
+    |----------------------------------------------------------------------
+    | RCS (Rich Communication Services)
+    |----------------------------------------------------------------------
+    |
+    | Send rich messages via RCS Business Messaging API.
+    | Supports rich cards, carousels, and suggested actions.
+    |
+    */
+    // rcs: {
+    //   agentId: env('RCS_AGENT_ID', ''),
+    //   accessToken: env('RCS_ACCESS_TOKEN', ''),
+    // },
+  },
+}

package/skeleton/config/queue.ts

@@ -0,0 +1,59 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Queue Connection
+  |--------------------------------------------------------------------------
+  |
+  | The default queue connection used when dispatching jobs. The "sync"
+  | driver processes jobs immediately during the request — no background
+  | worker needed. Switch to "sqlite" for persistent background processing.
+  |
+  | Supported: 'sync', 'sqlite'
+  |
+  */
+  default: env('QUEUE_CONNECTION', 'sync'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Queue Connections
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure the connection information for each queue
+  | backend used by your application.
+  |
+  | Run workers with: bun mantiq queue:work
+  |
+  */
+  connections: {
+    // Synchronous — jobs run inline (no background worker needed)
+    sync: {
+      driver: 'sync' as const,
+    },
+
+    // SQLite — persistent queue stored in a local database file
+    sqlite: {
+      driver: 'sqlite' as const,
+      database: import.meta.dir + '/../database/queue.sqlite',
+      table: 'jobs',
+      retryAfter: 60,  // Seconds before a stalled job is retried
+    },
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Failed Queue Jobs
+  |--------------------------------------------------------------------------
+  |
+  | These options configure the behavior of failed queue job logging so you
+  | can study why certain jobs have failed. Inspect with: bun mantiq queue:failed
+  |
+  */
+  failed: {
+    driver: 'sqlite' as const,
+    database: import.meta.dir + '/../database/queue.sqlite',
+    table: 'failed_jobs',
+  },
+}

package/skeleton/config/search.ts

@@ -0,0 +1,96 @@
+// import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Search Engine
+  |--------------------------------------------------------------------------
+  |
+  | The default search engine used when performing full-text searches on
+  | models with the Searchable trait. The "collection" engine works
+  | in-memory with no external dependencies — ideal for development.
+  |
+  | Supported: 'collection', 'database', 'algolia', 'meilisearch',
+  |            'typesense', 'elasticsearch'
+  |
+  */
+  default: 'collection',
+
+  /*
+  |--------------------------------------------------------------------------
+  | Index Prefix
+  |--------------------------------------------------------------------------
+  |
+  | This prefix is added to all search index names. Useful to avoid
+  | collisions when multiple applications share the same search service.
+  |
+  */
+  prefix: '',
+
+  /*
+  |--------------------------------------------------------------------------
+  | Queue Indexing
+  |--------------------------------------------------------------------------
+  |
+  | When true, model index updates are dispatched to the queue for
+  | background processing, keeping your request cycle fast.
+  |
+  */
+  queue: false,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Soft Delete Behavior
+  |--------------------------------------------------------------------------
+  |
+  | When true, soft-deleted models remain in the search index and can
+  | be included in search results.
+  |
+  */
+  softDelete: false,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Search Engines
+  |--------------------------------------------------------------------------
+  |
+  | Configure the search engine backends available to your application.
+  | Uncomment and configure the engines you need.
+  |
+  */
+  engines: {
+    // In-memory — no external service needed (development)
+    collection: {
+      driver: 'collection' as const,
+    },
+
+    // SQL LIKE queries — uses your existing database
+    database: {
+      driver: 'database' as const,
+    },
+
+    // Algolia — hosted search API (https://algolia.com)
+    // algolia: {
+    //   driver: 'algolia' as const,
+    //   applicationId: env('ALGOLIA_APP_ID', ''),
+    //   apiKey: env('ALGOLIA_SECRET', ''),
+    // },
+
+    // Meilisearch — open-source (https://meilisearch.com)
+    // meilisearch: {
+    //   driver: 'meilisearch' as const,
+    //   host: env('MEILISEARCH_HOST', 'http://127.0.0.1:7700'),
+    //   apiKey: env('MEILISEARCH_KEY', ''),
+    // },
+
+    // Typesense — open-source (https://typesense.org)
+    // typesense: {
+    //   driver: 'typesense' as const,
+    //   host: env('TYPESENSE_HOST', 'localhost'),
+    //   port: Number(env('TYPESENSE_PORT', '8108')),
+    //   apiKey: env('TYPESENSE_API_KEY', ''),
+    //   protocol: 'http',
+    // },
+  },
+}

package/skeleton/config/services.ts

@@ -0,0 +1,110 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Third-Party Services
+  |--------------------------------------------------------------------------
+  |
+  | Centralized credentials for external services used by your application.
+  | Other config files (mail, notify, filesystem, search) reference these
+  | same env vars, but this file gives you a single place to see all
+  | third-party integrations at a glance.
+  |
+  */
+
+  /*
+  |--------------------------------------------------------------------------
+  | AWS (S3, SES, etc.)
+  |--------------------------------------------------------------------------
+  */
+  aws: {
+    accessKeyId: env('AWS_ACCESS_KEY_ID', ''),
+    secretAccessKey: env('AWS_SECRET_ACCESS_KEY', ''),
+    region: env('AWS_REGION', 'us-east-1'),
+    bucket: env('AWS_BUCKET', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Stripe
+  |--------------------------------------------------------------------------
+  */
+  stripe: {
+    key: env('STRIPE_KEY', ''),
+    secret: env('STRIPE_SECRET', ''),
+    webhookSecret: env('STRIPE_WEBHOOK_SECRET', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Resend
+  |--------------------------------------------------------------------------
+  */
+  resend: {
+    apiKey: env('RESEND_API_KEY', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Slack
+  |--------------------------------------------------------------------------
+  */
+  slack: {
+    webhookUrl: env('SLACK_WEBHOOK_URL', ''),
+    botToken: env('SLACK_BOT_TOKEN', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Twilio (SMS)
+  |--------------------------------------------------------------------------
+  */
+  twilio: {
+    sid: env('TWILIO_SID', ''),
+    token: env('TWILIO_TOKEN', ''),
+    from: env('TWILIO_FROM', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Telegram
+  |--------------------------------------------------------------------------
+  */
+  telegram: {
+    botToken: env('TELEGRAM_BOT_TOKEN', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Firebase
+  |--------------------------------------------------------------------------
+  */
+  firebase: {
+    projectId: env('FIREBASE_PROJECT_ID', ''),
+    serviceAccountKey: env('FIREBASE_SERVICE_ACCOUNT_KEY', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Algolia
+  |--------------------------------------------------------------------------
+  */
+  algolia: {
+    applicationId: env('ALGOLIA_APP_ID', ''),
+    apiKey: env('ALGOLIA_SECRET', ''),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Redis
+  |--------------------------------------------------------------------------
+  */
+  redis: {
+    url: env('REDIS_URL', ''),
+    host: env('REDIS_HOST', '127.0.0.1'),
+    port: Number(env('REDIS_PORT', '6379')),
+    password: env('REDIS_PASSWORD', ''),
+  },
+}

package/skeleton/config/session.ts

@@ -0,0 +1,84 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Session Driver
+  |--------------------------------------------------------------------------
+  |
+  | This option controls the default session "driver" used by requests.
+  | The "memory" driver is fast but sessions are lost on restart. Use
+  | "file" for persistence across server restarts.
+  |
+  | Supported: 'memory', 'file', 'cookie'
+  |
+  */
+  driver: env('SESSION_DRIVER', 'memory'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Session Lifetime
+  |--------------------------------------------------------------------------
+  |
+  | The number of minutes a session may remain idle before it expires.
+  |
+  */
+  lifetime: Number(env('SESSION_LIFETIME', '120')),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Session Cookie Name
+  |--------------------------------------------------------------------------
+  |
+  | The name of the cookie used to identify a session instance by ID.
+  | Change this if running multiple MantiqJS apps on the same domain.
+  |
+  */
+  cookie: env('SESSION_COOKIE', 'mantiq_session'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Session Cookie Path
+  |--------------------------------------------------------------------------
+  |
+  | The path for which the session cookie is available. Typically this
+  | will be the root path of your application.
+  |
+  */
+  path: '/',
+
+  /*
+  |--------------------------------------------------------------------------
+  | HTTPS Only Cookies
+  |--------------------------------------------------------------------------
+  |
+  | When true, the session cookie will only be sent over HTTPS connections.
+  | Automatically enabled in production.
+  |
+  */
+  secure: env('APP_ENV', 'production') === 'production',
+
+  /*
+  |--------------------------------------------------------------------------
+  | HTTP Access Only
+  |--------------------------------------------------------------------------
+  |
+  | When true, JavaScript cannot access the session cookie. This provides
+  | protection against XSS attacks that attempt to steal session IDs.
+  |
+  */
+  httpOnly: true,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Same-Site Cookies
+  |--------------------------------------------------------------------------
+  |
+  | Controls when the session cookie is sent with cross-site requests.
+  | 'Lax' allows top-level navigations, 'Strict' blocks all cross-site,
+  | 'None' allows all (requires secure: true).
+  |
+  */
+  sameSite: 'Lax' as const,
+}

package/skeleton/config/vite.ts

@@ -0,0 +1,33 @@
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | React Fast Refresh
+  |--------------------------------------------------------------------------
+  |
+  | Injects the React Refresh preamble into dev mode HTML so that HMR
+  | works correctly. Required for React — without it, components throw
+  | "can't detect preamble" and the page renders blank.
+  |
+  | Set to false for Vue/Svelte (they don't need this preamble).
+  |
+  */
+  reactRefresh: false,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Server-Side Rendering
+  |--------------------------------------------------------------------------
+  |
+  | SSR renders pages on the server so users see content immediately
+  | instead of a blank shell. The entry file exports a render() function.
+  |
+  | In dev: Vite's ssrLoadModule() loads the entry with HMR.
+  | In prod: the pre-built bundle at bootstrap/ssr/ is used.
+  |
+  */
+  // ssr: {
+  //   entry: 'src/ssr.tsx',
+  //   bundle: 'bootstrap/ssr/ssr.js',
+  // },
+}

package/skeleton/database/migrations/001_create_users_table.ts

@@ -0,0 +1,19 @@
+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.string('password', 255)
+      t.string('remember_token', 100).nullable()
+      t.timestamps()
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.dropIfExists('users')
+  }
+}

package/skeleton/database/migrations/002_create_personal_access_tokens_table.ts

@@ -0,0 +1,22 @@
+import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class CreatePersonalAccessTokensTable extends Migration {
+  override async up(schema: SchemaBuilder) {
+    await schema.create('personal_access_tokens', (t) => {
+      t.id()
+      t.string('tokenable_type')
+      t.unsignedBigInteger('tokenable_id')
+      t.string('name')
+      t.string('token', 64).unique()
+      t.json('abilities').nullable()
+      t.timestamp('last_used_at').nullable()
+      t.timestamp('expires_at').nullable()
+      t.timestamps()
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.dropIfExists('personal_access_tokens')
+  }
+}

package/skeleton/database/seeders/DatabaseSeeder.ts

@@ -0,0 +1,7 @@
+import { Seeder } from '@mantiq/database'
+
+export default class DatabaseSeeder extends Seeder {
+  override async run() {
+    // await this.call(UserSeeder)
+  }
+}

package/skeleton/index.ts

@@ -0,0 +1,20 @@
+import { Application, CoreServiceProvider, HttpKernel, RouterImpl, Discoverer } from '@mantiq/core'
+
+const app = await Application.create(import.meta.dir, 'config')
+
+const discoverer = new Discoverer(import.meta.dir)
+const isDev = process.env['APP_ENV'] !== 'production'
+const manifest = await discoverer.resolve(isDev)
+const userProviders = await discoverer.loadProviders(manifest)
+
+await app.bootstrap([CoreServiceProvider], userProviders)
+
+const router = app.make(RouterImpl)
+await discoverer.loadRoutes(manifest, router)
+
+export default app
+
+if (import.meta.main) {
+  const kernel = app.make(HttpKernel)
+  await kernel.start()
+}

package/skeleton/mantiq.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+await import('./index.ts')
+
+import { Kernel } from '@mantiq/cli'
+
+const kernel = new Kernel()
+const code = await kernel.run()
+process.exit(code)

package/skeleton/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "skeleton",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "bun run --watch index.ts",
+    "start": "bun run index.ts",
+    "mantiq": "bun run mantiq.ts"
+  },
+  "dependencies": {
+    "@mantiq/auth": "^0.5.0",
+    "@mantiq/cli": "^0.5.0",
+    "@mantiq/core": "^0.5.0",
+    "@mantiq/database": "^0.5.0",
+    "@mantiq/events": "^0.5.0",
+    "@mantiq/filesystem": "^0.5.0",
+    "@mantiq/heartbeat": "^0.5.0",
+    "@mantiq/helpers": "^0.5.0",
+    "@mantiq/logging": "^0.5.0",
+    "@mantiq/queue": "^0.5.0",
+    "@mantiq/realtime": "^0.5.0",
+    "@mantiq/validation": "^0.5.0",
+    "@mantiq/mail": "^0.5.0",
+    "@mantiq/notify": "^0.5.0",
+    "@mantiq/search": "^0.5.0",
+    "@mantiq/health": "^0.5.0"
+  },
+  "devDependencies": {
+    "@mantiq/testing": "^0.5.0",
+    "bun-types": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/skeleton/routes/api.ts

@@ -0,0 +1,8 @@
+import type { Router } from '@mantiq/core'
+import { MantiqResponse } from '@mantiq/core'
+
+export default function (router: Router) {
+  router.get('/ping', () => {
+    return MantiqResponse.json({ status: 'ok', timestamp: new Date().toISOString() })
+  })
+}

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
+}