@outfoxx/sunday 1.1.0-beta.6 → 1.1.0-beta.7

package/src/fetch-event-source.ts

@@ -1,406 +0,0 @@
-// 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 { EMPTY, map, Observable, of, Subscription, switchMap, tap } from 'rxjs';
-import { EventInfo, EventParser } from './event-parser';
-import { validate } from './fetch';
-import { Logger } from './logger';
-import { MediaType } from './media-type';
-import { ExtEventSource } from './request-factory';
-import { unknownSet } from './util/any';
-import { fromStream } from './util/stream-rxjs';
-
-export interface FetchEventSource {
-  addEventListener<K extends keyof EventSourceEventMap>(
-    type: K,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
-    options?: boolean | AddEventListenerOptions,
-  ): void;
-  removeEventListener<K extends keyof EventSourceEventMap>(
-    type: K,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
-    options?: boolean | EventListenerOptions,
-  ): void;
-}
-
-export class FetchEventSource extends EventTarget implements ExtEventSource {
-  private static LAST_EVENT_ID_HEADER = 'Last-Event-ID';
-  private static MAX_RETRY_TIME_MULTIPLE = 30;
-  private static EVENT_TIMEOUT_DEFAULT = 75;
-  private static EVENT_TIMEOUT_CHECK_INTERVAL = 2;
-
-  CONNECTING = 0;
-  OPEN = 1;
-  CLOSED = 2;
-
-  readyState: number = this.CLOSED;
-  url: string;
-  withCredentials = false;
-  onerror: ((this: EventSource, ev: Event) => unknown) | null = null;
-  onmessage: ((this: EventSource, ev: MessageEvent) => unknown) | null = null;
-  onopen: ((this: EventSource, ev: Event) => unknown) | null = null;
-
-  get retryTime(): number {
-    return this.internalRetryTime;
-  }
-
-  private adapter: (
-    url: string,
-    requestInit: RequestInit,
-  ) => Observable<Request>;
-  private connectionSubscription?: Subscription;
-  private internalRetryTime = 100;
-  private retryAttempt = 0;
-  private connectionAttemptTime = 0;
-  private connectionOrigin?: string;
-  private reconnectTimeoutHandle?: number;
-  private lastEventId?: string;
-  private logger?: Logger;
-  private readonly eventTimeout?: number;
-  private eventTimeoutCheckHandle?: number;
-  private lastEventReceivedTime = 0;
-  private eventParser = new EventParser();
-  private readonly externalAbortController?: AbortController;
-
-  constructor(
-    url: string,
-    eventSourceInit?: EventSourceInit & {
-      adapter?: (url: string, requestInit: RequestInit) => Observable<Request>;
-      eventTimeout?: number;
-      logger?: Logger;
-      abortController?: AbortController;
-    },
-  ) {
-    super();
-    this.url = url;
-    this.adapter =
-      eventSourceInit?.adapter ??
-      ((_url, requestInit) => of(new Request(_url, requestInit)));
-    this.eventTimeout =
-      eventSourceInit?.eventTimeout ??
-      FetchEventSource.EVENT_TIMEOUT_DEFAULT * 1000;
-    this.logger = eventSourceInit?.logger;
-    this.externalAbortController = eventSourceInit?.abortController;
-  }
-
-  //
-  // Connect
-  //
-
-  connect(): void {
-    if (this.readyState === this.CONNECTING || this.readyState === this.OPEN) {
-      this.logger?.trace?.('skipping connect', { state: this.readyState });
-      return;
-    }
-
-    this.internalConnect();
-  }
-
-  private internalConnect() {
-    this.logger?.debug?.('connecting');
-
-    this.readyState = this.CONNECTING;
-
-    const headers = new Headers({
-      accept: MediaType.EventStream.toString(),
-    });
-    if (this.lastEventId) {
-      headers.append(FetchEventSource.LAST_EVENT_ID_HEADER, this.lastEventId);
-    }
-
-    const abortController =
-      this.externalAbortController ?? new AbortController();
-
-    const requestInit: RequestInit = {
-      headers,
-      cache: 'no-store',
-      redirect: 'follow',
-      signal: abortController.signal,
-    };
-
-    this.connectionAttemptTime = Date.now();
-
-    this.connectionSubscription = this.adapter(this.url, requestInit)
-      .pipe(
-        switchMap((request) => fetch(request)),
-        switchMap((response) => validate(response, true)),
-        tap((response) => this.receivedHeaders(response)),
-        switchMap((response) => {
-          const body = response.body;
-          if (!body) {
-            return EMPTY;
-          }
-
-          return fromStream(body);
-        }),
-        map((value) => this.receivedData(value)),
-      )
-      .subscribe({
-        error: (error: unknown) => {
-          this.receivedError(error);
-        },
-        complete: () => {
-          this.receivedComplete();
-        },
-      });
-    this.connectionSubscription.add(() => {
-      abortController.abort();
-    });
-  }
-
-  //
-  // Close
-  //
-
-  close(): void {
-    this.logger?.debug?.('close requested');
-
-    this.readyState = this.CLOSED;
-
-    this.internalClose();
-  }
-
-  private internalClose() {
-    this.connectionSubscription?.unsubscribe();
-    this.connectionSubscription = undefined;
-
-    this.clearReconnect();
-
-    this.stopEventTimeoutCheck();
-  }
-
-  //
-  // Event Timeout
-  //
-
-  private startEventTimeoutCheck(lastEventReceivedTime: number) {
-    this.stopEventTimeoutCheck();
-
-    if (!this.eventTimeout) {
-      return;
-    }
-
-    this.lastEventReceivedTime = lastEventReceivedTime;
-
-    this.logger?.trace?.('starting event timeout checks');
-
-    this.eventTimeoutCheckHandle = window.setInterval(
-      () => this.checkEventTimeout(),
-      FetchEventSource.EVENT_TIMEOUT_CHECK_INTERVAL * 1000,
-    );
-  }
-
-  private stopEventTimeoutCheck() {
-    this.logger?.trace?.('stopping event timeout checks');
-
-    if (this.eventTimeoutCheckHandle) {
-      clearInterval(this.eventTimeoutCheckHandle);
-    }
-    this.eventTimeoutCheckHandle = undefined;
-  }
-
-  private checkEventTimeout() {
-    if (!this.eventTimeout) {
-      this.stopEventTimeoutCheck();
-      return;
-    }
-
-    this.logger?.trace?.('checking event timeout');
-
-    // Check elapsed time since last received event
-    const elapsed = Date.now() - this.lastEventReceivedTime;
-    if (elapsed > this.eventTimeout) {
-      this.logger?.debug?.('event timeout reached', {
-        elapsed,
-      });
-      this.fireErrorEvent(Error('EventTimeout'));
-
-      this.scheduleReconnect();
-    }
-  }
-
-  //
-  // Connection Handlers
-  //
-
-  private receivedHeaders(response: Response) {
-    if (this.readyState !== this.CONNECTING) {
-      this.logger?.error?.('invalid readyState for receivedHeaders', {
-        readyState: this.readyState,
-      });
-
-      this.fireErrorEvent(Error('InvalidState'));
-
-      this.scheduleReconnect();
-      return;
-    }
-
-    this.logger?.debug?.('opened');
-
-    this.connectionOrigin = response.url;
-    this.retryAttempt = 0;
-    this.readyState = this.OPEN;
-
-    // Start event timeout check, treating this
-    // connect as last time we received an event
-    this.startEventTimeoutCheck(Date.now());
-
-    const event = new Event('open');
-    this.onopen?.(event);
-    this.dispatchEvent(event);
-  }
-
-  private receivedData(buffer: ArrayBuffer) {
-    if (this.readyState !== this.OPEN) {
-      this.logger?.error?.('invalid readyState for receiveData', {
-        readyState: this.readyState,
-      });
-
-      this.fireErrorEvent(Error('InvalidState'));
-
-      this.scheduleReconnect();
-      return;
-    }
-
-    this.logger?.debug?.('received data', { length: buffer.byteLength });
-
-    this.eventParser.process(buffer, this.dispatchParsedEvent);
-  }
-
-  private receivedError(error: unknown) {
-    if (this.readyState === this.CLOSED) {
-      return;
-    }
-
-    this.logger?.debug?.('received error', { error });
-    this.fireErrorEvent(error);
-
-    if (this.readyState !== this.CLOSED) {
-      this.scheduleReconnect();
-    }
-  }
-
-  private receivedComplete() {
-    if (this.readyState == this.CLOSED) {
-      return;
-    }
-
-    this.logger?.debug?.('received complete');
-
-    this.scheduleReconnect();
-  }
-
-  //
-  // Reconnection
-  //
-
-  private scheduleReconnect() {
-    this.internalClose();
-
-    // calculate total delay
-    const backOffDelay = Math.pow(this.retryAttempt, 2) * this.retryTime;
-    let retryDelay = Math.min(
-      this.retryTime + backOffDelay,
-      this.retryTime * FetchEventSource.MAX_RETRY_TIME_MULTIPLE,
-    );
-
-    // Adjust delay by amount of time last connect
-    // cycle took, except on the first attempt
-    if (this.retryAttempt > 0) {
-      const connectionTime = Date.now() - this.connectionAttemptTime;
-      // Ensure delay is at least as large as
-      // minimum retry time interval
-      retryDelay = Math.max(retryDelay - connectionTime, this.retryTime);
-    }
-
-    this.retryAttempt++;
-    this.readyState = this.CONNECTING;
-
-    this.logger?.debug?.('scheduling reconnect', { retryDelay });
-
-    this.reconnectTimeoutHandle = window.setTimeout(
-      () => this.internalConnect(),
-      retryDelay,
-    );
-  }
-
-  private clearReconnect() {
-    if (this.reconnectTimeoutHandle) {
-      clearTimeout(this.reconnectTimeoutHandle);
-    }
-    this.reconnectTimeoutHandle = undefined;
-  }
-
-  //
-  // Event Dispatch
-  //
-
-  private dispatchParsedEvent = (eventInfo: EventInfo) => {
-    this.lastEventReceivedTime = Date.now();
-
-    if (eventInfo.retry) {
-      const retryTime = Number.parseInt(eventInfo.retry, 10);
-
-      if (Number.isSafeInteger(retryTime)) {
-        this.logger?.debug?.('updating retry timeout', { retryTime });
-
-        this.internalRetryTime = retryTime;
-      } else {
-        this.logger?.debug?.('ignoring invalid retry timeout event', {
-          eventInfo,
-        });
-      }
-    }
-
-    // skip empty events
-    if (
-      eventInfo.id == null &&
-      eventInfo.event == null &&
-      eventInfo.data == null
-    ) {
-      // skip empty event
-      return;
-    }
-
-    // Save last-event-id if the new id is valid
-    if (eventInfo.id != null) {
-      // Check for NULL as it is not allowed
-      if (eventInfo.id.indexOf('\0') == -1) {
-        this.lastEventId = eventInfo.id;
-      } else {
-        this.logger?.debug?.(
-          'event id contains null, unable to use for last-event-id',
-        );
-      }
-    }
-
-    // Dispatch event
-    const event = new MessageEvent(eventInfo.event ?? 'message', {
-      data: eventInfo.data,
-      lastEventId: this.lastEventId,
-      origin: this.connectionOrigin,
-    });
-
-    this.onmessage?.(event);
-    this.dispatchEvent(event);
-  };
-
-  fireErrorEvent(error: unknown): void {
-    const event = new Event('error');
-    unknownSet(event, 'error', error);
-    this.onerror?.(event);
-  }
-}

