@fluojs/http 1.0.0-beta.1

package/dist/decorators.js

@@ -0,0 +1,378 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { validateRoutePath } from './route-path.js';
+const standardControllerMetadataKey = Symbol.for('fluo.standard.controller');
+const standardRouteMetadataKey = Symbol.for('fluo.standard.route');
+const standardDtoBindingMetadataKey = Symbol.for('fluo.standard.dto-binding');
+function normalizeProducesMediaTypes(mediaTypes) {
+  const normalized = [];
+  for (const mediaType of mediaTypes) {
+    const value = mediaType.trim();
+    if (!value || normalized.includes(value)) {
+      continue;
+    }
+    normalized.push(value);
+  }
+  return normalized;
+}
+function mergeUnique(existing, values) {
+  const merged = [...(existing ?? [])];
+  for (const value of values) {
+    if (!merged.includes(value)) {
+      merged.push(value);
+    }
+  }
+  return merged;
+}
+function getStandardMetadataBag(metadata) {
+  void metadataSymbol;
+  return metadata;
+}
+function getStandardControllerRecord(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardControllerMetadataKey];
+  if (current) {
+    return current;
+  }
+  const created = {};
+  bag[standardControllerMetadataKey] = created;
+  return created;
+}
+function getStandardRouteMap(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardRouteMetadataKey];
+  if (current) {
+    return current;
+  }
+  const created = new Map();
+  bag[standardRouteMetadataKey] = created;
+  return created;
+}
+function getStandardRouteRecord(metadata, propertyKey) {
+  const routeMap = getStandardRouteMap(metadata);
+  const current = routeMap.get(propertyKey);
+  if (current) {
+    return current;
+  }
+  const created = {};
+  routeMap.set(propertyKey, created);
+  return created;
+}
+function getStandardDtoBindingMap(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardDtoBindingMetadataKey];
+  if (current) {
+    return current;
+  }
+  const created = new Map();
+  bag[standardDtoBindingMetadataKey] = created;
+  return created;
+}
+function mergeStandardDtoBinding(metadata, propertyKey, partial) {
+  const map = getStandardDtoBindingMap(metadata);
+  map.set(propertyKey, {
+    ...map.get(propertyKey),
+    ...partial
+  });
+}
+function createRouteDecorator(method) {
+  return path => {
+    validateRoutePath(path, `@${method}() path`);
+    const decorator = (_value, context) => {
+      const route = getStandardRouteRecord(context.metadata, context.name);
+      route.method = method;
+      route.path = path;
+    };
+    return decorator;
+  };
+}
+function createRouteValueDecorator(apply) {
+  return value => {
+    const decorator = (_target, context) => {
+      apply(getStandardRouteRecord(context.metadata, context.name), value);
+    };
+    return decorator;
+  };
+}
+function createDtoFieldDecorator(source) {
+  return key => {
+    const decorator = (_value, context) => {
+      mergeStandardDtoBinding(context.metadata, context.name, {
+        key,
+        source
+      });
+    };
+    return decorator;
+  };
+}
+
+/**
+ * Marks a class as an HTTP controller and defines its base route path.
+ *
+ * @param basePath Controller base path prefixed to every route declared on the class.
+ * @returns A class decorator that writes controller metadata for route mapping.
+ */
+export function Controller(basePath = '') {
+  validateRoutePath(basePath, '@Controller() base path');
+  const decorator = (_target, context) => {
+    getStandardControllerRecord(context.metadata).basePath = basePath;
+  };
+  return decorator;
+}
+
+/**
+ * Sets API version metadata on a controller or route handler.
+ *
+ * @param version Version label interpreted by runtime versioning strategy (for example `"1"`).
+ * @returns A decorator that applies version metadata at class or method scope.
+ */
+export function Version(version) {
+  const decorator = (_target, context) => {
+    if (context.kind === 'class') {
+      getStandardControllerRecord(context.metadata).version = version;
+      return;
+    }
+    getStandardRouteRecord(context.metadata, context.name).version = version;
+  };
+  return decorator;
+}
+
+/**
+ * Registers a `GET` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `GET` handler mapping.
+ */
+export const Get = createRouteDecorator('GET');
+/**
+ * Registers a `POST` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `POST` handler mapping.
+ */
+export const Post = createRouteDecorator('POST');
+/**
+ * Registers a `PUT` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `PUT` handler mapping.
+ */
+export const Put = createRouteDecorator('PUT');
+/**
+ * Registers a `PATCH` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `PATCH` handler mapping.
+ */
+export const Patch = createRouteDecorator('PATCH');
+/**
+ * Registers a `DELETE` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `DELETE` handler mapping.
+ */
+export const Delete = createRouteDecorator('DELETE');
+/**
+ * Registers an `OPTIONS` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers an `OPTIONS` handler mapping.
+ */
+export const Options = createRouteDecorator('OPTIONS');
+/**
+ * Registers a `HEAD` route handler.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers a `HEAD` handler mapping.
+ */
+export const Head = createRouteDecorator('HEAD');
+/**
+ * Registers a route handler that matches all HTTP methods.
+ *
+ * @param path Route path relative to the controller base path.
+ * @returns A method decorator that registers an all-method handler mapping.
+ */
+export const All = createRouteDecorator('ALL');
+
+/**
+ * Associates a DTO class used for request binding and validation.
+ *
+ * @param dto DTO class consumed by request binding and validation.
+ * @returns A method decorator that stores request DTO metadata for the route.
+ */
+export const RequestDto = createRouteValueDecorator((record, dto) => {
+  record.request = dto;
+});
+
+/**
+ * Declares response media types produced by a route handler.
+ *
+ * @param mediaTypes One or more media type strings written into route metadata.
+ * @returns A method decorator that stores normalized `produces` metadata.
+ */
+export function Produces(...mediaTypes) {
+  return createRouteValueDecorator((record, value) => {
+    record.produces = normalizeProducesMediaTypes(value);
+  })(mediaTypes);
+}
+
+/**
+ * Overrides the default success status code for a route handler.
+ *
+ * @param status HTTP status code used when the route completes successfully.
+ * @returns A method decorator that stores the route-level success status override.
+ */
+export const HttpCode = createRouteValueDecorator((record, status) => {
+  record.successStatus = status;
+});
+
+/**
+ * Reads route-level `@Produces(...)` metadata from a controller method.
+ *
+ * @param controllerToken Controller class containing route metadata.
+ * @param propertyKey Controller method key to read.
+ * @returns A defensive copy of declared media types, or `undefined` when not configured.
+ */
+export function getRouteProducesMetadata(controllerToken, propertyKey) {
+  const bag = controllerToken[metadataSymbol];
+  const routeMap = bag?.[standardRouteMetadataKey];
+  const produces = routeMap?.get(propertyKey)?.produces;
+  return produces ? [...produces] : undefined;
+}
+
+/**
+ * Binds a DTO field from a path parameter.
+ *
+ * @param key Optional source key override. Defaults to the DTO field name.
+ * @returns A field decorator that marks the binding source as `path`.
+ */
+export const FromPath = createDtoFieldDecorator('path');
+/**
+ * Binds a DTO field from query parameters.
+ *
+ * @param key Optional source key override. Defaults to the DTO field name.
+ * @returns A field decorator that marks the binding source as `query`.
+ */
+export const FromQuery = createDtoFieldDecorator('query');
+/**
+ * Binds a DTO field from a request header.
+ *
+ * @param key Optional source key override. Defaults to the DTO field name.
+ * @returns A field decorator that marks the binding source as `header`.
+ */
+export const FromHeader = createDtoFieldDecorator('header');
+/**
+ * Binds a DTO field from a cookie.
+ *
+ * @param key Optional source key override. Defaults to the DTO field name.
+ * @returns A field decorator that marks the binding source as `cookie`.
+ */
+export const FromCookie = createDtoFieldDecorator('cookie');
+/**
+ * Binds a DTO field from the request body.
+ *
+ * @param key Optional source key override. Defaults to the DTO field name.
+ * @returns A field decorator that marks the binding source as `body`.
+ */
+export const FromBody = createDtoFieldDecorator('body');
+
+/**
+ * Marks a DTO field binding as optional.
+ *
+ * @returns A field decorator that marks the DTO binding as optional.
+ */
+export function Optional() {
+  const decorator = (_value, context) => {
+    mergeStandardDtoBinding(context.metadata, context.name, {
+      optional: true
+    });
+  };
+  return decorator;
+}
+
+/**
+ * Applies a field-level converter to a DTO binding.
+ *
+ * @param converter Converter instance or token resolved during request binding.
+ * @returns A field decorator that stores converter metadata for the DTO field.
+ */
+export function Convert(converter) {
+  const decorator = (_value, context) => {
+    mergeStandardDtoBinding(context.metadata, context.name, {
+      converter
+    });
+  };
+  return decorator;
+}
+
+/**
+ * Adds a static response header to the route metadata.
+ *
+ * @param name Response header name.
+ * @param value Static response header value applied by the dispatcher.
+ * @returns A method decorator that appends route-level response-header metadata.
+ */
+export function Header(name, value) {
+  const decorator = (_target, context) => {
+    const route = getStandardRouteRecord(context.metadata, context.name);
+    route.headers = [...(route.headers ?? []), {
+      name,
+      value
+    }];
+  };
+  return decorator;
+}
+
+/**
+ * Marks a route as a redirect with an optional status code.
+ *
+ * @param url Redirect target URL.
+ * @param statusCode Optional explicit redirect status code.
+ * @returns A method decorator that writes redirect metadata for the route.
+ */
+export function Redirect(url, statusCode) {
+  const decorator = (_target, context) => {
+    getStandardRouteRecord(context.metadata, context.name).redirect = {
+      url,
+      statusCode
+    };
+  };
+  return decorator;
+}
+
+/**
+ * Attaches guards to a controller or route handler.
+ *
+ * @param guards One or more guards merged into existing class- or route-level guard metadata.
+ * @returns A decorator applicable to classes and methods.
+ */
+export function UseGuards(...guards) {
+  const decorator = (_target, context) => {
+    if (context.kind === 'class') {
+      const controller = getStandardControllerRecord(context.metadata);
+      controller.guards = mergeUnique(controller.guards, guards);
+      return;
+    }
+    const route = getStandardRouteRecord(context.metadata, context.name);
+    route.guards = mergeUnique(route.guards, guards);
+  };
+  return decorator;
+}
+
+/**
+ * Attaches interceptors to a controller or route handler.
+ *
+ * @param interceptors One or more interceptors merged into existing class- or route-level metadata.
+ * @returns A decorator applicable to classes and methods.
+ */
+export function UseInterceptors(...interceptors) {
+  const decorator = (_target, context) => {
+    if (context.kind === 'class') {
+      const controller = getStandardControllerRecord(context.metadata);
+      controller.interceptors = mergeUnique(controller.interceptors, interceptors);
+      return;
+    }
+    const route = getStandardRouteRecord(context.metadata, context.name);
+    route.interceptors = mergeUnique(route.interceptors, interceptors);
+  };
+  return decorator;
+}

