@mantiq/core 0.3.0 → 0.4.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/core",
-  "version": "0.3.0",
+  "version": "0.4.0-rc.2",
   "description": "Service container, router, middleware, HTTP kernel, config, and exception handler",
   "type": "module",
   "license": "MIT",

package/src/application/Application.ts

@@ -30,7 +30,7 @@ export class Application extends ContainerImpl {
   private constructor(private readonly basePath: string = process.cwd()) {
     super()
     // Register the application itself so it can be resolved from the container
-    this.instance(Application, this)
+    this.instance(Application as any, this)
   }
 
   // ── Singleton access ──────────────────────────────────────────────────────
@@ -133,6 +133,61 @@ export class Application extends ContainerImpl {
     return this.basePath_(path ? `storage/${path}` : 'storage')
   }
 
+  // ── Package provider discovery ──────────────────────────────────────────
+
+  /**
+   * Discover service providers from installed @mantiq/* packages.
+   * Each package declares its provider in package.json:
+   *   { "mantiq": { "provider": "AuthServiceProvider" } }
+   *
+   * Install a package → provider auto-discovered. Uninstall → gone.
+   */
+  async discoverPackageProviders(): Promise<Constructor<ServiceProvider>[]> {
+    const providers: Constructor<ServiceProvider>[] = []
+    const nodeModulesDir = this.basePath_('node_modules/@mantiq')
+
+    try {
+      const glob = new Bun.Glob('*/package.json')
+      for await (const file of glob.scan({ cwd: nodeModulesDir, absolute: false })) {
+        try {
+          const pkgJson = JSON.parse(
+            await Bun.file(`${nodeModulesDir}/${file}`).text()
+          )
+          const providerName = pkgJson?.mantiq?.provider
+          if (!providerName) continue
+
+          const pkgName = pkgJson.name as string
+          const mod = await import(pkgName)
+          if (mod[providerName] && typeof mod[providerName] === 'function') {
+            providers.push(mod[providerName])
+          }
+        } catch {
+          // Skip packages that can't be loaded
+        }
+      }
+    } catch {
+      // node_modules/@mantiq doesn't exist
+    }
+
+    return providers
+  }
+
+  /**
+   * One-call bootstrap: discover package providers, register, boot.
+   * Equivalent to:
+   *   const providers = await app.discoverPackageProviders()
+   *   await app.registerProviders([CoreServiceProvider, ...providers, ...userProviders])
+   *   await app.bootProviders()
+   */
+  async bootstrap(
+    coreProviders: Constructor<ServiceProvider>[] = [],
+    userProviders: Constructor<ServiceProvider>[] = [],
+  ): Promise<void> {
+    const packageProviders = await this.discoverPackageProviders()
+    await this.registerProviders([...coreProviders, ...packageProviders, ...userProviders])
+    await this.bootProviders()
+  }
+
   // ── Provider lifecycle ────────────────────────────────────────────────────
 
   /**
@@ -191,7 +246,7 @@ export class Application extends ContainerImpl {
    * Override make() to handle deferred provider loading.
    * If a binding isn't found in the container, check deferred providers.
    */
-  make<T>(abstract: Bindable<T>): T {
+  override make<T>(abstract: Bindable<T>): T {
     try {
       return super.make(abstract)
     } catch (err) {

package/src/contracts/Router.ts

@@ -19,14 +19,14 @@ export interface RouteMatch {
   action: RouteAction
   params: Record<string, any>
   middleware: string[]
-  routeName?: string
+  routeName?: string | undefined
 }
 
 export interface RouteDefinition {
   method: HttpMethod | HttpMethod[]
   path: string
   action: RouteAction
-  name?: string
+  name?: string | undefined
   middleware: string[]
   wheres: Record<string, RegExp>
 }

package/src/discovery/Discoverer.ts

@@ -0,0 +1,200 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+
+/**
+ * Auto-discovers application classes by scanning conventional directories.
+ *
+ * In development: scans the filesystem and rebuilds the manifest.
+ * In production: reads a cached manifest from bootstrap/manifest.json.
+ *
+ * Usage:
+ *   const discoverer = new Discoverer(app.basePath)
+ *   const manifest = await discoverer.build()  // scan + cache
+ *   const manifest = discoverer.cached()        // read cache only
+ */
+
+export interface DiscoveryManifest {
+  providers: string[]
+  commands: string[]
+  routes: string[]
+  models: string[]
+  policies: string[]
+  middleware: string[]
+  observers: string[]
+  listeners: string[]
+  jobs: string[]
+  timestamp: number
+}
+
+const EMPTY_MANIFEST: DiscoveryManifest = {
+  providers: [],
+  commands: [],
+  routes: [],
+  models: [],
+  policies: [],
+  middleware: [],
+  observers: [],
+  listeners: [],
+  jobs: [],
+  timestamp: 0,
+}
+
+/** Directories to scan, relative to basePath. */
+const DISCOVERY_MAP: Array<{ key: keyof DiscoveryManifest; dir: string; pattern: string }> = [
+  { key: 'providers',  dir: 'app/Providers',            pattern: '*ServiceProvider.ts' },
+  { key: 'commands',   dir: 'app/Console/Commands',     pattern: '*Command.ts' },
+  { key: 'routes',     dir: 'routes',                   pattern: '*.ts' },
+  { key: 'models',     dir: 'app/Models',               pattern: '*.ts' },
+  { key: 'policies',   dir: 'app/Policies',             pattern: '*Policy.ts' },
+  { key: 'middleware',  dir: 'app/Http/Middleware',      pattern: '*.ts' },
+  { key: 'observers',  dir: 'app/Observers',            pattern: '*Observer.ts' },
+  { key: 'listeners',  dir: 'app/Listeners',            pattern: '*Listener.ts' },
+  { key: 'jobs',       dir: 'app/Jobs',                 pattern: '*.ts' },
+]
+
+export class Discoverer {
+  private manifestPath: string
+
+  constructor(private basePath: string) {
+    this.manifestPath = join(basePath, 'bootstrap', 'manifest.json')
+  }
+
+  /**
+   * Scan all directories and build a fresh manifest.
+   * Writes to bootstrap/manifest.json for caching.
+   */
+  async build(): Promise<DiscoveryManifest> {
+    const manifest: DiscoveryManifest = { ...EMPTY_MANIFEST, timestamp: Date.now() }
+
+    for (const { key, dir, pattern } of DISCOVERY_MAP) {
+      if (key === 'timestamp') continue
+      const fullDir = join(this.basePath, dir)
+      const files = await this.scanDirectory(fullDir, pattern)
+      ;(manifest[key] as string[]) = files.map((f) => join(dir, f))
+    }
+
+    // Write cache
+    this.writeManifest(manifest)
+    return manifest
+  }
+
+  /**
+   * Read the cached manifest. Returns null if no cache exists.
+   */
+  cached(): DiscoveryManifest | null {
+    if (!existsSync(this.manifestPath)) return null
+    try {
+      const raw = readFileSync(this.manifestPath, 'utf-8')
+      return JSON.parse(raw) as DiscoveryManifest
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get the manifest — cached in production, fresh in development.
+   */
+  async resolve(isDev = true): Promise<DiscoveryManifest> {
+    if (!isDev) {
+      const cached = this.cached()
+      if (cached) return cached
+    }
+    return this.build()
+  }
+
+  /**
+   * Load and instantiate all discovered service providers.
+   * Returns provider instances ready for registration.
+   */
+  async loadProviders(manifest: DiscoveryManifest): Promise<any[]> {
+    const providers: any[] = []
+    for (const file of manifest.providers) {
+      const fullPath = join(this.basePath, file)
+      try {
+        const mod = await import(fullPath)
+        const ProviderClass = this.findExport(mod, (v) =>
+          typeof v === 'function' && v.prototype?.register && v.prototype?.boot
+        )
+        if (ProviderClass) providers.push(ProviderClass)
+      } catch {
+        // Skip unloadable providers
+      }
+    }
+    return providers
+  }
+
+  /**
+   * Load and register all discovered route files.
+   * Each route file should export a default function: (router) => void
+   */
+  async loadRoutes(manifest: DiscoveryManifest, router: any): Promise<void> {
+    for (const file of manifest.routes) {
+      const fullPath = join(this.basePath, file)
+      try {
+        const mod = await import(fullPath)
+        if (typeof mod.default === 'function') {
+          mod.default(router)
+        }
+      } catch {
+        // Skip unloadable routes
+      }
+    }
+  }
+
+  /**
+   * Load all discovered command classes for CLI kernel.
+   */
+  async loadCommands(manifest: DiscoveryManifest): Promise<any[]> {
+    const commands: any[] = []
+    for (const file of manifest.commands) {
+      const fullPath = join(this.basePath, file)
+      try {
+        const mod = await import(fullPath)
+        for (const exported of Object.values(mod)) {
+          if (typeof exported !== 'function') continue
+          try {
+            const instance = new (exported as any)()
+            if (instance.name && typeof instance.handle === 'function') {
+              commands.push(instance)
+            }
+          } catch {
+            // Not a command
+          }
+        }
+      } catch {
+        // Skip
+      }
+    }
+    return commands
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────────
+
+  private async scanDirectory(dir: string, pattern: string): Promise<string[]> {
+    const files: string[] = []
+    try {
+      const glob = new Bun.Glob(pattern)
+      for await (const file of glob.scan({ cwd: dir, absolute: false })) {
+        // Skip dotfiles and test files
+        if (file.startsWith('.') || file.includes('.test.') || file.includes('.spec.')) continue
+        files.push(file)
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+    return files.sort()
+  }
+
+  private writeManifest(manifest: DiscoveryManifest): void {
+    const dir = dirname(this.manifestPath)
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+    writeFileSync(this.manifestPath, JSON.stringify(manifest, null, 2))
+  }
+
+  private findExport(mod: any, predicate: (v: any) => boolean): any {
+    for (const exported of Object.values(mod)) {
+      if (predicate(exported)) return exported
+    }
+    return null
+  }
+}

package/src/http/Kernel.ts

@@ -2,6 +2,7 @@ import type { Container, Constructor } from '../contracts/Container.ts'
 import type { ExceptionHandler } from '../contracts/ExceptionHandler.ts'
 import type { Middleware } from '../contracts/Middleware.ts'
 import type { Router, RouteMatch } from '../contracts/Router.ts'
+import type { MantiqRequest as MantiqRequestContract } from '../contracts/Request.ts'
 import { MantiqRequest } from './Request.ts'
 import { MantiqResponse } from './Response.ts'
 import { Pipeline } from '../middleware/Pipeline.ts'
@@ -90,7 +91,7 @@ export class HttpKernel {
   /**
    * Main entry point. Passed to Bun.serve() as the fetch handler.
    */
-  async handle(bunRequest: Request, server: Server): Promise<Response> {
+  async handle(bunRequest: Request, server: Bun.Server<any>): Promise<Response> {
     // WebSocket upgrade
     if (bunRequest.headers.get('upgrade')?.toLowerCase() === 'websocket') {
       return this.wsKernel.handleUpgrade(bunRequest, server)
@@ -145,7 +146,7 @@ export class HttpKernel {
           port,
           hostname,
           fetch: (req, server) => this.handle(req, server),
-          websocket: this.wsKernel.getBunHandlers(),
+          websocket: this.wsKernel.getBunHandlers() as Bun.WebSocketHandler<any>,
         })
 
         const display = hostname === '0.0.0.0' ? 'localhost' : hostname
@@ -172,7 +173,7 @@ export class HttpKernel {
    * Call the route action (controller method or closure).
    * Converts the return value to a Response.
    */
-  private async callAction(match: RouteMatch, request: MantiqRequest): Promise<Response> {
+  private async callAction(match: RouteMatch, request: MantiqRequestContract): Promise<Response> {
     const action = match.action
 
     let result: any

package/src/http/Request.ts

@@ -228,7 +228,7 @@ export class MantiqRequest implements MantiqRequestContract {
 
     try {
       if (contentType.includes('application/json')) {
-        this.parsedBody = await this.bunRequest.clone().json()
+        this.parsedBody = await this.bunRequest.clone().json() as Record<string, any>
       } else if (contentType.includes('application/x-www-form-urlencoded')) {
         const text = await this.bunRequest.clone().text()
         this.parsedBody = Object.fromEntries(new URLSearchParams(text).entries())

package/src/index.ts

@@ -55,10 +55,12 @@ export { EncryptCookies } from './middleware/EncryptCookies.ts'
 export { VerifyCsrfToken } from './middleware/VerifyCsrfToken.ts'
 export { RateLimiter, MemoryStore } from './rateLimit/RateLimiter.ts'
 export type { RateLimitConfig, RateLimitStore, LimiterResolver } from './rateLimit/RateLimiter.ts'
-export { ThrottleRequests } from './rateLimit/ThrottleRequests.ts'
+export { ThrottleRequests, getDefaultRateLimiter, setDefaultRateLimiter } from './rateLimit/ThrottleRequests.ts'
 export { WebSocketKernel } from './websocket/WebSocketKernel.ts'
 export { DefaultExceptionHandler } from './exceptions/Handler.ts'
 export { CoreServiceProvider } from './providers/CoreServiceProvider.ts'
+export { Discoverer } from './discovery/Discoverer.ts'
+export type { DiscoveryManifest } from './discovery/Discoverer.ts'
 
 // ── Encryption ────────────────────────────────────────────────────────────────
 export { AesEncrypter } from './encryption/Encrypter.ts'

package/src/macroable/Macroable.ts

@@ -48,7 +48,7 @@ export interface MacroableInstance {
  */
 export function Macroable<T extends Constructor>(Base: T): T & MacroableStatic {
   class MacroableClass extends (Base as Constructor) {
-    private static _macros = new Map<string, Function>()
+    static _macros = new Map<string, Function>()
 
     static macro(name: string, fn: Function): void {
       this._ensureOwnMacros()

package/src/providers/CoreServiceProvider.ts

@@ -9,6 +9,7 @@ import { TrimStringsMiddleware } from '../middleware/TrimStrings.ts'
 import { StartSession } from '../middleware/StartSession.ts'
 import { EncryptCookies } from '../middleware/EncryptCookies.ts'
 import { VerifyCsrfToken } from '../middleware/VerifyCsrfToken.ts'
+import { ThrottleRequests } from '../rateLimit/ThrottleRequests.ts'
 import { ROUTER } from '../helpers/route.ts'
 import { ENCRYPTER } from '../helpers/encrypt.ts'
 import { AesEncrypter } from '../encryption/Encrypter.ts'
@@ -77,6 +78,9 @@ export class CoreServiceProvider extends ServiceProvider {
     this.app.bind(EncryptCookies, (c) => new EncryptCookies(c.make<AesEncrypter>(ENCRYPTER)))
     this.app.bind(VerifyCsrfToken, (c) => new VerifyCsrfToken(c.make<AesEncrypter>(ENCRYPTER)))
 
+    // Rate limiting — zero-config, uses shared in-memory store
+    this.app.singleton(ThrottleRequests, () => new ThrottleRequests())
+
     // HTTP kernel — singleton, depends on Router + ExceptionHandler + WsKernel
     this.app.singleton(HttpKernel, (c) => {
       const router = c.make(RouterImpl)
@@ -93,5 +97,14 @@ export class CoreServiceProvider extends ServiceProvider {
       const encrypter = await AesEncrypter.fromAppKey(appKey)
       this.app.instance(ENCRYPTER, encrypter)
     }
+
+    // ── Auto-register middleware aliases on HttpKernel ─────────────────────
+    const kernel = this.app.make(HttpKernel)
+    kernel.registerMiddleware('throttle', ThrottleRequests)
+    kernel.registerMiddleware('cors', CorsMiddleware)
+    kernel.registerMiddleware('trim', TrimStringsMiddleware)
+    kernel.registerMiddleware('encrypt.cookies', EncryptCookies)
+    kernel.registerMiddleware('session', StartSession)
+    kernel.registerMiddleware('csrf', VerifyCsrfToken)
   }
 }

package/src/rateLimit/ThrottleRequests.ts

@@ -1,6 +1,18 @@
 import type { MantiqRequest } from '../contracts/Request.ts'
+import type { Middleware } from '../contracts/Middleware.ts'
 import { HttpError } from '../errors/HttpError.ts'
-import type { RateLimiter, RateLimitConfig } from './RateLimiter.ts'
+import { RateLimiter } from './RateLimiter.ts'
+import type { RateLimitConfig } from './RateLimiter.ts'
+
+/** Shared default RateLimiter instance. */
+let _defaultLimiter: RateLimiter | null = null
+export function getDefaultRateLimiter(): RateLimiter {
+  if (!_defaultLimiter) _defaultLimiter = new RateLimiter()
+  return _defaultLimiter
+}
+export function setDefaultRateLimiter(limiter: RateLimiter): void {
+  _defaultLimiter = limiter
+}
 
 /**
  * Middleware that throttles requests using the RateLimiter.
@@ -17,12 +29,19 @@ import type { RateLimiter, RateLimitConfig } from './RateLimiter.ts'
  *   X-RateLimit-Remaining: 45
  *   Retry-After: 30 (only when rate limited)
  */
-export class ThrottleRequests {
+export class ThrottleRequests implements Middleware {
   private params: string[] = []
+  private rateLimiter: RateLimiter = getDefaultRateLimiter()
 
-  constructor(private readonly rateLimiter: RateLimiter) {}
+  constructor() {}
+
+  /** Use a custom RateLimiter instead of the default shared instance. */
+  useRateLimiter(limiter: RateLimiter): this {
+    this.rateLimiter = limiter
+    return this
+  }
 
-  setParameters(...params: string[]): void {
+  setParameters(params: string[]): void {
     this.params = params
   }
 

package/src/types.d.ts

@@ -0,0 +1,3 @@
+// Optional peer dependencies
+declare module 'ioredis' { const x: any; export = x; export default x; }
+declare module 'memjs' { const x: any; export = x; export default x; }

package/src/websocket/WebSocketContext.ts

@@ -1,7 +1,7 @@
 import type { MantiqRequest } from '../contracts/Request.ts'
 
 export interface WebSocketContext {
-  userId?: string | number
+  userId?: string | number | undefined
   channels: Set<string>
   metadata: Record<string, any>
 }