@outfoxx/sunday 1.0.9 → 1.0.10

package/src/fetch-request-factory.ts

@@ -1,225 +0,0 @@
-import { Observable, of, Subscriber } from 'rxjs';
-import { mapTo, switchMap } from 'rxjs/operators';
-import { AnyType } from './any-type';
-import { validate } from './fetch';
-import { FetchEventSource } from './fetch-event-source';
-import { HttpError } from './http-error';
-import { JSONDecoder } from './json-decoder';
-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 {
-  EventTypes,
-  ExtEventSource,
-  RequestAdapter,
-  RequestFactory,
-  RequestSpec,
-} from './request-factory';
-import { URLTemplate } from './url-template';
-
-export class FetchRequestFactory implements RequestFactory {
-  public baseUrl: URLTemplate;
-  public adapter?: RequestAdapter;
-  public mediaTypeEncoders: MediaTypeEncoders;
-  public mediaTypeDecoders: MediaTypeDecoders;
-  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;
-  }
-
-  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
-      );
-      if (!isURLQueryParamsEncoder(encoder)) {
-        throw Error(
-          `MediaTypeEncoder for ${MediaType.WWW_URL_FORM_ENCODED} must be an instance of URLEncoder`
-        );
-      }
-      url.search = `?${encoder.encodeQueryString(requestSpec.queryParameters)}`;
-    }
-
-    const headers = new Headers(requestSpec.headers);
-
-    // Determine & add accept header
-    const supportedAcceptTypes = requestSpec.acceptTypes?.filter((type) =>
-      this.mediaTypeDecoders.supports(type)
-    );
-    if (supportedAcceptTypes?.length) {
-      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);
-    }
-
-    // Encode & add body data
-    let body: BodyInit | undefined;
-    if (requestSpec.body) {
-      if (!contentType) {
-        throw Error('Unsupported content-type for request body');
-      }
-
-      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))
-    );
-  }
-
-  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(mapTo(undefined));
-    } else {
-      return response$.pipe(
-        switchMap(async (response) => {
-          try {
-            const contentType = mediaType(
-              response.headers.get('content-type'),
-              MediaType.OCTET_STREAM
-            );
-            const decoder = this.mediaTypeDecoders.find(contentType);
-            return await decoder.decode(response, responseType);
-          } catch (error) {
-            throw await HttpError.fromResponse(
-              error.message ?? 'Unknown Error',
-              response
-            );
-          }
-        })
-      );
-    }
-  }
-
-  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> {
-    //
-    const adapter = (
-      url: string,
-      requestInit: RequestInit
-    ): Observable<Request> => {
-      const eventSourceSpec = Object.assign({}, requestSpec, {
-        pathTemplate: url,
-      });
-      return this.request(eventSourceSpec, requestInit);
-    };
-
-    const eventSource = 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);
-      };
-    };
-
-    return new Observable((subscriber) => {
-      for (const eventTypeName of Object.keys(eventTypes)) {
-        const eventType = eventTypes[eventTypeName];
-
-        eventSource.addEventListener(
-          eventTypeName,
-          generateEventHandler(eventType, subscriber)
-        );
-
-        eventSource.onerror = (event) => {
-          this.logger?.error?.({ event }, 'event source error');
-        };
-      }
-
-      eventSource.connect();
-
-      return () => {
-        eventSource.close();
-      };
-    });
-  }
-}

package/src/fetch.ts

@@ -1,30 +0,0 @@
-import { mediaType, MediaType } from './media-type';
-import { HttpError } from './http-error';
-import { Problem } from './problem';
-
-export async function validate(
-  response: Response,
-  dataExpected: boolean
-): 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 problemData = await response.json();
-
-    throw new Problem(problemData as Problem);
-  }
-
-  if (dataExpected && (response.status === 204 || response.status === 205)) {
-    throw await HttpError.fromResponse('Unexpected empty response', response);
-  }
-
-  return response;
-}

package/src/http-error.ts