package/dist/dispatch/dispatch-content-negotiation.d.ts

@@ -0,0 +1,9 @@
+import type { ContentNegotiationOptions, FrameworkRequest, HandlerDescriptor, ResponseFormatter } from '../types.js';
+export interface ResolvedContentNegotiation {
+    defaultFormatter: ResponseFormatter;
+    formatters: ResponseFormatter[];
+    normalizedMediaTypes: string[];
+}
+export declare function resolveContentNegotiation(options: ContentNegotiationOptions | undefined): ResolvedContentNegotiation | undefined;
+export declare function selectResponseFormatter(handler: HandlerDescriptor, request: FrameworkRequest, contentNegotiation: ResolvedContentNegotiation): ResponseFormatter;
+//# sourceMappingURL=dispatch-content-negotiation.d.ts.map

package/dist/dispatch/dispatch-content-negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-content-negotiation.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatch-content-negotiation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAQrB,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,EAAE,iBAAiB,CAAC;IACpC,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC;AA2GD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,yBAAyB,GAAG,SAAS,GAAG,0BAA0B,GAAG,SAAS,CA+BhI;AAqCD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,gBAAgB,EACzB,kBAAkB,EAAE,0BAA0B,GAC7C,iBAAiB,CA2CnB"}

package/dist/dispatch/dispatch-content-negotiation.js

