@c9up/ream 0.2.2 → 0.2.4

package/src/types/{container.ts → index.ts}

@@ -1,23 +1,14 @@
 /**
- * The container's known bindings, as a type.
+ * The interfaces an application or a package augments — `@c9up/ream/types`.
  *
- * 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:
+ * Resolving from the container and picking an auth guard are both string
+ * lookups; without a shared interface to augment, every call site casts.
  *
- * ```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.
+ * The augmentable interfaces are DECLARED here rather than re-exported from a
+ * neighbouring file, and that is load-bearing: TypeScript augments the module
+ * that declares an interface, so a re-export makes
+ * `declare module '@c9up/ream/types' { interface Authenticators { … } }` a
+ * duplicate declaration instead of an augmentation. warden hit exactly that.
  */
 
 import type { Application } from '../Application.js'
@@ -33,6 +24,46 @@ import type { CookieSigner } from '../security/CookieSigner.js'
 import type { SignedUrl } from '../security/SignedUrl.js'
 import type { Server } from '../server/Server.js'
 
+/**
+ * Guard name → what `auth.use(name)` hands back.
+ *
+ * Empty here, and deliberately: ream owns no auth package, so it cannot know
+ * the guards an app configured. The auth package fills it in:
+ *
+ * ```ts
+ * declare module '@c9up/ream/types' {
+ *   interface Authenticators {
+ *     session: SessionGuard
+ *   }
+ * }
+ * ```
+ *
+ * Until something augments it, `keyof Authenticators` is `never` and `use()`
+ * falls through to its `unknown` signature — the previous behaviour kept as
+ * the floor rather than the ceiling.
+ */
+/**
+ * An EMPTY INTERFACE is the whole mechanism here, not an oversight. Rewritten
+ * as `type Authenticators = {}` the declaration stops being augmentable:
+ * `declare module '@c9up/ream/types' { interface Authenticators { … } }`
+ * becomes a duplicate identifier instead of a merge, and warden cannot type
+ * `ctx.auth.use()`. That is exactly what shipped in 0.2.3, where the formatter
+ * had rewritten it.
+ */
+// biome-ignore lint/suspicious/noEmptyInterface: it must stay an interface to be augmentable — see above
+export interface Authenticators {}
+
+/** A guard name this application knows about. */
+export type AuthenticatorName = keyof Authenticators
+
+/**
+ * The container's known bindings.
+ *
+ * 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 it is open rather than a closed
+ * union.
+ */
 export interface ContainerBindings {
   /** The application instance. */
   app: Application

package/dist/types/container.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/types/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,MAAM,WAAW,iBAAiB;IAChC,gCAAgC;IAChC,GAAG,EAAE,WAAW,CAAA;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,iDAAiD;IACjD,MAAM,EAAE,WAAW,CAAA;IACnB,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAA;IAChB,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAA;IACrB,yBAAyB;IACzB,OAAO,EAAE,OAAO,CAAA;IAChB,gEAAgE;IAChE,UAAU,EAAE,YAAY,CAAA;IACxB,mFAAmF;IACnF,WAAW,EAAE,OAAO,WAAW,CAAA;IAC/B,qDAAqD;IACrD,UAAU,EAAE,kBAAkB,CAAA;IAC9B,wEAAwE;IACxE,UAAU,EAAE,iBAAiB,CAAA;IAC7B,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,SAAS,EAAE,SAAS,CAAA;CACrB;AAED,mDAAmD;AACnD,MAAM,MAAM,gBAAgB,GAAG,MAAM,iBAAiB,CAAA"}

package/dist/types/container.js

@@ -1,23 +0,0 @@
-/**
- * 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.
- */
-export {};
-//# sourceMappingURL=container.js.map

package/dist/types/container.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"container.js","sourceRoot":"","sources":["../../src/types/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}