@rexeus/typeweaver-server 0.10.2 → 0.10.4

package/dist/lib/middleware/poweredBy.ts

@@ -10,10 +10,15 @@ export function poweredBy(options?: PoweredByOptions) {
 
   return defineMiddleware(async (_ctx, next) => {
     const response = await next();
+    const responseHeaders = Object.fromEntries(
+      Object.entries(response.header ?? {}).filter(
+        ([headerName]) => headerName.toLowerCase() !== "x-powered-by"
+      )
+    );
 
     return {
       ...response,
-      header: { ...response.header, "x-powered-by": value },
+      header: { ...responseHeaders, "x-powered-by": value },
     } satisfies IHttpResponse;
   });
 }

package/dist/lib/middleware/requestId.ts

@@ -1,29 +1,29 @@
 import type { IHttpResponse } from "@rexeus/typeweaver-core";
 import { defineMiddleware } from "../TypedMiddleware.js";
+import { omitHeaders, readSingletonHeader } from "./header.js";
 
 export type RequestIdOptions = {
   readonly headerName?: string;
   readonly generator?: () => string;
 };
 
+const isValidRequestId = (value: string | undefined): value is string =>
+  value !== undefined && value.length > 0 && !/[\r\n]/.test(value);
+
 export function requestId(options?: RequestIdOptions) {
   const headerName = (options?.headerName ?? "x-request-id").toLowerCase();
   const generator = options?.generator ?? (() => crypto.randomUUID());
 
   return defineMiddleware<{ requestId: string }>(async (ctx, next) => {
-    const existing = ctx.request.header?.[headerName];
-    const id =
-      typeof existing === "string"
-        ? existing
-        : Array.isArray(existing)
-          ? (existing[0] ?? generator())
-          : generator();
+    const existing = readSingletonHeader(ctx.request.header, headerName);
+    const id = isValidRequestId(existing) ? existing : generator();
 
     const response = await next({ requestId: id });
+    const header = omitHeaders(response.header, [headerName]);
 
     return {
       ...response,
-      header: { ...response.header, [headerName]: id },
+      header: { ...header, [headerName]: id },
     } satisfies IHttpResponse;
   });
 }

package/dist/lib/middleware/scoped.ts

@@ -2,55 +2,70 @@ import { pathMatcher } from "../PathMatcher.js";
 import { defineMiddleware } from "../TypedMiddleware.js";
 import type { TypedMiddleware } from "../TypedMiddleware.js";
 
+type NoProvidedKeys<TProvides extends Record<string, unknown>> = [
+  keyof TProvides,
+] extends [never]
+  ? unknown
+  : never;
+
 /**
  * Restricts a middleware to only run on paths matching the given patterns.
  *
  * Accepts the same pattern syntax as {@link pathMatcher}: exact (`"/users"`),
  * prefix (`"/api/*"`), and parameterized (`"/users/:id"`).
  *
- * Only accepts non-state middleware (`TypedMiddleware<{}, {}>`) to preserve
+ * Only accepts non-state-providing middleware to preserve
  * TypeWeaver's compile-time state guarantees — skipping a state-providing
  * middleware would leave downstream consumers with missing state.
+ * Any upstream state requirements declared by the wrapped middleware are
+ * preserved on the returned middleware descriptor.
  *
  * @example
  * ```typescript
  * app.use(scoped(["/api/*"], cors({ origin: "https://app.com" })));
  * ```
  */
-export function scoped(
+export function scoped<
+  TProvides extends Record<string, unknown>,
+  TRequires extends Record<string, unknown>,
+>(
   paths: readonly string[],
-  middleware: TypedMiddleware<{}, {}>
-): TypedMiddleware<{}, {}> {
+  middleware: TypedMiddleware<TProvides, TRequires> & NoProvidedKeys<TProvides>
+): TypedMiddleware<TProvides, TRequires> {
   const matchers = paths.map(pathMatcher);
 
-  return defineMiddleware(async (ctx, next) => {
+  return defineMiddleware<{}, TRequires>(async (ctx, next) => {
     if (!matchers.some(match => match(ctx.request.path))) {
       return next();
     }
     return middleware.handler(ctx, next);
-  });
+  }) as TypedMiddleware<TProvides, TRequires>;
 }
 
 /**
  * Runs a middleware on all paths *except* those matching the given patterns.
  *
- * The inverse of {@link scoped}. Same pattern syntax and type constraint.
+ * The inverse of {@link scoped}. Same pattern syntax and type constraints,
+ * including preservation of wrapped middleware state requirements.
  *
  * @example
  * ```typescript
  * app.use(except(["/health", "/ready"], logger()));
  * ```
  */
-export function except(
+export function except<
+  TProvides extends Record<string, unknown>,
+  TRequires extends Record<string, unknown>,
+>(
   paths: readonly string[],
-  middleware: TypedMiddleware<{}, {}>
-): TypedMiddleware<{}, {}> {
+  middleware: TypedMiddleware<TProvides, TRequires> & NoProvidedKeys<TProvides>
+): TypedMiddleware<TProvides, TRequires> {
   const matchers = paths.map(pathMatcher);
 
-  return defineMiddleware(async (ctx, next) => {
+  return defineMiddleware<{}, TRequires>(async (ctx, next) => {
     if (matchers.some(match => match(ctx.request.path))) {
       return next();
     }
     return middleware.handler(ctx, next);
-  });
+  }) as TypedMiddleware<TProvides, TRequires>;
 }

package/dist/lib/middleware/secureHeaders.ts

@@ -1,5 +1,6 @@
 import type { IHttpResponse } from "@rexeus/typeweaver-core";
 import { defineMiddleware } from "../TypedMiddleware.js";
+import { omitHeaders } from "./header.js";
 
 export type SecureHeadersOptions = {
   readonly contentTypeOptions?: string | false;
@@ -48,10 +49,11 @@ export function secureHeaders(options?: SecureHeadersOptions) {
 
   return defineMiddleware(async (_ctx, next) => {
     const response = await next();
+    const header = omitHeaders(response.header, Object.keys(headers));
 
     return {
       ...response,
-      header: { ...headers, ...response.header },
+      header: { ...header, ...headers },
     } satisfies IHttpResponse;
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rexeus/typeweaver-server",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Generates a lightweight, dependency-free server with built-in routing and middleware from your API definitions. Powered by Typeweaver.",
   "type": "module",
   "sideEffects": false,
@@ -47,15 +47,18 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.10.2",
-    "@rexeus/typeweaver-gen": "^0.10.2"
+    "@rexeus/typeweaver-core": "^0.10.4",
+    "@rexeus/typeweaver-gen": "^0.10.4"
   },
   "devDependencies": {
     "get-port": "^7.2.0",
     "test-utils": "file:../test-utils",
     "tsx": "^4.21.0",
-    "@rexeus/typeweaver-core": "^0.10.2",
-    "@rexeus/typeweaver-gen": "^0.10.2"
+    "@rexeus/typeweaver-core": "^0.10.4",
+    "@rexeus/typeweaver-gen": "^0.10.4"
+  },
+  "dependencies": {
+    "polycase": "^1.1.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",