@@ -0,0 +1,164 @@
+import { NotAcceptableException } from '../exceptions.js';
+const NO_ACCEPTABLE_REPRESENTATION_MESSAGE = 'No acceptable response representation found.';
+function normalizeMediaType(value) {
+  return value.split(';')[0]?.trim().toLowerCase() ?? '';
+}
+function readAcceptHeader(request) {
+  const raw = request.headers.accept ?? request.headers.Accept;
+  const value = Array.isArray(raw) ? raw.join(',') : raw;
+  const normalized = value?.trim();
+  return normalized ? normalized : undefined;
+}
+function parseQuality(value) {
+  if (!value) {
+    return 1;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 0;
+  }
+  if (parsed > 1) {
+    return 1;
+  }
+  return parsed;
+}
+function getMediaRangeSpecificity(mediaRange) {
+  if (mediaRange === '*/*') {
+    return 0;
+  }
+  if (mediaRange.endsWith('/*')) {
+    return 1;
+  }
+  return 2;
+}
+function parseAcceptHeader(acceptHeader) {
+  const tokens = [];
+  for (const token of acceptHeader.split(',')) {
+    const [rawMediaRange, ...parameterParts] = token.trim().split(';');
+    const mediaRange = normalizeMediaType(rawMediaRange ?? '');
+    if (!mediaRange || !mediaRange.includes('/')) {
+      continue;
+    }
+    let quality = 1;
+    for (const parameterPart of parameterParts) {
+      const [name, value] = parameterPart.trim().split('=');
+      if (name?.toLowerCase() === 'q') {
+        quality = parseQuality(value?.trim());
+        break;
+      }
+    }
+    if (quality <= 0) {
+      continue;
+    }
+    tokens.push({
+      mediaRange,
+      quality,
+      specificity: getMediaRangeSpecificity(mediaRange)
+    });
+  }
+  return tokens.sort((left, right) => {
+    if (right.quality !== left.quality) {
+      return right.quality - left.quality;
+    }
+    return right.specificity - left.specificity;
+  });
+}
+function matchesMediaRange(mediaRange, mediaType) {
+  if (mediaRange === '*/*') {
+    return true;
+  }
+  const [rangeType, rangeSubtype] = mediaRange.split('/');
+  const [mediaTypeType, mediaTypeSubtype] = mediaType.split('/');
+  if (!rangeType || !rangeSubtype || !mediaTypeType || !mediaTypeSubtype) {
+    return false;
+  }
+  if (rangeType !== '*' && rangeType !== mediaTypeType) {
+    return false;
+  }
+  return rangeSubtype === '*' || rangeSubtype === mediaTypeSubtype;
+}
+export function resolveContentNegotiation(options) {
+  if (!options?.formatters?.length) {
+    return undefined;
+  }
+  const seen = new Set();
+  const formatters = options.formatters.filter(formatter => {
+    const mediaType = normalizeMediaType(formatter.mediaType);
+    if (!mediaType || seen.has(mediaType)) {
+      return false;
+    }
+    seen.add(mediaType);
+    return true;
+  });
+  if (!formatters.length) {
+    return undefined;
+  }
+  const defaultMediaType = normalizeMediaType(options.defaultMediaType ?? '');
+  const defaultFormatter = defaultMediaType ? formatters.find(formatter => normalizeMediaType(formatter.mediaType) === defaultMediaType) ?? formatters[0] : formatters[0];
+  return {
+    defaultFormatter,
+    formatters,
+    normalizedMediaTypes: formatters.map(f => normalizeMediaType(f.mediaType))
+  };
+}
+function resolveAllowedFormatters(handler, contentNegotiation) {
+  if (!handler.route.produces?.length) {
+    return {
+      formatters: contentNegotiation.formatters,
+      normalizedMediaTypes: contentNegotiation.normalizedMediaTypes
+    };
+  }
+  const allowed = new Set(handler.route.produces.map(mediaType => normalizeMediaType(mediaType)));
+  const formatters = [];
+  const normalizedMediaTypes = [];
+  for (let i = 0; i < contentNegotiation.formatters.length; i++) {
+    const normalized = contentNegotiation.normalizedMediaTypes[i];
+    if (allowed.has(normalized)) {
+      formatters.push(contentNegotiation.formatters[i]);
+      normalizedMediaTypes.push(normalized);
+    }
+  }
+  return {
+    formatters,
+    normalizedMediaTypes
+  };
+}
+function resolveDefaultFormatter(allowedFormatters, allowedNormalizedMediaTypes, contentNegotiation) {
+  const defaultMediaType = normalizeMediaType(contentNegotiation.defaultFormatter.mediaType);
+  const idx = allowedNormalizedMediaTypes.indexOf(defaultMediaType);
+  return idx >= 0 ? allowedFormatters[idx] : allowedFormatters[0] ?? contentNegotiation.defaultFormatter;
+}
+export function selectResponseFormatter(handler, request, contentNegotiation) {
+  const {
+    formatters: allowedFormatters,
+    normalizedMediaTypes: allowedNormalizedMediaTypes
+  } = resolveAllowedFormatters(handler, contentNegotiation);
+  if (!allowedFormatters.length) {
+    throw new NotAcceptableException(NO_ACCEPTABLE_REPRESENTATION_MESSAGE);
+  }
+  const defaultFormatter = resolveDefaultFormatter(allowedFormatters, allowedNormalizedMediaTypes, contentNegotiation);
+  const acceptHeader = readAcceptHeader(request);
+  if (!acceptHeader) {
+    return defaultFormatter;
+  }
+  const acceptTokens = parseAcceptHeader(acceptHeader);
+  if (!acceptTokens.length) {
+    throw new NotAcceptableException(NO_ACCEPTABLE_REPRESENTATION_MESSAGE);
+  }
+  for (const token of acceptTokens) {
+    if (token.mediaRange === '*/*') {
+      return defaultFormatter;
+    }
+    let matchedFormatter;
+    for (let i = 0; i < allowedFormatters.length; i++) {
+      if (matchesMediaRange(token.mediaRange, allowedNormalizedMediaTypes[i])) {
+        matchedFormatter = allowedFormatters[i];
+        break;
+      }
+    }
+    if (matchedFormatter) {
+      return matchedFormatter;
+    }
+  }
+  throw new NotAcceptableException(NO_ACCEPTABLE_REPRESENTATION_MESSAGE);
+}

