@c9up/ream 0.2.1 → 0.2.2

package/src/services/router.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Router } from '../router/Router.js'
+import { createServiceProxy } from './createServiceProxy.js'
 
 let instance: Router | undefined
 
@@ -34,19 +35,10 @@ export function getRouter(): Router | undefined {
  * Router proxy — defers all property access to the underlying instance.
  * Throws if accessed before Ignitor initializes it.
  */
-const router: Router = new Proxy({} as Router, {
-  get(_target, prop) {
-    if (!instance) {
-      throw new Error(
-        'Router accessed before initialization. ' +
-          'Ensure your route files are loaded as preloads in reamrc.ts, not at import time.',
-      )
-    }
-    // Bind methods so private-field writes inside the class resolve
-    // against the real instance brand instead of the Proxy.
-    const value = Reflect.get(instance, prop, instance)
-    return typeof value === 'function' ? value.bind(instance) : value
-  },
-})
+const router: Router = createServiceProxy<Router>(
+  () => instance,
+  'Router accessed before initialization. ' +
+    'Ensure your route files are loaded as preloads in reamrc.ts, not at import time.',
+)
 
 export default router

package/src/services/server.ts

@@ -8,6 +8,7 @@
  */
 
 import type { Server } from '../server/Server.js'
+import { createServiceProxy } from './createServiceProxy.js'
 
 let instance: Server | undefined
 
@@ -29,29 +30,10 @@ export function getServer(): Server | undefined {
   return instance
 }
 
-const server: Server = new Proxy({} as Server, {
-  get(_target, prop) {
-    // A module loader inspects what it imports before anyone uses it: it reads
-    // `then` to decide whether the namespace is thenable, and various symbols
-    // for interop and formatting. Throwing on those turns a plain
-    // `import { setX } from '.../services/x'` into a crash at import time, far
-    // from any real use. They are not members of what this stands in for, so
-    // answer undefined and let a genuine access be the one that reports.
-    if (typeof prop === 'symbol' || prop === 'then') {
-      return undefined
-    }
-    if (!instance) {
-      throw new Error(
-        'Server accessed before initialization. ' +
-          'Ensure your kernel files are loaded as preloads in reamrc.ts.',
-      )
-    }
-    // Bind methods to the real instance so private-field access inside
-    // them resolves against the underlying class brand — passing the
-    // Proxy as `this` breaks `#field` writes (Proxy isn't branded).
-    const value = Reflect.get(instance, prop, instance)
-    return typeof value === 'function' ? value.bind(instance) : value
-  },
-})
+const server: Server = createServiceProxy<Server>(
+  () => instance,
+  'Server accessed before initialization. ' +
+    'Ensure your kernel files are loaded as preloads in reamrc.ts.',
+)
 
 export default server

package/src/types/container.ts

@@ -0,0 +1,66 @@
+/**
+ * The container's known bindings, as a type.
+ *
+ * Resolving from the container is a string lookup, so without a shared
+ * interface every `container.make('router')` returns `unknown` and every app
+ * casts. AdonisJS solves it with an augmentable `ContainerBindings`, and every
+ * package in its ecosystem adds its own token to it:
+ *
+ * ```ts
+ * declare module '@c9up/ream/types' {
+ *   interface ContainerBindings {
+ *     auth: AuthManager
+ *   }
+ * }
+ * ```
+ *
+ * Ream core registers the entries below; anything else — `auth` (warden),
+ * `logger` (spectrum), `db` (atlas) — reaches this interface by augmentation
+ * from the package that owns it, which is why the interface is open rather
+ * than a closed union.
+ */
+
+import type { Application } from '../Application.js'
+import type { ConfigStore } from '../ConfigLoader.js'
+import type { Console } from '../console/Console.js'
+import type { Kernel } from '../console/Kernel.js'
+import type { Emitter } from '../events/Emitter.js'
+import type { HttpContext } from '../http/HttpContext.js'
+import type { MiddlewareRegistry } from '../middleware/Pipeline.js'
+import type { MigrationRegistry } from '../migrations/MigrationRegistry.js'
+import type { Router } from '../router/Router.js'
+import type { CookieSigner } from '../security/CookieSigner.js'
+import type { SignedUrl } from '../security/SignedUrl.js'
+import type { Server } from '../server/Server.js'
+
+export interface ContainerBindings {
+  /** The application instance. */
+  app: Application
+  /** Absolute path to the application root. */
+  appRoot: string
+  /** The config store built from `config/*.ts`. */
+  config: ConfigStore
+  /** The console application (AdonisJS calls its equivalent `ace`). */
+  console: Console
+  /** The console kernel that dispatches commands. */
+  consoleKernel: Kernel
+  /** The event emitter. */
+  emitter: Emitter
+  /** Cookie/value signing and encryption, backed by `APP_KEY`. */
+  encryption: CookieSigner
+  /** The `HttpContext` class itself — for `HttpContext.getOrFail()` style access. */
+  HttpContext: typeof HttpContext
+  /** Named middleware registered by the app kernel. */
+  middleware: MiddlewareRegistry
+  /** Migration sources contributed by data packages (atlas, eon, ...). */
+  migrations: MigrationRegistry
+  /** The HTTP router. */
+  router: Router
+  /** The HTTP server. */
+  server: Server
+  /** Signed-URL generation and verification. */
+  signedUrl: SignedUrl
+}
+
+/** A token this container knows how to resolve. */
+export type ContainerBinding = keyof ContainerBindings