@outfoxx/sunday 1.0.8 → 1.1.0-alpha.10

package/src/fetch-request-factory.ts

@@ -1,29 +1,32 @@
-import { Observable, of, Subscriber } from 'rxjs';
-import { mapTo, switchMap } from 'rxjs/operators';
+import { defer, map, Observable, of, switchMap } from 'rxjs';
 import { AnyType } from './any-type';
+import { ConstructableClassType } from './class-type';
 import { validate } from './fetch';
 import { FetchEventSource } from './fetch-event-source';
-import { HttpError } from './http-error';
-import { JSONDecoder } from './json-decoder';
+import { HeaderParameters } from './header-parameters';
 import { Logger } from './logger';
-import { mediaType, MediaType } from './media-type';
-import { MediaTypeDecoders } from './media-type-decoders';
-import { isURLQueryParamsEncoder } from './media-type-encoder';
-import { MediaTypeEncoders } from './media-type-encoders';
+import { MediaType } from './media-type';
+import { TextMediaTypeDecoder } from './media-type-codecs/media-type-decoder';
+import { MediaTypeDecoders } from './media-type-codecs/media-type-decoders';
+import { isURLQueryParamsEncoder } from './media-type-codecs/media-type-encoder';
+import { MediaTypeEncoders } from './media-type-codecs/media-type-encoders';
+import { Problem } from './problem';
 import {
-  EventTypes,
   ExtEventSource,
   RequestAdapter,
   RequestFactory,
   RequestSpec,
 } from './request-factory';
+import { SundayError } from './sunday-error';
 import { URLTemplate } from './url-template';