package/dist/dispatch/dispatch-error-policy.d.ts

@@ -0,0 +1,3 @@
+import type { FrameworkResponse } from '../types.js';
+export declare function writeErrorResponse(error: unknown, response: FrameworkResponse, requestId?: string): Promise<void>;
+//# sourceMappingURL=dispatch-error-policy.d.ts.map

package/dist/dispatch/dispatch-error-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-error-policy.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatch-error-policy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAiBrD,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQvH"}

package/dist/dispatch/dispatch-error-policy.js

@@ -0,0 +1,24 @@
+import { HandlerNotFoundError } from '../errors.js';
+import { HttpException, InternalServerErrorException, NotFoundException, createErrorResponse } from '../exceptions.js';
+function toHttpException(error) {
+  if (error instanceof HttpException) {
+    return error;
+  }
+  if (error instanceof HandlerNotFoundError) {
+    const message = error instanceof Error ? error.message : 'Resource not found.';
+    return new NotFoundException(message, {
+      cause: error
+    });
+  }
+  return new InternalServerErrorException('Internal server error.', {
+    cause: error
+  });
+}
+export async function writeErrorResponse(error, response, requestId) {
+  if (response.committed) {
+    return;
+  }
+  const httpError = toHttpException(error);
+  response.setStatus(httpError.status);
+  await response.send(createErrorResponse(httpError, requestId));
+}

