@zudojs/tenancy 1.2.0 → 1.3.0

package/README.md

@@ -51,9 +51,30 @@ const middleware = createResolveTenantMiddleware({
 });
 ```
 
+The chain's context type is inferred from its resolvers — what the JWT,
+domain and subdomain resolvers read, which `HttpResolverContext` provides — so
+the call needs no type argument and no casts. (Before 1.3 it failed with
+TS2322 unless you wrote `createResolverChain<HttpResolverContext>`; that form
+still works.)
+
 The middleware runs inside the real `@zudojs/http` pipeline without
 depending on it: headers are read through `request.getHeader()` when present,
-and otherwise from a plain object or a `Map`, case-insensitively.
+and otherwise from a plain object or a `Map`, case-insensitively. Its
+`HttpMiddleware` type is assignable to `@zudojs/http`'s, so it goes straight
+into a route's `middleware` list:
+
+```typescript
+router.get("/projects", listProjects, { middleware: [middleware] });
+```
+
+A refusal — 400, 401, 403, 404 — is a `GuardResponse` (`createGuardResponse`
+from `@zudojs/middleware`), which `@zudojs/http` sends with that status. The
+helpers `createBadRequest`, `createUnauthorized`, `createForbidden`,
+`createNotFound`, `createJsonErrorResponse` and `createJsonResponse` all
+return one. They used to return plain `{ status, body, headers }` objects,
+which `@zudojs/http` did not treat as a response, so a request carrying only
+an `x-tenant-id` header was refused (the handler never ran) but answered
+`200` instead of `403`.
 
 Read the current tenant anywhere downstream:
 

package/dist/http/httpHelpers.d.ts

@@ -1,46 +1,36 @@
 /**
  * HTTP response helpers for tenancy middleware.
  *
+ * Every helper returns a `GuardResponse` from `@zudojs/middleware`, which
+ * `@zudojs/http` sends with its own status. They used to return plain
+ * `{ status, body, headers }` objects, which a route middleware's caller
+ * ignored: a refused request reached the client as `200`.
+ *
  * @module http/httpHelpers
  */
+import { type GuardResponse } from "@zudojs/middleware";
+/**
+ * Create a JSON response with a caller-built body.
+ */
+export declare function createJsonResponse(status: number, body: unknown): GuardResponse;
 /**
- * Create a JSON error response.
+ * Create a JSON error response: `{ "error": message }`.
  */
-export declare function createJsonErrorResponse(status: number, message: string): {
-    readonly status: number;
-    readonly body: unknown;
-    readonly headers: Record<string, string>;
-};
+export declare function createJsonErrorResponse(status: number, message: string): GuardResponse;
 /**
  * Create a 400 Bad Request response.
  */
-export declare function createBadRequest(message: string): {
-    readonly status: number;
-    readonly body: unknown;
-    readonly headers: Record<string, string>;
-};
+export declare function createBadRequest(message: string): GuardResponse;
 /**
  * Create a 401 Unauthorized response.
  */
-export declare function createUnauthorized(message: string): {
-    readonly status: number;
-    readonly body: unknown;
-    readonly headers: Record<string, string>;
-};
+export declare function createUnauthorized(message: string): GuardResponse;
 /**
  * Create a 403 Forbidden response.
  */
-export declare function createForbidden(message: string): {
-    readonly status: number;
-    readonly body: unknown;
-    readonly headers: Record<string, string>;
-};
+export declare function createForbidden(message: string): GuardResponse;
 /**
  * Create a 404 Not Found response.
  */
-export declare function createNotFound(message: string): {
-    readonly status: number;
-    readonly body: unknown;
-    readonly headers: Record<string, string>;
-};
+export declare function createNotFound(message: string): GuardResponse;
 //# sourceMappingURL=httpHelpers.d.ts.map

package/dist/http/httpHelpers.js

@@ -1,17 +1,26 @@
 /**
  * HTTP response helpers for tenancy middleware.
  *
+ * Every helper returns a `GuardResponse` from `@zudojs/middleware`, which
+ * `@zudojs/http` sends with its own status. They used to return plain
+ * `{ status, body, headers }` objects, which a route middleware's caller
+ * ignored: a refused request reached the client as `200`.
+ *
  * @module http/httpHelpers
  */
+import { createGuardResponse } from "@zudojs/middleware";
+const JSON_HEADERS = { "content-type": "application/json" };
+/**
+ * Create a JSON response with a caller-built body.
+ */
+export function createJsonResponse(status, body) {
+    return createGuardResponse({ status, body, headers: JSON_HEADERS });
+}
 /**
- * Create a JSON error response.
+ * Create a JSON error response: `{ "error": message }`.
  */
 export function createJsonErrorResponse(status, message) {
-    return Object.freeze({
-        status,
-        body: { error: message },
-        headers: { "content-type": "application/json" },
-    });
+    return createJsonResponse(status, { error: message });
 }
 /**
  * Create a 400 Bad Request response.

package/dist/http/httpTypes.d.ts

@@ -7,8 +7,23 @@
  *
  * @module http/httpTypes
  */
-/** HTTP middleware signature from @zudojs/http. */
-export type HttpMiddleware = (context: HttpMiddlewareContext, next: () => Promise<HttpResponseContext>) => void | Response | HttpResponseContext | Promise<void | Response | HttpResponseContext>;
+import type { GuardResponse } from "@zudojs/middleware";
+/**
+ * What a tenancy middleware returns: nothing, a web `Response`, a
+ * `GuardResponse` refusing the request, or whatever `next()` produced.
+ */
+export type HttpMiddlewareOutcome<Downstream> = void | Response | GuardResponse | Downstream;
+/**
+ * HTTP middleware signature, structurally assignable to `@zudojs/http`'s
+ * `HttpMiddleware` without a cast.
+ *
+ * Generic over what `next()` resolves to, so a middleware hands back the
+ * real pipeline's response unchanged. A refusal is a `GuardResponse`
+ * (`createGuardResponse` from `@zudojs/middleware`), which `@zudojs/http`
+ * sends with its own status; a plain `{ status, body, headers }` object is
+ * not a response.
+ */
+export type HttpMiddleware = <Downstream extends HttpResponseContext>(context: HttpMiddlewareContext, next: () => Promise<Downstream>) => HttpMiddlewareOutcome<Downstream> | Promise<HttpMiddlewareOutcome<Downstream>>;
 /** HTTP middleware context from @zudojs/http. */
 export interface HttpMiddlewareContext {
     readonly request: HttpRequestContext;

package/dist/http/index.d.ts

@@ -8,6 +8,6 @@ export type { TenantGuardMiddlewareOptions } from "./tenancyMiddleware.guard.js"
 export { TENANT_CLAIMS_STATE_KEY, createHttpResolverContext, } from "./httpResolverContext.js";
 export type { HttpResolverContext, TenantClaims, } from "./httpResolverContext.js";
 export { readRequestHeader } from "./httpSupport/index.js";
-export { createBadRequest, createForbidden, createJsonErrorResponse, createNotFound, createUnauthorized, } from "./httpHelpers.js";
+export { createBadRequest, createForbidden, createJsonErrorResponse, createJsonResponse, createNotFound, createUnauthorized, } from "./httpHelpers.js";
 export type * from "./httpTypes.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -5,5 +5,5 @@ export { TENANT_CONTEXT_STATE_KEY, TENANT_STATE_KEY, createRequireTenantMiddlewa
 export { createTenantGuardMiddleware, createTenantPropagationMiddleware, } from "./tenancyMiddleware.guard.js";
 export { TENANT_CLAIMS_STATE_KEY, createHttpResolverContext, } from "./httpResolverContext.js";
 export { readRequestHeader } from "./httpSupport/index.js";
-export { createBadRequest, createForbidden, createJsonErrorResponse, createNotFound, createUnauthorized, } from "./httpHelpers.js";
+export { createBadRequest, createForbidden, createJsonErrorResponse, createJsonResponse, createNotFound, createUnauthorized, } from "./httpHelpers.js";
 //# sourceMappingURL=index.js.map

package/dist/http/tenancyMiddleware.core.js

@@ -8,7 +8,7 @@
  * Composes with the @zudojs/http pipeline structurally; no dependency on it.
  */
 import { createHttpResolverContext } from "./httpResolverContext.js";
-import { createBadRequest, createForbidden, createNotFound, createUnauthorized, } from "./httpHelpers.js";
+import { createBadRequest, createForbidden, createJsonResponse, createNotFound, createUnauthorized, } from "./httpHelpers.js";
 import { meetsTrustLevel } from "../security/guard.core.js";
 import { loadResolvedTenant } from "./httpSupport/index.js";
 import { TenantResolutionConflictError, TenantResolutionError, } from "../tenancyErrors/tenancyError.types.js";
@@ -31,11 +31,7 @@ export function createResolveTenantMiddleware(options) {
     // Unknown and unavailable tenants get the same answer, so a caller cannot
     // learn which tenant ids exist or which of them are suspended.
     const notFound = (resolution) => options.notFoundResponse
-        ? {
-            status: 404,
-            body: options.notFoundResponse(resolution),
-            headers: { "content-type": "application/json" },
-        }
+        ? createJsonResponse(404, options.notFoundResponse(resolution))
         : createNotFound("Tenant not found");
     return async (context, next) => {
         let resolution;
@@ -98,11 +94,7 @@ export function createRequireTenantMiddleware(options) {
             return next();
         if (!tenant) {
             return options?.deniedResponse
-                ? {
-                    status: 401,
-                    body: options.deniedResponse(undefined),
-                    headers: { "content-type": "application/json" },
-                }
+                ? createJsonResponse(401, options.deniedResponse(undefined))
                 : createUnauthorized("Tenant context is required");
         }
         return next();

package/dist/resolver/index.d.ts

@@ -4,6 +4,6 @@
  * @module resolver
  */
 export { createResolverChain } from "./resolverChain.core.js";
-export type { TenantResolverChain } from "./resolverChain.core.js";
+export type { ResolverChainContext, TenantResolverChain, } from "./resolverChain.core.js";
 export * from "./resolvers/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/resolver/resolverChain.core.d.ts

@@ -18,14 +18,32 @@ export interface TenantResolverChain<Context = unknown> {
     resolveTenant(context: Context): Promise<TenantResolution | undefined>;
     asResolver(): TenantResolver<Context>;
 }
+/** The context type one resolver reads. */
+type ResolverContextOf<Resolver> = Resolver extends TenantResolver<infer Context> ? Context : never;
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
+/**
+ * The context a chain of these resolvers needs: everything each of them
+ * reads. For the JWT, domain and subdomain resolvers that is
+ * `JwtContext & DomainContext & SubdomainContext`, which
+ * `HttpResolverContext` satisfies.
+ */
+export type ResolverChainContext<Resolvers extends readonly TenantResolver<never>[]> = UnionToIntersection<ResolverContextOf<Resolvers[number]>>;
 /**
  * Create a resolver chain that tries resolvers in priority order.
  *
+ * The chain's context is inferred from the resolvers — each reads a
+ * different part of the request, so it is the intersection of what they
+ * read — and `createResolverChain([createJwtResolver(), createDomainResolver(
+ * { repository })])` needs no type argument. Passing one explicitly
+ * (`createResolverChain<HttpResolverContext>([...])`) still works.
+ *
  * A resolver that returns `undefined` found nothing, and the chain moves on.
  * A resolver that *throws* rejected a credential — an expired JWT, a bad
  * signature — and the chain stops there. Continuing would let a lower-trust
  * source such as a client-supplied header decide the tenant for a request
  * whose credential was just refused.
  */
+export declare function createResolverChain<const Resolvers extends readonly TenantResolver<never>[]>(resolvers: Resolvers, options?: ResolverChainOptions): TenantResolverChain<ResolverChainContext<Resolvers>>;
 export declare function createResolverChain<Context = unknown>(resolvers: readonly TenantResolver<Context>[], options?: ResolverChainOptions): TenantResolverChain<Context>;
+export {};
 //# sourceMappingURL=resolverChain.core.d.ts.map

package/dist/resolver/resolverChain.core.js

@@ -4,15 +4,6 @@
  * @module resolver/resolverChain
  */
 import { TenantResolutionConflictError, TenantResolutionError, } from "../tenancyErrors/tenancyError.types.js";
-/**
- * Create a resolver chain that tries resolvers in priority order.
- *
- * A resolver that returns `undefined` found nothing, and the chain moves on.
- * A resolver that *throws* rejected a credential — an expired JWT, a bad
- * signature — and the chain stops there. Continuing would let a lower-trust
- * source such as a client-supplied header decide the tenant for a request
- * whose credential was just refused.
- */
 export function createResolverChain(resolvers, options) {
     // Sort by priority descending (higher priority first)
     const sorted = [...resolvers].sort((a, b) => b.priority - a.priority);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/tenancy",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Multi-tenant context and isolation with tenant resolution, AsyncLocalStorage propagation, resolver chains, trust levels, and guard middleware.",
   "license": "MIT",
   "author": {
@@ -25,15 +25,16 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/errors": "1.1.0",
-    "@zudojs/constants": "1.1.0"
+    "@zudojs/errors": "1.3.0",
+    "@zudojs/constants": "1.1.2",
+    "@zudojs/middleware": "1.1.0"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -44,7 +45,7 @@
     "multi-tenant",
     "saas"
   ],
-  "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "homepage": "https://zudojs.oyinlola.site/docs/packages-tenancy",
   "bugs": {
     "url": "https://github.com/oyinlola-tech/zudo/issues"
   },