@outfoxx/sunday 1.1.0-alpha.8 → 1.1.0-beta.1

package/src/fetch-request-factory.ts

@@ -1,10 +1,23 @@
-import { defer, Observable, of } from 'rxjs';
-import { mapTo, switchMap } from 'rxjs/operators';
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+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 { SundayError } from './sunday-error';
+import { HeaderParameters } from './header-parameters';
 import { Logger } from './logger';
 import { MediaType } from './media-type';
 import { TextMediaTypeDecoder } from './media-type-codecs/media-type-decoder';
@@ -18,8 +31,10 @@ import {
   RequestFactory,
   RequestSpec,
 } from './request-factory';
+import { ResultResponse } from './result-response';
+import { SundayError } from './sunday-error';
 import { URLTemplate } from './url-template';
-import { HeaderParameters } from './header-parameters';
+import { errorToMessage } from './util/error';
 
 export class FetchRequestFactory implements RequestFactory {
   public baseUrl: URLTemplate;
@@ -36,7 +51,7 @@ export class FetchRequestFactory implements RequestFactory {
       mediaTypeEncoders?: MediaTypeEncoders;
       mediaTypeDecoders?: MediaTypeDecoders;
       logger?: Logger;
-    }
+    },
   ) {
     this.baseUrl =
       typeof baseUrl === 'string' ? new URLTemplate(baseUrl) : baseUrl;
@@ -50,7 +65,7 @@ export class FetchRequestFactory implements RequestFactory {
 
   registerProblem(
     type: URL | string,
-    problemType: ConstructableClassType<Problem>
+    problemType: ConstructableClassType<Problem>,
   ): void {
     const typeStr = type instanceof URL ? type.toString() : type;
     this.problemTypes.set(typeStr, problemType);
@@ -58,26 +73,26 @@ export class FetchRequestFactory implements RequestFactory {
 
   request(
     requestSpec: RequestSpec<unknown>,
-    requestInit?: RequestInit
+    requestInit?: RequestInit,
   ): Observable<Request> {
     //
     return defer(() => {
       const url = this.baseUrl.complete(
         requestSpec.pathTemplate,
-        requestSpec.pathParameters ?? {}
+        requestSpec.pathParameters ?? {},
       );
 
       if (requestSpec.queryParameters) {
         const encoder = this.mediaTypeEncoders.find(
-          MediaType.WWWFormUrlEncoded
+          MediaType.WWWFormUrlEncoded,
         );
         if (!isURLQueryParamsEncoder(encoder)) {
           throw Error(
-            `MediaTypeEncoder for ${MediaType.WWWFormUrlEncoded} must be an instance of URLQueryParamsEncoder`
+            `MediaTypeEncoder for ${MediaType.WWWFormUrlEncoded} must be an instance of URLQueryParamsEncoder`,
           );
         }
         url.search = `?${encoder.encodeQueryString(
-          requestSpec.queryParameters
+          requestSpec.queryParameters,
         )}`;
       }
 
@@ -86,12 +101,12 @@ export class FetchRequestFactory implements RequestFactory {
       // Determine & add accept header
       if (requestSpec.acceptTypes) {
         const supportedAcceptTypes = requestSpec.acceptTypes.filter((type) =>
-          this.mediaTypeDecoders.supports(type)
+          this.mediaTypeDecoders.supports(type),
         );
 
         if (!supportedAcceptTypes.length) {
           throw Error(
-            'None of the provided accept types has a reqistered decoder'
+            'None of the provided accept types has a reqistered decoder',
           );
         }
 
@@ -102,7 +117,7 @@ export class FetchRequestFactory implements RequestFactory {
 
       // Determine content type
       const contentType = requestSpec.contentTypes?.find((type) =>
-        this.mediaTypeEncoders.supports(type)
+        this.mediaTypeEncoders.supports(type),
       );
 
       // If matched, add content type (even if body is nil, to match any expected server requirements)
@@ -115,7 +130,7 @@ export class FetchRequestFactory implements RequestFactory {
       if (requestSpec.body) {
         if (!contentType) {
           throw Error(
-            'None of the provided content types has a registered encoder'
+            'None of the provided content types has a registered encoder',
           );
         }
 
@@ -138,45 +153,92 @@ export class FetchRequestFactory implements RequestFactory {
 
   response(
     request: Request | RequestSpec<unknown>,
-    dataExpected?: boolean
+    dataExpected?: boolean,
   ): Observable<Response> {
     const request$ =
       request instanceof Request ? of(request) : this.request(request);
     return request$.pipe(
       switchMap((req) => fetch(req)),
       switchMap((response) =>
-        validate(response, dataExpected ?? false, this.problemTypes)
-      )
+        validate(response, dataExpected ?? false, this.problemTypes),
+      ),
     );
   }
 
+  resultResponse<B, R>(
+    requestSpec: RequestSpec<B>,
+    resultType: AnyType,
+  ): Observable<ResultResponse<R>>;
+  resultResponse<B>(
+    requestSpec: RequestSpec<B>,
+  ): Observable<ResultResponse<void>>;
+  resultResponse(
+    request: RequestSpec<unknown>,
+    responseType?: AnyType,
+  ): Observable<ResultResponse<unknown>> {
+    const response$ = this.response(request, !!responseType);
+
+    if (!responseType) {
+      return response$.pipe(
+        map((response) => {
+          return {
+            result: undefined,
+            response,
+          };
+        }),
+      );
+    } else {
+      return response$.pipe(
+        switchMap(async (response) => {
+          try {
+            const contentType = MediaType.from(
+              response.headers.get('content-type'),
+              MediaType.OctetStream,
+            );
+            const decoder = this.mediaTypeDecoders.find(contentType);
+            const result = await decoder.decode(response, responseType);
+            return {
+              result,
+              response,
+            };
+          } catch (error) {
+            throw await SundayError.fromResponse(
+              errorToMessage(error, 'Response Decoding Failed'),
+              response,
+            );
+          }
+        }),
+      );
+    }
+  }
+
   result<B, R>(requestSpec: RequestSpec<B>, resultType: AnyType): Observable<R>;
   result<B>(requestSpec: RequestSpec<B>): Observable<void>;
   result(
     request: RequestSpec<unknown>,
-    responseType?: AnyType
+    responseType?: AnyType,
   ): Observable<unknown> {
     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.from(
               response.headers.get('content-type'),
-              MediaType.OctetStream
+              MediaType.OctetStream,
             );
             const decoder = this.mediaTypeDecoders.find(contentType);
             return await decoder.decode(response, responseType);
           } catch (error) {
             throw await SundayError.fromResponse(
-              error.message ?? 'Response Decoding Failed',
-              response
+              errorToMessage(error, 'Response Decoding Failed'),
+              response,
             );
           }
-        })
+        }),
       );
     }
   }
@@ -185,7 +247,7 @@ export class FetchRequestFactory implements RequestFactory {
     //
     const adapter = (
       url: string,
-      requestInit: RequestInit
+      requestInit: RequestInit,
     ): Observable<Request> => {
       const eventSourceSpec = Object.assign({}, requestSpec, {
         pathTemplate: url,
@@ -193,12 +255,10 @@ 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,
     });
-
-    return eventSource;
   }
 
   eventStream<E>(
@@ -208,13 +268,13 @@ export class FetchRequestFactory implements RequestFactory {
       event: string | undefined,
       id: string | undefined,
       data: string,
-      logger?: Logger
-    ) => E | undefined
+      logger?: Logger,
+    ) => E | undefined,
   ): Observable<E> {
     const eventSource = this.eventSource(requestSpec);
 
     const jsonDecoder = this.mediaTypeDecoders.find(
-      MediaType.JSON
+      MediaType.JSON,
     ) as TextMediaTypeDecoder;
 
     return new Observable((subscriber) => {
@@ -229,7 +289,7 @@ export class FetchRequestFactory implements RequestFactory {
             event.type,
             event.lastEventId,
             event.data,
-            this.logger
+            this.logger,
           );
           if (!decodedEvent) {
             return;

package/src/fetch.ts

@@ -1,27 +1,46 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 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,
-  problemTypes?: Map<string, ConstructableClassType<Problem>>
+  problemTypes?: Map<string, ConstructableClassType<Problem>>,
 ): Promise<Response> {
   if (response.status < 200 || response.status >= 300) {
     const mediaType = MediaType.from(
       response.headers.get('content-type'),
-      MediaType.OctetStream
+      MediaType.OctetStream,
     );
-    const isProblemJSON = mediaType?.compatible(MediaType.ProblemJSON) ?? false;
-    if (!isProblemJSON) {
+    const isProblem = mediaType?.compatible(MediaType.Problem) ?? false;
+    if (!isProblem) {
       throw await Problem.fromResponse(response);
     }
 
     const problemData = await response.json();
     const problemType = problemTypes?.get(problemData.type) ?? Problem;
-    throw new problemType(problemData as Problem);
+    if (problemType.name === 'Problem') {
+      throw new Problem(problemData);
+    } else {
+      throw new problemType(problemData?.instance);
+    }
   }
 
   if (dataExpected && (response.status === 204 || response.status === 205)) {
@@ -45,7 +64,7 @@ export namespace ResponseExample {
 
   export async function bodyExcerpt(
     response: Response,
-    maxLength: number
+    maxLength: number,
   ): Promise<[string, unknown]> {
     let body: unknown;
     let bodyExcerpt: string;
@@ -70,9 +89,9 @@ export namespace ResponseExample {
           bodyExcerpt = Base64.encode(dataSlice);
         }
       }
-    } catch (e) {
+    } catch (error) {
       // ignore errors
-      const message = e.message || e.toString();
+      const message = errorToMessage(error);
       body = bodyExcerpt = `<<error displaying response data: ${message}>>`;
     }
     return [bodyExcerpt, body];

package/src/header-parameters.ts

@@ -1,6 +1,20 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 export namespace HeaderParameters {
   export function encode(
-    parameters?: Record<string, unknown>
+    parameters?: Record<string, unknown>,
   ): [string, string][] {
     if (parameters == null) {
       return [];
@@ -44,7 +58,7 @@ export namespace HeaderParameters {
   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}`
+        `The encoded header value contains one or more invalid characters: header=${name}, value=${value}`,
       );
     }
     return value;

package/src/index.ts

@@ -1,3 +1,17 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 export * from './any-type';
 export * from './class-type';
 export * from './request-factory';

package/src/logger.ts

@@ -1,3 +1,17 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 export interface Logger {
   trace?(...data: unknown[]): void;
   debug?(...data: unknown[]): void;

package/src/media-type-codecs/any-text-decoder.ts

@@ -0,0 +1,34 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { AnyType } from '../any-type';
+import { TextMediaTypeDecoder } from './media-type-decoder';
+
+export class AnyTextDecoder implements TextMediaTypeDecoder {
+  static default = new AnyTextDecoder();
+
+  async decode<T>(response: Response, type: AnyType): Promise<T> {
+    if (type[0] != String) {
+      throw Error('Invalid type, expected String');
+    }
+    return (await response.text()) as unknown as T;
+  }
+
+  decodeText<T>(text: string, type: AnyType): T {
+    if (type[0] != String) {
+      throw Error('Invalid type, expected String');
+    }
+    return text as unknown as T;
+  }
+}

package/src/media-type-codecs/any-text-encoder.ts

@@ -0,0 +1,26 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { MediaTypeEncoder } from './media-type-encoder';
+
+export class AnyTextEncoder implements MediaTypeEncoder {
+  static default = new AnyTextEncoder();
+
+  encode(value: unknown): BodyInit {
+    if (typeof value != 'string') {
+      throw Error('Invalid value, expected string');
+    }
+    return value;
+  }
+}

package/src/media-type-codecs/binary-decoder.ts

@@ -1,3 +1,17 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 import { MediaTypeDecoder } from './media-type-decoder';
 import { AnyConstructableType } from '../any-type';
 
@@ -8,7 +22,7 @@ export class BinaryDecoder implements MediaTypeDecoder {
     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 ||
@@ -18,7 +32,7 @@ export class BinaryDecoder implements MediaTypeDecoder {
     }
 
     throw Error(
-      'Invalid value, expected ArrayBuffer, (Int|Uint)Array or DataView'
+      'Invalid value, expected ArrayBuffer, (Int|Uint)Array or DataView',
     );
   }
 }

package/src/media-type-codecs/binary-encoder.ts

@@ -1,3 +1,17 @@
+// Copyright 2020 Outfox, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 import { MediaTypeEncoder } from './media-type-encoder';
 
 export class BinaryEncoder implements MediaTypeEncoder {
@@ -11,7 +25,7 @@ export class BinaryEncoder implements MediaTypeEncoder {
       !(value instanceof ReadableStream)
     ) {
       throw Error(
-        'Invalid value, expected BufferSource, Blob or ReadableStream'
+        'Invalid value, expected BufferSource, Blob or ReadableStream',
       );
     }
     return value;