package/dist/dispatch/dispatch-handler-policy.d.ts

@@ -0,0 +1,3 @@
+import type { Binder, HandlerDescriptor, RequestContext } from '../types.js';
+export declare function invokeControllerHandler(handler: HandlerDescriptor, requestContext: RequestContext, binder?: Binder): Promise<unknown>;
+//# sourceMappingURL=dispatch-handler-policy.d.ts.map

package/dist/dispatch/dispatch-handler-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-handler-policy.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatch-handler-policy.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,MAAM,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKtG,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,cAAc,EAC9B,MAAM,GAAE,MAAsB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAuBlB"}

package/dist/dispatch/dispatch-handler-policy.js

@@ -0,0 +1,21 @@
+import { InvariantError } from '@fluojs/core';
+import { DefaultBinder } from '../adapters/binding.js';
+import { HttpDtoValidationAdapter } from '../adapters/dto-validation-adapter.js';
+const defaultBinder = new DefaultBinder();
+const defaultValidator = new HttpDtoValidationAdapter();
+export async function invokeControllerHandler(handler, requestContext, binder = defaultBinder) {
+  const controller = await requestContext.container.resolve(handler.controllerToken);
+  const method = controller[handler.methodName];
+  if (typeof method !== 'function') {
+    throw new InvariantError(`Controller ${handler.controllerToken.name} does not expose handler method ${handler.methodName}.`);
+  }
+  const argumentResolverContext = {
+    handler,
+    requestContext
+  };
+  const input = handler.route.request ? await binder.bind(handler.route.request, argumentResolverContext) : undefined;
+  if (handler.route.request) {
+    await defaultValidator.validate(input, handler.route.request);
+  }
+  return method.call(controller, input, requestContext);
+}

