Get rid of RequestCapabilities

`RequestCapability` is just enough.

Author: surol

src/core/index.ts

@@ -1,6 +1,5 @@
 export * from './error.means';
 export * from './request-body.means';
-export * from './request-capabilities';
 export * from './request-capability';
 export * from './request-context';
 export * from './request-handler';

src/core/request-capabilities.ts

@@ -2,34 +2,76 @@
  * @packageDocumentation
  * @module @hatsy/hatsy/core
  */
-import { RequestCapabilities } from './request-capabilities';
-import { RequestContext } from './request-context';
 import { RequestHandler } from './request-handler';
-import { RequestModification } from './request-modification';
 
 /**
  * Request processing capability.
  *
  * Modifies request processing context in a certain way when delegates to handler.
  *
- * Request processing capabilities could be be {@link RequestCapabilities combined}.
+ * Request processing capabilities could be {@link RequestCapability.combine combined}.
  *
  * @typeparam TInput  A type of request processing means required in order to apply this capability.
  * @typeparam TExt  A type of extension to request processing means this capability applies.
  */
-export abstract class RequestCapability<TInput, TExt = object> implements RequestCapabilities<TInput, TExt> {
+export abstract class RequestCapability<TInput, TExt = object> {
 
   /**
-   * Builds request modification to apply by {@link for handler}.
+   * Builds request capability by the given `provider`.
    *
-   * @typeparam TMeans  A type of request processing means to modify.
-   * @param context  Request processing context to modify.
+   * @typeparam TInput  A type of request processing means required by this provider.
+   * @typeparam TExt  A type of extension to request processing means this provider applies.
+   * @param provider  Request processing capability provider.
    *
-   * @returns Request modifications to apply, or promise-like instance resolving to it.
+   * @returns Request processing capability that call the given `provider` in order to apply.
    */
-  abstract modification<TMeans extends TInput>(
-      context: RequestContext<TMeans>,
-  ): RequestModification<TMeans, TExt> | PromiseLike<RequestModification<TMeans, TExt>>;
+  static of<TInput, TExt>(
+      this: void,
+      provider: RequestCapability.Provider<TInput, TExt>,
+  ): RequestCapability<TInput, TExt> {
+
+    const capability: RequestCapability<TInput, TExt> = {
+      for: provider,
+      and<TNext>(next: RequestCapability<TInput & TExt, TNext>): RequestCapability<TInput, TExt & TNext> {
+        return RequestCapability.combine(capability, next);
+      },
+    };
+
+    return capability;
+  }
+
+  /**
+   * Combines two request processing capabilities.
+   *
+   * @typeparam TInput  A type of request processing means expected by the `first` capability.
+   * @typeparam TExt  A type of request processing means extension applied by the `first` capability.
+   * @typeparam TNext  A type of request processing means extension applied by the `second` capability.
+   * @param first  First capability to combine.
+   * @param second  Second capability to combine. Receives requests modified by the `first` one.
+   *
+   * @return Combined request processing capability that applies modifications to request by the `first` capability,
+   * and then - by the `second` one.
+   */
+  static combine<TInput, TExt, TNext>(
+      this: void,
+      first: RequestCapability<TInput, TExt>,
+      second: RequestCapability<TInput & TExt, TNext>,
+  ): RequestCapability<TInput, TExt & TNext> {
+
+    const chain: RequestCapability<TInput, TExt & TNext> = {
+
+      for<TMeans extends TInput>(delegate: RequestHandler<TMeans & TExt & TNext>): RequestHandler<TMeans> {
+        return first.for(second.for(delegate));
+      },
+
+      and<T>(next: RequestCapability<TInput & TExt & TNext, T>): RequestCapability<TInput, TExt & TNext & T> {
+        return RequestCapability.combine<TInput, TExt & TNext, T>(chain, next);
+      },
+
+    };
+
+    return chain;
+  }
 
   /**
    * Provides request processing capability to the given handler.
@@ -41,23 +83,46 @@ export abstract class RequestCapability<TInput, TExt = object> implements Reques
    *
    * @returns New request processing handler.
    */
-  for<TMeans extends TInput>(handler: RequestHandler<TMeans & TExt>): RequestHandler<TMeans> {
-    return async context => context.next(handler, await this.modification(context));
-  }
+  abstract for<TMeans extends TInput>(handler: RequestHandler<TMeans & TExt>): RequestHandler<TMeans>;
 
   /**
-   * Combines this capability with the `next` capability set.
+   * Combines this capability with the `next` one.
    *
-   * @typeparam TNext  A type of extension to request processing means applied by `next` capability set.
-   * @param next  Next capability set that receives requests modified by this capability.
+   * @typeparam TNext  A type of extension to request processing means applied by `next` capability.
+   * @param next  Next capability that receives requests modified by this capability.
    *
-   * @return New request processing capability set that applies modifications to request by this capability,
-   * and then - by the `next` capability set.
+   * @return New request processing capability that applies modifications to request by this capability first,
+   * and then - by the `next` one.
    *
-   * @see RequestCapabilities.combine
+   * @see RequestCapability.combine
    */
-  and<TNext>(next: RequestCapabilities<TInput & TExt, TNext>): RequestCapabilities<TInput, TExt & TNext> {
-    return RequestCapabilities.combine<TInput, TExt, TNext>(this, next);
+  and<TNext>(next: RequestCapability<TInput & TExt, TNext>): RequestCapability<TInput, TExt & TNext> {
+    return RequestCapability.combine<TInput, TExt, TNext>(this, next);
   }
 
 }
+
+export namespace RequestCapability {
+
+  /**
+   * Request processing capability provider signature.
+   *
+   * Builds a request processing handler that modifies request and delegates to another one.
+   *
+   * @typeparam TInput  A type of request processing means required by this provider.
+   * @typeparam TExt  A type of extension to request processing means this provider applies.
+   */
+  export type Provider<TInput, TExt = object> =
+  /**
+   * @typeparam TMeans  A type of request processing means expected by constructed handler.
+   *
+   * @param handler  Request processing handler that will receive modified request context.
+   *
+   * @returns New request processing handler.
+   */
+      <TMeans extends TInput>(
+          this: void,
+          handler: RequestHandler<TMeans & TExt>,
+      ) => RequestHandler<TMeans>;
+
+}

src/core/request-capability.ts

@@ -3,7 +3,7 @@
  * @module @hatsy/hatsy
  */
 import { IncomingMessage, ServerResponse } from 'http';
-import { RequestCapabilities, RequestContext, RequestHandler } from '../core';
+import { RequestCapability, RequestContext, RequestHandler } from '../core';
 import { HttpMeans } from './http.means';
 
 /**
@@ -52,12 +52,12 @@ export namespace Middleware {
  * @typeparam TInput  A type of input HTTP request processing means.
  * @param middleware  Middleware to apply.
  *
- * @returns New request processing capability set that processes HTTP requests by the given `middleware`.
+ * @returns New request processing capability that processes HTTP requests by the given `middleware`.
  */
 export function middleware<TInput extends HttpMeans>(
     middleware: Middleware<TInput['request'], TInput['response']>,
-): RequestCapabilities<TInput> {
-  return RequestCapabilities.of(
+): RequestCapability<TInput> {
+  return RequestCapability.of(
       <TMeans extends TInput>(handler: RequestHandler<TMeans>) => async (
           { request, response, next }: RequestContext<TMeans>,
       ) => new Promise<void>((resolve, reject) => {

src/http/middleware.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module @hatsy/hatsy
 */
-import { RequestCapability, RequestContext, requestExtension, RequestModification } from '../../core';
+import { RequestCapability, requestExtension, RequestHandler } from '../../core';
 import { HttpMeans } from '../http.means';
 import { HTML__MIME, JSON__MIME } from '../util';
 import { RenderMeans } from './render.means';
@@ -12,40 +12,43 @@ import { RenderMeans } from './render.means';
  */
 class RenderingCapability extends RequestCapability<HttpMeans, RenderMeans> {
 
-  modification<TMeans extends HttpMeans>(
-      {
-        request: { method },
-        response,
-      }: RequestContext<TMeans>,
-  ): RequestModification<TMeans, RenderMeans> {
+  for<TMeans extends HttpMeans>(
+      handler: RequestHandler<TMeans & RenderMeans>,
+  ): RequestHandler<TMeans> {
+    return ({
+      request: { method },
+      response,
+      next,
+    }) => {
 
-    const renderBody = (body: string | Buffer, encoding: BufferEncoding = 'utf-8'): void => {
+      const renderBody = (body: string | Buffer, encoding: BufferEncoding = 'utf-8'): void => {
 
-      const length = Buffer.isBuffer(body) ? body.byteLength : Buffer.byteLength(body, encoding);
+        const length = Buffer.isBuffer(body) ? body.byteLength : Buffer.byteLength(body, encoding);
 
-      response.setHeader('Content-Length', length);
-      if (method === 'HEAD') {
-        response.end();
-      } else {
-        response.end(body, encoding);
-      }
-    };
+        response.setHeader('Content-Length', length);
+        if (method === 'HEAD') {
+          response.end();
+        } else {
+          response.end(body, encoding);
+        }
+      };
 
-    return requestExtension<TMeans, RenderMeans>({
+      return next(handler, requestExtension<TMeans, RenderMeans>({
 
-      renderBody,
+        renderBody,
 
-      renderHtml(html: string | Buffer) {
-        response.setHeader('Content-Type', `${HTML__MIME}; charset=utf-8`);
-        renderBody(html);
-      },
+        renderHtml(html: string | Buffer) {
+          response.setHeader('Content-Type', `${HTML__MIME}; charset=utf-8`);
+          renderBody(html);
+        },
 
-      renderJson(body: any) {
-        response.setHeader('Content-Type', `${JSON__MIME}; charset=utf-8`);
-        renderBody(JSON.stringify(body));
-      },
+        renderJson(body: any) {
+          response.setHeader('Content-Type', `${JSON__MIME}; charset=utf-8`);
+          renderBody(JSON.stringify(body));
+        },
 
-    });
+      }));
+    };
   }
 
 }