@@ -1,55 +0,0 @@
-export class HttpError extends Error {
-  constructor(
-    message: string,
-    public url: string,
-    public httpVersion: string,
-    public status: number,
-    public statusText: string,
-    public headers: Headers,
-    public body?: string
-  ) {
-    super(message);
-  }
-
-  static async fromResponse(
-    message: string,
-    response: Response
-  ): Promise<HttpError> {
-    let body: string | undefined;
-    try {
-      if (response.headers.get('content-type')?.startsWith('text/')) {
-        body = await response.text();
-      } else {
-        const blob = await response.blob();
-        body = `<binary data: ${blob.size} bytes>`;
-      }
-    } catch (e) {
-      // ignore errors
-      body = '<unable to show response data>';
-    }
-    if (body.length > 512) {
-      body = `${body.slice(0, 512)}<<... another ${body.length - 512} bytes>>`;
-    }
-    const fullMessage = `${message}
-    
-    ########## BEGIN REQUEST ##########
-    
-    HTTP/?.? ${response.status} ${response.statusText}
-    ${Array.from(response.headers.entries())
-      .map(([name, value]) => `${name}: ${value}`)
-      .join('\n    ')}
-    ${body ?? '<none>'}
-    
-    ########### END REQUEST ###########  
-    `;
-    return new HttpError(
-      fullMessage,
-      response.url,
-      '?.?',
-      response.status,
-      response.statusText,
-      response.headers,
-      body
-    );
-  }
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-export * from './any-type';
-export * from './class-type';
-export * from './request-factory';
-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 './logger';
-export * from './http-error';
-export * from './problem';
-export * from './date-time-types';
-
-export * from './util/base64';
-export * from './util/hex';
-export * from './util/rxjs';

package/src/json-decoder.ts

@@ -1,164 +0,0 @@
-import { JsonParser } from '@outfoxx/jackson-js';
-import { CustomMapper, Deserializer } from '@outfoxx/jackson-js/dist/@types';
-import { DateTime } from 'luxon';
-import { AnyType } from './any-type';
-import { MediaTypeDecoder } from './media-type-decoder';
-import { Base64 } from './util/base64';
-
-export class JSONDecoder implements MediaTypeDecoder {
-  static get default(): JSONDecoder {
-    return new JSONDecoder(
-      JSONDecoder.NumericDateDecoding.MILLISECONDS_SINCE_EPOCH
-    );
-  }
-
-  private readonly customDeserializers: CustomMapper<Deserializer>[];
-  private readonly parser = new JsonParser();
-
-  constructor(readonly numericDateDecoding: JSONDecoder.NumericDateDecoding) {
-    this.customDeserializers = [
-      {
-        type: () => Date,
-        mapper: this.dateDeserializer,
-      },
-      {
-        type: () => DateTime,
-        mapper: this.dateTimeDeserializer,
-      },
-      {
-        type: () => URL,
-        mapper: this.urlDeserializer,
-      },
-      {
-        type: () => ArrayBuffer,
-        mapper: this.arrayBufferDeserializer,
-      },
-    ];
-  }
-
-  async decode<T>(response: Response, type: AnyType): Promise<T> {
-    return this.decodeJSON(await response.json(), type);
-  }
-
-  decodeText<T>(text: string, type: AnyType): T {
-    return this.parser.parse(text, {
-      deserializers: this.customDeserializers,
-      mainCreator: () => type,
-    }) as T;
-  }
-
-  decodeJSON<T, U>(value: T, type: AnyType): Promise<U> {
-    return this.parser.transform(value, {
-      deserializers: this.customDeserializers,
-      mainCreator: () => type,
-    });
-  }
-
-  private dateTimeDeserializer: Deserializer = (
-    key: string,
-    value: unknown
-  ) => {
-    if (value == null) {
-      return value;
-    }
-    if (DateTime.isDateTime(value)) {
-      return value;
-    }
-    if (value instanceof Date) {
-      return DateTime.fromJSDate(value, { zone: 'UTC' });
-    }
-    if (typeof value === 'number') {
-      if (
-        this.numericDateDecoding ===
-        JSONDecoder.NumericDateDecoding.MILLISECONDS_SINCE_EPOCH
-      ) {
-        return DateTime.fromMillis(value, { zone: 'UTC' });
-      } else if (
-        this.numericDateDecoding ===
-        JSONDecoder.NumericDateDecoding.SECONDS_SINCE_EPOCH
-      ) {
-        return DateTime.fromSeconds(value, { zone: 'UTC' });
-      } else {
-        console.error('Unsupported date decoding format');
-      }
-    }
-    if (typeof value === 'string') {
-      return DateTime.fromISO(value, { setZone: true });
-    }
-    throw new Error(`Invalid date value for property ${key}`);
-  };
-
-  private dateDeserializer: Deserializer = (key: string, value: unknown) => {
-    if (value == null) {
-      return value;
-    }
-    if (value instanceof Date) {
-      return value;
-    }
-    if (typeof value === 'number') {
-      if (
-        this.numericDateDecoding ===
-        JSONDecoder.NumericDateDecoding.MILLISECONDS_SINCE_EPOCH
-      ) {
-        return new Date(value);
-      } else if (
-        this.numericDateDecoding ===
-        JSONDecoder.NumericDateDecoding.SECONDS_SINCE_EPOCH
-      ) {
-        return new Date(value * 1000);
-      } else {
-        console.error('Unsupported date decoding format');
-      }
-    }
-    if (typeof value === 'string') {
-      return new Date(value);
-    }
-    throw new Error(`Invalid date value for property ${key}`);
-  };
-
-  private urlDeserializer: Deserializer = (key: string, value: unknown) => {
-    if (value == null) {
-      return value;
-    }
-    if (value instanceof URL) {
-      return value;
-    }
-    if (typeof value === 'string') {
-      return new URL(value);
-    }
-    throw Error(`Invalid URL value for property ${key}`);
-  };
-
-  private arrayBufferDeserializer: Deserializer = (
-    key: string,
-    value: unknown
-  ) => {
-    if (value == null) {
-      return value;
-    }
-    if (value instanceof ArrayBuffer) {
-      return value;
-    }
-    if (typeof value === 'string') {
-      return Base64.decode(value);
-    }
-    throw Error(`Invalid ArrayBuffer value for property ${key}`);
-  };
-}
-
-export namespace JSONDecoder {
-  /**
-   * Configures how numeric `Date` & `DateTime` parameters are decoded.
-   */
-  export enum NumericDateDecoding {
-    /**
-     * Decode the `Date`/`DateTime` as a UNIX timestamp (floating point seconds since epoch).
-     */
-    SECONDS_SINCE_EPOCH,
-
-    /**
-     * Decode the `Date`/`DateTime` as UNIX millisecond timestamp (integer milliseconds since epoch).
-     */
-    MILLISECONDS_SINCE_EPOCH,
-  }
-}

package/src/json-encoder.ts

@@ -1,162 +0,0 @@
-import { CustomMapper, Serializer } from '@outfoxx/jackson-js/dist/@types';
-import { DateTime } from 'luxon';
-import { MediaTypeEncoder } from './media-type-encoder';
-import { AnyType } from './any-type';
-import { JsonIncludeType, JsonStringifier } from '@outfoxx/jackson-js';
-import { Base64 } from './util/base64';
-import 'reflect-metadata';
-
-export class JSONEncoder implements MediaTypeEncoder {
-  static get default(): JSONEncoder {
-    return new JSONEncoder(JSONEncoder.DateEncoding.ISO8601);
-  }
-
-  private readonly customSerializers: CustomMapper<Serializer>[];
-  private stringifier = new JsonStringifier();
-
-  constructor(readonly dateEncoding: JSONEncoder.DateEncoding) {
-    this.customSerializers = [
-      {
-        type: () => Date,
-        mapper: this.dateSerializer,
-      },
-      {
-        type: () => DateTime,
-        mapper: this.dateTimeSerializer,
-      },
-      {
-        type: () => URL,
-        mapper: this.urlSerializer,
-      },
-      {
-        type: () => ArrayBuffer,
-        mapper: this.arrayBufferSerializer,
-      },
-    ];
-  }
-
-  encode<T>(value: T, type?: AnyType, includeNulls = false): string {
-    // Use natural type when subtypes exist
-    if (
-      Reflect.hasMetadata(
-        'jackson:defaultContextGroup:JsonSubTypes',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (value as any).constructor ?? {}
-      )
-    ) {
-      type = [Object];
-    }
-
-    return this.stringifier.stringify(value, {
-      serializers: this.customSerializers,
-      features: {
-        serialization: {
-          DEFAULT_PROPERTY_INCLUSION: {
-            value: includeNulls
-              ? JsonIncludeType.ALWAYS
-              : JsonIncludeType.NON_NULL,
-          },
-        },
-      },
-      mainCreator: () => type ?? [Object],
-    });
-  }
-
-  encodeJSON<T>(value: T, type?: AnyType, includeNulls = false): unknown {
-    // Use natural type when subtypes exist
-    if (
-      Reflect.hasMetadata(
-        'jackson:defaultContextGroup:JsonSubTypes',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (value as any).constructor ?? {}
-      )
-    ) {
-      type = [Object];
-    }
-
-    return this.stringifier.transform(value, {
-      serializers: this.customSerializers,
-      features: {
-        serialization: {
-          DEFAULT_PROPERTY_INCLUSION: {
-            value: includeNulls
-              ? JsonIncludeType.ALWAYS
-              : JsonIncludeType.NON_NULL,
-          },
-        },
-      },
-      mainCreator: () => type ?? [Object],
-    });
-  }
-
-  private dateTimeSerializer: Serializer = (key: string, value: DateTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    switch (this.dateEncoding) {
-      case JSONEncoder.DateEncoding.ISO8601:
-        return value.toISO();
-      case JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-        return value.toMillis();
-      case JSONEncoder.DateEncoding.SECONDS_SINCE_EPOCH:
-        return value.toSeconds();
-    }
-  };
-
-  private dateSerializer: Serializer = (key: string, value: Date) => {
-    if (value == null) {
-      return null;
-    }
-
-    switch (this.dateEncoding) {
-      case JSONEncoder.DateEncoding.ISO8601:
-        return value.toISOString();
-      case JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-        return value.getTime();
-      case JSONEncoder.DateEncoding.SECONDS_SINCE_EPOCH:
-        return value.getTime() / 1000;
-    }
-  };
-
-  private urlSerializer: Serializer = (key: string, value: URL) => {
-    if (value == null) {
-      return null;
-    }
-
-    return value.toString();
-  };
-
-  private arrayBufferSerializer: Serializer = (
-    key: string,
-    value: ArrayBuffer
-  ) => {
-    if (value == null) {
-      return null;
-    }
-
-    return Base64.encode(value);
-  };
-}
-
-export namespace JSONEncoder {
-  /**
-   * Configures how `Date` & `DateTime` parameters are encoded.
-   */
-  export enum DateEncoding {
-    /**
-     * Encode `Date`/`DateTime` values as a UNIX timestamp (floating point seconds since epoch).
-     */
-    SECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode `Date`/`DateTime` values as UNIX millisecond timestamp (integer milliseconds since epoch).
-     */
-    MILLISECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode `Date`/`DateTime` values as an ISO-8601-formatted string (in RFC 3339 format). This is the default behavior.
-     */
-    ISO8601,
-  }
-}

package/src/logger.ts

@@ -1,8 +0,0 @@
-export interface Logger {
-  trace?(...data: unknown[]): void;
-  debug?(...data: unknown[]): void;
-  info?(...data: unknown[]): void;
-  log?(...data: unknown[]): void;
-  warn?(...data: unknown[]): void;
-  error?(...data: unknown[]): void;
-}

package/src/media-type-decoder.ts

@@ -1,5 +0,0 @@
-import { AnyType } from './any-type';
-
-export interface MediaTypeDecoder {
-  decode<T>(response: Response, type: AnyType): Promise<T>;
-}