package/dist/dispatch/dispatch-response-policy.d.ts

@@ -0,0 +1,7 @@
+import { resolveContentNegotiation, type ResolvedContentNegotiation } from './dispatch-content-negotiation.js';
+import { writeErrorResponse } from './dispatch-error-policy.js';
+import type { FrameworkRequest, FrameworkResponse, HandlerDescriptor } from '../types.js';
+export declare function writeSuccessResponse(handler: HandlerDescriptor, request: FrameworkRequest, response: FrameworkResponse, value: unknown, contentNegotiation: ResolvedContentNegotiation | undefined): Promise<void>;
+export { resolveContentNegotiation, writeErrorResponse };
+export type { ResolvedContentNegotiation };
+//# sourceMappingURL=dispatch-response-policy.d.ts.map

package/dist/dispatch/dispatch-response-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-response-policy.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatch-response-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAEzB,KAAK,0BAA0B,EAChC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAcrB,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,OAAO,EACd,kBAAkB,EAAE,0BAA0B,GAAG,SAAS,GACzD,OAAO,CAAC,IAAI,CAAC,CAoCf;AAED,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,CAAC;AACzD,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/dispatch/dispatch-response-policy.js

@@ -0,0 +1,45 @@
+import { resolveContentNegotiation, selectResponseFormatter } from './dispatch-content-negotiation.js';
+import { writeErrorResponse } from './dispatch-error-policy.js';
+function resolveDefaultSuccessStatus(handler, value) {
+  switch (handler.route.method) {
+    case 'POST':
+      return 201;
+    case 'DELETE':
+    case 'OPTIONS':
+      return value === undefined ? 204 : 200;
+    default:
+      return 200;
+  }
+}
+export async function writeSuccessResponse(handler, request, response, value, contentNegotiation) {
+  if (response.committed) {
+    return;
+  }
+  if (handler.route.redirect) {
+    const {
+      url,
+      statusCode = 302
+    } = handler.route.redirect;
+    response.redirect(statusCode, url);
+    return;
+  }
+  const formatter = contentNegotiation ? selectResponseFormatter(handler, request, contentNegotiation) : undefined;
+
+  // Write route-level headers only after successful formatter negotiation so
+  // that a negotiation failure does not leak success-only headers onto the
+  // error response.
+  for (const header of handler.route.headers ?? []) {
+    response.setHeader(header.name, header.value);
+  }
+  if (formatter) {
+    response.setHeader('Content-Type', formatter.mediaType);
+  }
+  if (handler.route.successStatus !== undefined) {
+    response.setStatus(handler.route.successStatus);
+  } else if (response.statusSet !== true) {
+    response.setStatus(resolveDefaultSuccessStatus(handler, value));
+  }
+  const responseBody = formatter ? formatter.format(value) : value;
+  await response.send(responseBody);
+}
+export { resolveContentNegotiation, writeErrorResponse };

package/dist/dispatch/dispatch-routing-policy.d.ts

@@ -0,0 +1,4 @@
+import type { FrameworkRequest, HandlerMapping, HandlerMatch, RequestContext } from '../types.js';
+export declare function matchHandlerOrThrow(handlerMapping: HandlerMapping, request: FrameworkRequest): HandlerMatch;
+export declare function updateRequestParams(requestContext: RequestContext, params: Readonly<Record<string, string>>): void;
+//# sourceMappingURL=dispatch-routing-policy.d.ts.map

package/dist/dispatch/dispatch-routing-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-routing-policy.d.ts","sourceRoot":"","sources":["../../src/dispatch/dispatch-routing-policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElG,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,cAAc,EAAE,OAAO,EAAE,gBAAgB,GAAG,YAAY,CAQ3G;AAED,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAKlH"}