+import { errorToMessage } from './util/error';
 
 export class FetchRequestFactory implements RequestFactory {
   public baseUrl: URLTemplate;
   public adapter?: RequestAdapter;
   public mediaTypeEncoders: MediaTypeEncoders;
   public mediaTypeDecoders: MediaTypeDecoders;
+  public problemTypes = new Map<string, ConstructableClassType<Problem>>();
   public logger?: Logger;
 
   constructor(
@@ -45,71 +48,92 @@ export class FetchRequestFactory implements RequestFactory {
     this.logger = options?.logger ?? console;
   }
 
+  registerProblem(
+    type: URL | string,
+    problemType: ConstructableClassType<Problem>
+  ): void {
+    const typeStr = type instanceof URL ? type.toString() : type;
+    this.problemTypes.set(typeStr, problemType);
+  }
+
   request(
     requestSpec: RequestSpec<unknown>,
     requestInit?: RequestInit
   ): Observable<Request> {
     //
-    const url = this.baseUrl.complete(
-      requestSpec.pathTemplate,
-      requestSpec.pathParameters ?? {}
-    );
-
-    if (requestSpec.queryParameters) {
-      const encoder = this.mediaTypeEncoders.find(
-        MediaType.WWW_URL_FORM_ENCODED
+    return defer(() => {
+      const url = this.baseUrl.complete(
+        requestSpec.pathTemplate,
+        requestSpec.pathParameters ?? {}
       );
-      if (!isURLQueryParamsEncoder(encoder)) {
-        throw Error(
-          `MediaTypeEncoder for ${MediaType.WWW_URL_FORM_ENCODED} must be an instance of URLEncoder`
+
+      if (requestSpec.queryParameters) {
+        const encoder = this.mediaTypeEncoders.find(
+          MediaType.WWWFormUrlEncoded
         );
+        if (!isURLQueryParamsEncoder(encoder)) {
+          throw Error(
+            `MediaTypeEncoder for ${MediaType.WWWFormUrlEncoded} must be an instance of URLQueryParamsEncoder`
+          );
+        }
+        url.search = `?${encoder.encodeQueryString(
+          requestSpec.queryParameters
+        )}`;
       }
-      url.search = `?${encoder.encodeQueryString(requestSpec.queryParameters)}`;
-    }
 
-    const headers = new Headers(requestSpec.headers);
+      const headers = new Headers(HeaderParameters.encode(requestSpec.headers));
 
-    // Determine & add accept header
-    const supportedAcceptTypes = requestSpec.acceptTypes?.filter((type) =>
-      this.mediaTypeDecoders.supports(type)
-    );
-    if (supportedAcceptTypes?.length) {
-      const accept = supportedAcceptTypes.join(' , ');
+      // Determine & add accept header
+      if (requestSpec.acceptTypes) {
+        const supportedAcceptTypes = requestSpec.acceptTypes.filter((type) =>
+          this.mediaTypeDecoders.supports(type)
+        );
 
-      headers.set('accept', accept);
-    }
+        if (!supportedAcceptTypes.length) {
+          throw Error(
+            'None of the provided accept types has a reqistered decoder'
+          );
+        }
 
-    // Determine content type
-    const contentType = requestSpec.contentTypes?.find((type) =>
-      this.mediaTypeEncoders.supports(type)
-    );
+        const accept = supportedAcceptTypes.join(' , ');
 
-    // If matched, add content type (even if body is nil, to match any expected server requirements)
-    if (contentType) {
-      headers.set('content-type', contentType);
-    }
+        headers.set('accept', accept);
+      }
+
+      // Determine content type
+      const contentType = requestSpec.contentTypes?.find((type) =>
+        this.mediaTypeEncoders.supports(type)
+      );
 
-    // Encode & add body data
-    let body: BodyInit | undefined;
-    if (requestSpec.body) {
-      if (!contentType) {
-        throw Error('Unsupported content-type for request body');
+      // If matched, add content type (even if body is nil, to match any expected server requirements)
+      if (contentType) {
+        headers.set('content-type', contentType.toString());
       }
 
-      body = this.mediaTypeEncoders
-        .find(contentType)
-        .encode(requestSpec.body, requestSpec.bodyType);
-    }
+      // Encode & add body data
+      let body: BodyInit | undefined;
+      if (requestSpec.body) {
+        if (!contentType) {
+          throw Error(
+            'None of the provided content types has a registered encoder'
+          );
+        }
+
+        body = this.mediaTypeEncoders
+          .find(contentType)
+          .encode(requestSpec.body, requestSpec.bodyType);
+      }
 
-    const init: RequestInit = Object.assign({}, requestInit, {
-      headers,
-      body,
-      method: requestSpec.method,
-    });
+      const init: RequestInit = Object.assign({}, requestInit, {
+        headers,
+        body,
+        method: requestSpec.method,
+      });
 
-    const request = new Request(url.toString(), init);
+      const request = new Request(url.toString(), init);
 
-    return this.adapter?.(request) ?? of(request);
+      return this.adapter?.(request) ?? of(request);
+    });
   }
 
   response(
@@ -120,7 +144,9 @@ export class FetchRequestFactory implements RequestFactory {
       request instanceof Request ? of(request) : this.request(request);
     return request$.pipe(
       switchMap((req) => fetch(req)),
-      switchMap((response) => validate(response, dataExpected ?? false))
+      switchMap((response) =>
+        validate(response, dataExpected ?? false, this.problemTypes)
+      )
     );
   }
 
@@ -133,20 +159,20 @@ export class FetchRequestFactory implements RequestFactory {
     const response$ = this.response(request, !!responseType);
 
     if (!responseType) {
-      return response$.pipe(mapTo(undefined));
+      return response$.pipe(map(() => undefined));
     } else {
       return response$.pipe(
         switchMap(async (response) => {
           try {
-            const contentType = mediaType(
+            const contentType = MediaType.from(
               response.headers.get('content-type'),
-              MediaType.OCTET_STREAM
+              MediaType.OctetStream
             );
             const decoder = this.mediaTypeDecoders.find(contentType);
             return await decoder.decode(response, responseType);
           } catch (error) {
-            throw await HttpError.fromResponse(
-              error.message ?? 'Unknown Error',
+            throw await SundayError.fromResponse(
+              errorToMessage(error, 'Response Decoding Failed'),
               response
             );
           }
@@ -155,15 +181,7 @@ export class FetchRequestFactory implements RequestFactory {
     }
   }
 
-  events(requestSpec: RequestSpec<void>): ExtEventSource;
-  events<E>(
-    requestSpec: RequestSpec<void>,
-    eventTypes: EventTypes<E>
-  ): Observable<E>;
-  events(
-    requestSpec: RequestSpec<void>,
-    eventTypes?: EventTypes<unknown>
-  ): ExtEventSource | Observable<unknown> {
+  eventSource(requestSpec: RequestSpec<void>): ExtEventSource {
     //
     const adapter = (
       url: string,
@@ -175,45 +193,55 @@ export class FetchRequestFactory implements RequestFactory {
       return this.request(eventSourceSpec, requestInit);
     };
 
-    const eventSource = new FetchEventSource(requestSpec.pathTemplate, {
+    return new FetchEventSource(requestSpec.pathTemplate, {
       logger: this.logger,
       adapter,
     });
+  }
 
-    if (!eventTypes) {
-      return eventSource;
-    }
-
-    const generateEventHandler = (
-      eventType: AnyType,
-      subscriber: Subscriber<unknown>
-    ) => {
-      return async (event: Event) => {
-        const decoder = this.mediaTypeDecoders.find(
-          'application/json'
-        ) as JSONDecoder;
-        const msgEvent = event as MessageEvent;
-        const deserializedEvent = await decoder.decodeText(
-          msgEvent.data,
-          eventType
-        );
-        subscriber.next(deserializedEvent);
-      };
-    };
+  eventStream<E>(
+    requestSpec: RequestSpec<void>,
+    decoder: (
+      decoder: TextMediaTypeDecoder,
+      event: string | undefined,
+      id: string | undefined,
+      data: string,
+      logger?: Logger
+    ) => E | undefined
+  ): Observable<E> {
+    const eventSource = this.eventSource(requestSpec);
+
+    const jsonDecoder = this.mediaTypeDecoders.find(
+      MediaType.JSON
+    ) as TextMediaTypeDecoder;
 
     return new Observable((subscriber) => {
-      for (const eventTypeName of Object.keys(eventTypes)) {
-        const eventType = eventTypes[eventTypeName];
+      eventSource.onmessage = (event: MessageEvent<string>) => {
+        if (!event.data) {
+          return;
+        }
+
+        try {
+          const decodedEvent = decoder(
+            jsonDecoder,
+            event.type,
+            event.lastEventId,
+            event.data,
+            this.logger
+          );
+          if (!decodedEvent) {
+            return;
+          }
 
-        eventSource.addEventListener(
-          eventTypeName,
-          generateEventHandler(eventType, subscriber)
-        );
+          subscriber.next(decodedEvent);
+        } catch (error) {
+          subscriber.error(error);
+        }
+      };
 
-        eventSource.onerror = (event) => {
-          this.logger?.error?.({ event }, 'event source error');
-        };
-      }
+      eventSource.onerror = (event) => {
+        this.logger?.error?.({ event }, 'event source error');
+      };
 
       eventSource.connect();
 

package/src/fetch.ts

@@ -1,30 +1,81 @@
-import { mediaType, MediaType } from './media-type';
-import { HttpError } from './http-error';
+import { ConstructableClassType } from './class-type';
+import { MediaType } from './media-type';
 import { Problem } from './problem';
+import { SundayError } from './sunday-error';
+import { Base64 } from './util/base64';
+import { errorToMessage } from './util/error';
 
 export async function validate(
   response: Response,
-  dataExpected: boolean
+  dataExpected: boolean,
+  problemTypes?: Map<string, ConstructableClassType<Problem>>
 ): Promise<Response> {
   if (response.status < 200 || response.status >= 300) {
-    if (
-      mediaType(response.headers.get('content-type')) !== MediaType.PROBLEM_JSON
-    ) {
-      await response.body?.cancel?.();
-      throw await HttpError.fromResponse(
-        'Unacceptable response status code',
-        response
-      );
+    const mediaType = MediaType.from(
+      response.headers.get('content-type'),
+      MediaType.OctetStream
+    );
+    const isProblemJSON = mediaType?.compatible(MediaType.ProblemJSON) ?? false;
+    if (!isProblemJSON) {
+      throw await Problem.fromResponse(response);
     }
 
     const problemData = await response.json();
-
-    throw new Problem(problemData as Problem);
+    const problemType = problemTypes?.get(problemData.type) ?? Problem;
+    throw new problemType(problemData as Problem);
   }
 
   if (dataExpected && (response.status === 204 || response.status === 205)) {
-    throw await HttpError.fromResponse('Unexpected empty response', response);
+    throw await SundayError.fromResponse('Unexpected Empty Response', response);
   }
 
   return response;
 }
+
+export namespace ResponseExample {
+  export function build(response: Response, bodyExample?: string): string {
+    return (
+      `HTTP/?.? ${response.status} ${response.statusText}\n` +
+      Array.from(response.headers.entries())
+        .map(([name, value]) => `${name}: ${value}\n`)
+        .join('') +
+      '\n' +
+      (bodyExample ?? '<none>')
+    );
+  }
+
+  export async function bodyExcerpt(
+    response: Response,
+    maxLength: number
+  ): Promise<[string, unknown]> {
+    let body: unknown;
+    let bodyExcerpt: string;
+    try {
+      if (response.headers.get('content-type')?.startsWith('text/')) {
+        const text = await response.text();
+        body = text;
+        if (text.length > maxLength) {
+          const exampleText = text.slice(0, maxLength);
+          const remainingTextLength = text.length - maxLength;
+          bodyExcerpt = `${exampleText}<<... ${remainingTextLength} characters>>`;
+        } else {
+          bodyExcerpt = text;
+        }
+      } else {
+        const blob = await response.blob();
+        body = blob;
+        if (blob.size > maxLength) {
+          bodyExcerpt = `<<binary data: ${blob.size} bytes>>`;
+        } else {
+          const dataSlice = await blob.slice(0, maxLength).arrayBuffer();
+          bodyExcerpt = Base64.encode(dataSlice);
+        }
+      }
+    } catch (error) {
+      // ignore errors
+      const message = errorToMessage(error);
+      body = bodyExcerpt = `<<error displaying response data: ${message}>>`;
+    }
+    return [bodyExcerpt, body];
+  }
+}

package/src/header-parameters.ts

@@ -0,0 +1,52 @@
+export namespace HeaderParameters {
+  export function encode(
+    parameters?: Record<string, unknown>
+  ): [string, string][] {
+    if (parameters == null) {
+      return [];
+    }
+
+    const headers: [string, string][] = [];
+
+    Object.entries(parameters).forEach(([name, parameter]) => {
+      for (const value of encodeParam(name, parameter)) {
+        headers.push([name, value]);
+      }
+    });
+
+    return headers;
+  }
+
+  function encodeParam(name: string, value: unknown): string[] {
+    if (value == null) {
+      return [];
+    }
+
+    if (value instanceof Array) {
+      const result: string[] = [];
+
+      for (const item of value) {
+        if (item == null) {
+          continue;
+        }
+
+        result.push(validate(name, `${item}`));
+      }
+
+      return result;
+    }
+
+    return [validate(name, `${value}`)];
+  }
+
+  const asciiRegex = /^[\x20-\x7F]*$/;
+
+  function validate(name: string, value: string): string {
+    if (!asciiRegex.test(value)) {
+      throw new Error(
+        `The encoded header value contains one or more invalid characters: header=${name}, value=${value}`
+      );
+    }
+    return value;
+  }
+}

package/src/index.ts

@@ -5,19 +5,19 @@ export * from './fetch-request-factory';
 export * from './fetch-event-source';
 export * from './url-template';
 export * from './media-type';
-export * from './media-type-decoder';
-export * from './media-type-decoders';
-export * from './media-type-encoder';
-export * from './media-type-encoders';
-export * from './json-decoder';
-export * from './json-encoder';
-export * from './cbor-decoder';
-export * from './cbor-encoder';
-export * from './binary-decoder';
-export * from './binary-encoder';
-export * from './url-encoder';
+export * from './media-type-codecs/media-type-decoder';
+export * from './media-type-codecs/media-type-decoders';
+export * from './media-type-codecs/media-type-encoder';
+export * from './media-type-codecs/media-type-encoders';
+export * from './media-type-codecs/json-decoder';
+export * from './media-type-codecs/json-encoder';
+export * from './media-type-codecs/cbor-decoder';
+export * from './media-type-codecs/cbor-encoder';
+export * from './media-type-codecs/binary-decoder';
+export * from './media-type-codecs/binary-encoder';
+export * from './media-type-codecs/www-form-url-encoder';
 export * from './logger';
-export * from './http-error';
+export * from './sunday-error';
 export * from './problem';
 export * from './date-time-types';
 

package/src/{binary-decoder.ts → media-type-codecs/binary-decoder.ts}

@@ -1,14 +1,14 @@
 import { MediaTypeDecoder } from './media-type-decoder';
-import { AnyType } from './any-type';
+import { AnyConstructableType } from '../any-type';
 
 export class BinaryDecoder implements MediaTypeDecoder {
   static default = new BinaryDecoder();
 
-  async decode<T>(response: Response, type: AnyType): Promise<T> {
+  async decode<T>(response: Response, type: AnyConstructableType): Promise<T> {
     const arrayBuffer = await response.arrayBuffer();
 
     if (type[0] === ArrayBuffer) {
-      return (arrayBuffer as unknown) as T;
+      return arrayBuffer as unknown as T;
     } else if (
       type[0] === Uint8Array ||
       type[0] === Int8Array ||