package/src/fetch-request-factory.ts

@@ -1,315 +0,0 @@
-// 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 { HeaderParameters } from './header-parameters';
-import { Logger } from './logger';
-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 {
-  ExtEventSource,
-  RequestAdapter,
-  RequestFactory,
-  RequestSpec,
-} from './request-factory';
-import { ResultResponse } from './result-response';
-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(
-    baseUrl: string | URLTemplate,
-    options?: {
-      adapter?: RequestAdapter;
-      mediaTypeEncoders?: MediaTypeEncoders;
-      mediaTypeDecoders?: MediaTypeDecoders;
-      logger?: Logger;
-    },
-  ) {
-    this.baseUrl =
-      typeof baseUrl === 'string' ? new URLTemplate(baseUrl) : baseUrl;
-    this.adapter = options?.adapter;
-    this.mediaTypeEncoders =
-      options?.mediaTypeEncoders ?? MediaTypeEncoders.DEFAULT;
-    this.mediaTypeDecoders =
-      options?.mediaTypeDecoders ?? MediaTypeDecoders.DEFAULT;
-    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> {
-    //
-    return defer(() => {
-      const url = this.baseUrl.complete(
-        requestSpec.pathTemplate,
-        requestSpec.pathParameters ?? {},
-      );
-
-      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,
-        )}`;
-      }
-
-      const headers = new Headers(HeaderParameters.encode(requestSpec.headers));
-
-      // Determine & add accept header
-      if (requestSpec.acceptTypes) {
-        const supportedAcceptTypes = requestSpec.acceptTypes.filter((type) =>
-          this.mediaTypeDecoders.supports(type),
-        );
-
-        if (!supportedAcceptTypes.length) {
-          throw Error(
-            'None of the provided accept types has a reqistered decoder',
-          );
-        }
-
-        const accept = supportedAcceptTypes.join(' , ');
-
-        headers.set('accept', accept);
-      }
-
-      // Determine content type
-      const contentType = requestSpec.contentTypes?.find((type) =>
-        this.mediaTypeEncoders.supports(type),
-      );
-
-      // If matched, add content type (even if body is nil, to match any expected server requirements)
-      if (contentType) {
-        headers.set('content-type', contentType.toString());
-      }
-
-      // 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 request = new Request(url.toString(), init);
-
-      return this.adapter?.(request) ?? of(request);
-    });
-  }
-
-  response(
-    request: Request | RequestSpec<unknown>,
-    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),
-      ),
-    );
-  }
-
-  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,
-  ): Observable<unknown> {
-    const response$ = this.response(request, !!responseType);
-
-    if (!responseType) {
-      return response$.pipe(map(() => undefined));
-    } 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);
-            return await decoder.decode(response, responseType);
-          } catch (error) {
-            throw await SundayError.fromResponse(
-              errorToMessage(error, 'Response Decoding Failed'),
-              response,
-            );
-          }
-        }),
-      );
-    }
-  }
-
-  eventSource(requestSpec: RequestSpec<void>): ExtEventSource {
-    //
-    const adapter = (
-      url: string,
-      requestInit: RequestInit,
-    ): Observable<Request> => {
-      const eventSourceSpec = Object.assign({}, requestSpec, {
-        pathTemplate: url,
-      });
-      return this.request(eventSourceSpec, requestInit);
-    };
-
-    return new FetchEventSource(requestSpec.pathTemplate, {
-      logger: this.logger,
-      adapter,
-    });
-  }
-
-  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) => {
-      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;
-          }
-
-          subscriber.next(decodedEvent);
-        } catch (error) {
-          subscriber.error(error);
-        }
-      };
-
-      eventSource.onerror = (event) => {
-        this.logger?.error?.({ event }, 'event source error');
-      };
-
-      eventSource.connect();
-
-      return () => {
-        eventSource.close();
-      };
-    });
-  }
-}