@c9up/ream 0.1.25 → 0.1.27

package/src/rpc/RpcProvider.ts

@@ -42,6 +42,7 @@ export interface RpcConfig {
 
 export class RpcProvider extends Provider {
   readonly rpc: RpcRouter
+  #registered = false
 
   constructor(app: AppContext, options: RpcProviderOptions = {}) {
     super(app)
@@ -51,7 +52,9 @@ export class RpcProvider extends Provider {
   override register(): void {
     const container = this.app.container
     if (container.has('rpc')) {
-      if (container.resolve('rpc') === this.rpc) return // re-register is idempotent
+      // Idempotent re-register: tracked with a flag rather than
+      // `container.resolve('rpc')` because resolution is now async.
+      if (this.#registered) return
       throw new ReamError(
         'RPC_PROVIDER_ALREADY_REGISTERED',
         "Container token 'rpc' is already bound to a different instance",
@@ -62,12 +65,13 @@ export class RpcProvider extends Provider {
     }
     this.rpc.useContainer(container)
     container.singleton('rpc', () => this.rpc)
+    this.#registered = true
   }
 
   override async boot(): Promise<void> {
     const config = this.app.config.get<RpcConfig>('rpc')
     const path = config?.path ?? '/rpc'
-    const router = this.app.container.make<Router>('router')
+    const router = await this.app.container.make<Router>('router')
     // RpcRouter.handle() reads the registered methods at request time, so the
     // mount can happen before apps finish registering methods.
     const route = router.post(path, (ctx: HttpContext) => this.rpc.handle(ctx))

package/src/rpc/RpcRouter.ts

@@ -20,7 +20,7 @@ import {
 } from '@c9up/comet'
 import type { HttpContext } from '../http/HttpContext.js'
 import type { MiddlewareRegistry, RuntimeValidator } from '../middleware/Pipeline.js'
-import { compose } from '../middleware/Pipeline.js'
+import { compose, runValidator } from '../middleware/Pipeline.js'
 
 export type RpcHandler = (ctx: HttpContext, params: unknown) => Promise<unknown> | unknown
 
@@ -29,8 +29,8 @@ export type RpcHandler = (ctx: HttpContext, params: unknown) => Promise<unknown>
  * the shared `'middleware'` registry, and `validator:<name>` schemas.
  */
 interface RpcContainer {
-  make<T>(target: new (...args: unknown[]) => T): T
-  resolve<T>(token: string): T
+  make<T>(target: new (...args: unknown[]) => T): Promise<T>
+  resolve<T>(token: string): Promise<T>
   has(token: string): boolean
 }
 
@@ -101,7 +101,7 @@ function checkRpcAuthorization(
   def: RpcMethodDefinition,
 ): { code: number; message: string } | undefined {
   const needsAuth = def.guards.length > 0 || def.roles.length > 0 || def.permissions.length > 0
-  if (needsAuth && !ctx.auth?.authenticated) {
+  if (needsAuth && !ctx.auth?.isAuthenticated) {
     return { code: -32003, message: 'Unauthorized' }
   }
   if (def.roles.length > 0) {
@@ -163,7 +163,7 @@ export class RpcRouter {
       this.method(`${prefix}.${methodName}`, async (ctx, params) => {
         // Resolve through the container on every call (fresh DI per request,
         // like GraphQLEngine), falling back to a bare `new` when unset.
-        const instance = this.#container ? this.#container.make(controller) : new controller()
+        const instance = this.#container ? await this.#container.make(controller) : new controller()
         return instance[methodName](ctx, params)
       })
     }
@@ -238,7 +238,7 @@ export class RpcRouter {
    */
   async #runMiddleware(ctx: HttpContext, names: string[]): Promise<void> {
     const registry = this.#container?.has('middleware')
-      ? this.#container.resolve<MiddlewareRegistry>('middleware')
+      ? await this.#container.resolve<MiddlewareRegistry>('middleware')
       : undefined
     if (!registry) {
       throw new Error(
@@ -285,7 +285,22 @@ export class RpcRouter {
             id,
           )
         }
-        const outcome = this.#container.resolve<RuntimeValidator>(token).validate(params)
+        const validator = await this.#container.resolve<RuntimeValidator>(token)
+        // `runValidator` picks the async result form first — the synchronous
+        // one cannot run `unique` / `exists` and throws outright when the schema
+        // carries them.
+        let outcome: Awaited<ReturnType<typeof runValidator>>
+        try {
+          outcome = await runValidator(validator, params)
+        } catch (err) {
+          return rpcError(
+            -32603,
+            err instanceof TypeError
+              ? `Validator '${def.validator}' exposes no usable validate method.`
+              : `Validator '${def.validator}' failed: ${err instanceof Error ? err.message : String(err)}`,
+            id,
+          )
+        }
         if (!outcome.valid) return rpcError(-32602, 'Invalid params', id, outcome.errors)
         effectiveParams = outcome.data ?? params
       }

package/src/scheduler/ScheduleProvider.ts

@@ -41,6 +41,7 @@ let activeProvider: ScheduleProvider | undefined
 export class ScheduleProvider extends Provider {
   readonly scheduler: Scheduler
   #booted = false
+  #registered = false
 
   constructor(app: AppContext, options: ScheduleProviderOptions = {}) {
     super(app)
@@ -65,20 +66,10 @@ export class ScheduleProvider extends Provider {
   override register(): void {
     const scheduler = this.scheduler
     const container = this.app.container
-    // Probe for an existing binding. The `make` / `resolve` API
-    // throws when unbound; use it to distinguish "same instance"
-    // from "another provider already claimed the token".
-    let existing: unknown
-    try {
-      existing = container.resolve('scheduler')
-    } catch {
-      existing = undefined
-    }
-    if (existing !== undefined) {
-      if (existing === scheduler) {
-        // Same provider re-running its register phase — no-op.
-        return
-      }
+    if (container.has('scheduler')) {
+      // Idempotent re-register: tracked with a flag rather than
+      // `container.resolve('scheduler')` because resolution is now async.
+      if (this.#registered) return
       throw new ReamError(
         'SCHEDULE_PROVIDER_ALREADY_REGISTERED',
         "Container token 'scheduler' is already bound to a different instance",
@@ -88,6 +79,7 @@ export class ScheduleProvider extends Provider {
       )
     }
     container.singleton('scheduler', () => scheduler)
+    this.#registered = true
   }
 
   override async boot(): Promise<void> {
@@ -130,7 +122,7 @@ export class ScheduleProvider extends Provider {
             this.scheduler.register(taskName, cronExpr, async () => {
               // Resolve from the container on every fire so transient
               // services get a fresh instance each run.
-              const instance = this.app.container.make<Record<string, unknown>>(target)
+              const instance = await this.app.container.make<Record<string, unknown>>(target)
               const method = instance[methodName]
               if (typeof method !== 'function') {
                 throw new ReamError(

package/src/server/Server.ts

@@ -12,11 +12,12 @@ import type { MiddlewareFunction } from '../middleware/Pipeline.js'
 import type { Router } from '../router/Router.js'
 
 /**
- * A middleware class with a handle method.
- * This is the pattern used by AdonisJS middleware.
+ * A middleware class with a handle method. The optional third argument carries
+ * per-route configuration passed through a named-middleware factory (AdonisJS
+ * `handle(ctx, next, args)`).
  */
 export interface MiddlewareClass {
-  handle(ctx: HttpContext, next: () => Promise<void>): Promise<void> | void
+  handle(ctx: HttpContext, next: () => Promise<void>, args?: unknown): Promise<void> | void
 }
 
 /** Lazy import returning a module with a default export. */
@@ -109,7 +110,11 @@ export class Server {
 
 /**
  * Convert a MiddlewareEntry (lazy import or function) into a MiddlewareFunction.
- * Lazy imports are resolved on first call and cached.
+ * The imported class is cached on first call; the INSTANCE is resolved through
+ * the request's IoC container so `@inject()` constructor dependencies are wired
+ * (AdonisJS resolves middleware via the container — a plain `new Class()` gives
+ * every injected dependency `undefined`). Falls back to `new Class()` only when
+ * no container is present (mock contexts in unit tests).
  */
 export function resolveMiddlewareEntry(entry: MiddlewareEntry): MiddlewareFunction {
   // Direct middleware function (2 params: ctx, next)
@@ -117,16 +122,50 @@ export function resolveMiddlewareEntry(entry: MiddlewareEntry): MiddlewareFuncti
     return entry
   }
 
-  // Lazy import of a middleware class — resolve + cache on first invocation
-  // After isMiddlewareFunction returns false, entry is narrowed to LazyImport<MiddlewareClassConstructor>
+  // Lazy import of a middleware class — cache the CLASS on first invocation,
+  // then resolve the instance per request through the container (DI). The
+  // container's own singleton bindings still cache instances where desired.
   const lazyImport = entry
-  let cached: MiddlewareClass | undefined
+  let cachedClass: MiddlewareClassConstructor | undefined
   return async (ctx: HttpContext, next: () => Promise<void>) => {
-    if (!cached) {
+    if (!cachedClass) {
       const mod = await lazyImport()
-      cached = new mod.default()
+      cachedClass = mod.default
+    }
+    const instance = ctx.containerResolver
+      ? await ctx.containerResolver.make<MiddlewareClass>(cachedClass)
+      : new cachedClass()
+    await instance.handle(ctx, next)
+  }
+}
+
+/**
+ * Turn a middleware entry into a FACTORY `(args?) => MiddlewareFunction`
+ * (AdonisJS named-middleware factories). The returned function bakes `args` in
+ * and forwards them to the class's `handle(ctx, next, args)`. A plain function
+ * middleware ignores `args` (it has no third parameter). Class resolution +
+ * caching mirror {@link resolveMiddlewareEntry} (imported once, instance via DI).
+ */
+export function resolveParametrizedMiddlewareEntry(
+  entry: MiddlewareEntry,
+): (args?: unknown) => MiddlewareFunction {
+  if (isMiddlewareFunction(entry)) {
+    return () => entry
+  }
+
+  const lazyImport = entry
+  let cachedClass: MiddlewareClassConstructor | undefined
+  return (args?: unknown): MiddlewareFunction => {
+    return async (ctx: HttpContext, next: () => Promise<void>) => {
+      if (!cachedClass) {
+        const mod = await lazyImport()
+        cachedClass = mod.default
+      }
+      const instance = ctx.containerResolver
+        ? await ctx.containerResolver.make<MiddlewareClass>(cachedClass)
+        : new cachedClass()
+      await instance.handle(ctx, next, args)
     }
-    await cached.handle(ctx, next)
   }
 }
 

package/src/services/app.ts

@@ -3,7 +3,7 @@
  *
  * Usage:
  *   import app from '@c9up/ream/services/app'
- *   const logger = app.container.make('logger')
+ *   const logger = await app.container.make('logger')
  *   if (app.inProduction) { ... }
  */
 

package/src/services/console.ts

@@ -0,0 +1,42 @@
+/**
+ * Console singleton service.
+ *
+ * Usage:
+ *   import consoleApp from '@c9up/ream/services/console'
+ *   if (await consoleApp.hasCommand('make:controller')) {
+ *     const command = await consoleApp.exec('make:controller', ['user', '--resource'])
+ *   }
+ */
+
+import type { Console } from '../console/Console.js'
+
+let instance: Console | undefined
+
+/** @internal Set the consoleApp instance (called by Ignitor). */
+export function setConsole(consoleApp: Console): void {
+  instance = consoleApp
+}
+
+/**
+ * @internal Unset the locator IF it still points at `consoleApp` (called by
+ * Ignitor.stop()) — same ownership guard as the app service: a second Ignitor
+ * rebinding the locator must not be torn down by the first one stopping.
+ */
+export function clearConsole(consoleApp: Console): void {
+  if (instance === consoleApp) instance = undefined
+}
+
+const consoleApp: Console = new Proxy({} as Console, {
+  get(_target, prop) {
+    if (!instance) {
+      throw new Error(
+        'Console accessed before initialization. ' +
+          'Ensure this code runs during or after the boot phase.',
+      )
+    }
+    const value = Reflect.get(instance, prop, instance)
+    return typeof value === 'function' ? value.bind(instance) : value
+  },
+})
+
+export default consoleApp

package/src/session/SessionMiddleware.ts

@@ -56,7 +56,7 @@ export default class SessionMiddleware {
     const isProduction = process.env.NODE_ENV === 'production'
 
     // Read session ID from cookie — pre-parsed by the Rust HyperServer.
-    let sessionId = ctx.request.cookie(cookieName)
+    let sessionId = ctx.request.plainCookie(cookieName)
     const hadIncomingCookie = sessionId !== null
 
     // Cookie driver: the cookie value IS the session data (encrypted)
@@ -65,7 +65,7 @@ export default class SessionMiddleware {
       sessionId = sessionId ?? generateSessionId()
       const session = new Session(sessionId, data)
       ctx.store.set('session', session)
-    ctx.session = session
+      ctx.session = session
 
       await next()
 
@@ -85,7 +85,7 @@ export default class SessionMiddleware {
               'Switch to a server-side driver (memory/redis) or reduce session data.\n',
           )
         }
-        ctx.response.cookie(cookieName, encoded, {
+        ctx.response.plainCookie(cookieName, encoded, {
           maxAge: this.#config.clearWithBrowser ? undefined : maxAge,
           path: '/',
           httpOnly: true,
@@ -145,7 +145,7 @@ export default class SessionMiddleware {
     // defeats HTTP caching, and leaks a Set-Cookie to CDNs. This mirrors
     // the cookie-driver path above (which already omits `isNew`).
     if (session.isDirty() || regenerated || (rolling && hadIncomingCookie)) {
-      ctx.response.cookie(cookieName, session.sessionId, {
+      ctx.response.plainCookie(cookieName, session.sessionId, {
         maxAge: this.#config.clearWithBrowser ? undefined : maxAge,
         path: '/',
         httpOnly: true,

package/src/storage/StaticProvider.ts

@@ -34,7 +34,7 @@ export class StaticProvider extends Provider {
     const config = this.app.config.get<StaticConfig>('static')
     const middleware = this.#override ?? (config?.root ? new StaticMiddleware(config) : undefined)
     if (!middleware) return // not configured — opt-out
-    const server = this.app.container.make<Server>('server')
+    const server = await this.app.container.make<Server>('server')
     server.use([(ctx, next) => middleware.handle(ctx, next)])
   }
 }