@outfoxx/sunday 1.0.8 → 1.0.10

package/src/media-type-decoders.ts

@@ -1,59 +0,0 @@
-import { BinaryDecoder } from './binary-decoder';
-import { CBORDecoder } from './cbor-decoder';
-import { JSONDecoder } from './json-decoder';
-import { MediaType } from './media-type';
-import { MediaTypeDecoder } from './media-type-decoder';
-
-export interface MediaTypeDecodersBuilder {
-  addDefaults(): MediaTypeDecodersBuilder;
-
-  add(mediaType: string, decoder: MediaTypeDecoder): MediaTypeDecodersBuilder;
-
-  build(): MediaTypeDecoders;
-}
-export interface MediaTypeDecodersBuilderConstructor {
-  new (): MediaTypeDecodersBuilder;
-}
-
-export class MediaTypeDecoders {
-  static Builder: MediaTypeDecodersBuilderConstructor = class Builder
-    implements MediaTypeDecodersBuilder {
-    decoders = new Map<string, MediaTypeDecoder>();
-
-    add(
-      mediaType: string,
-      decoder: MediaTypeDecoder
-    ): MediaTypeDecodersBuilder {
-      this.decoders.set(mediaType, decoder);
-      return this;
-    }
-
-    addDefaults(): MediaTypeDecodersBuilder {
-      return this.add(MediaType.JSON, JSONDecoder.default)
-        .add(MediaType.OCTET_STREAM, new BinaryDecoder())
-        .add(MediaType.CBOR, CBORDecoder.default);
-    }
-
-    build(): MediaTypeDecoders {
-      return new MediaTypeDecoders(this.decoders);
-    }
-  };
-
-  static DEFAULT: MediaTypeDecoders = new MediaTypeDecoders.Builder()
-    .addDefaults()
-    .build();
-
-  constructor(private decoders: Map<string, MediaTypeDecoder>) {}
-
-  supports(mediaType: string): boolean {
-    return this.decoders.has(mediaType);
-  }
-
-  find(mediaType: string): MediaTypeDecoder {
-    const decoder = this.decoders.get(mediaType);
-    if (!decoder) {
-      throw Error(`Unsupported media type - ${mediaType}`);
-    }
-    return decoder;
-  }
-}

package/src/media-type-encoder.ts

@@ -1,16 +0,0 @@
-import { AnyType } from './any-type';
-
-export interface MediaTypeEncoder {
-  encode<T = unknown>(value: T, type: AnyType | undefined): BodyInit;
-}
-
-export interface URLQueryParamsEncoder extends MediaTypeEncoder {
-  encodeQueryString(value: Record<string, unknown>): string;
-}
-
-export function isURLQueryParamsEncoder(
-  encoder: MediaTypeEncoder | URLQueryParamsEncoder | undefined
-): encoder is URLQueryParamsEncoder {
-  const rec = (encoder as unknown) as Record<string, unknown>;
-  return !!rec.encodeQueryString ?? false;
-}

package/src/media-type-encoders.ts

@@ -1,61 +0,0 @@
-import { BinaryEncoder } from './binary-encoder';
-import { CBOREncoder } from './cbor-encoder';
-import { JSONEncoder } from './json-encoder';
-import { MediaType } from './media-type';
-import { MediaTypeEncoder } from './media-type-encoder';
-import { URLEncoder } from './url-encoder';
-
-export interface MediaTypeEncodersBuilder {
-  addDefaults(): MediaTypeEncodersBuilder;
-
-  add(mediaType: string, encoder: MediaTypeEncoder): MediaTypeEncodersBuilder;
-
-  build(): MediaTypeEncoders;
-}
-export interface MediaTypeEncodersBuilderConstructor {
-  new (): MediaTypeEncodersBuilder;
-}
-
-export class MediaTypeEncoders {
-  static Builder: MediaTypeEncodersBuilderConstructor = class Builder
-    implements MediaTypeEncodersBuilder {
-    encoders = new Map<string, MediaTypeEncoder>();
-
-    add(
-      mediaType: string,
-      encoder: MediaTypeEncoder
-    ): MediaTypeEncodersBuilder {
-      this.encoders.set(mediaType, encoder);
-      return this;
-    }
-
-    addDefaults(): MediaTypeEncodersBuilder {
-      return this.add(MediaType.JSON, JSONEncoder.default)
-        .add(MediaType.OCTET_STREAM, BinaryEncoder.default)
-        .add(MediaType.WWW_URL_FORM_ENCODED, URLEncoder.default)
-        .add(MediaType.CBOR, CBOREncoder.default);
-    }
-
-    build(): MediaTypeEncoders {
-      return new MediaTypeEncoders(this.encoders);
-    }
-  };
-
-  static DEFAULT: MediaTypeEncoders = new MediaTypeEncoders.Builder()
-    .addDefaults()
-    .build();
-
-  constructor(private encoders: Map<string, MediaTypeEncoder>) {}
-
-  supports(mediaType: string): boolean {
-    return this.encoders.has(mediaType);
-  }
-
-  find(mediaType: string): MediaTypeEncoder {
-    const encoder = this.encoders.get(mediaType);
-    if (!encoder) {
-      throw Error(`Unsupported media type - ${mediaType}`);
-    }
-    return encoder;
-  }
-}

package/src/media-type.ts

@@ -1,25 +0,0 @@
-export enum MediaType {
-  TEXT = 'text/plain',
-  HTML = 'text/html',
-  JSON = 'application/json',
-  YAML = 'application/yaml',
-  CBOR = 'application/cbor',
-  OCTET_STREAM = 'application/octet-stream',
-  EVENT_STREAM = 'text/event-stream',
-  X509_CA_CERT = 'application/x-x509-ca-cert',
-  WWW_URL_FORM_ENCODED = 'application/x-www-form-urlencoded',
-  PROBLEM_JSON = 'application/problem+json',
-}
-
-export function mediaType(value: string | null | undefined): string | undefined;
-export function mediaType(
-  value: string | null | undefined,
-  def: string
-): string;
-
-export function mediaType(
-  value: string | null | undefined,
-  def?: string
-): string | undefined {
-  return value?.split(';')[0].trim() ?? def;
-}

package/src/problem.ts

@@ -1,25 +0,0 @@
-export interface Problem {
-  type: string;
-  status: number;
-  title: string;
-  detail: string;
-  instance: string;
-  [key: string]: unknown;
-}
-
-export class Problem extends Error implements Problem {
-  public type: string;
-  public status: number;
-  public title: string;
-  public detail: string;
-  public instance: string;
-
-  constructor(json: Record<string, unknown>) {
-    super(`${json.status} ${json.type} - ${json.title}`);
-    this.type = json.type as string;
-    this.status = json.status as number;
-    this.title = json.title as string;
-    this.detail = json.detail as string;
-    this.instance = json.instance as string;
-  }
-}

package/src/request-factory.ts

@@ -1,76 +0,0 @@
-import { ClassList } from '@outfoxx/jackson-js/dist/@types';
-import { Observable } from 'rxjs';
-import { AnyType } from './any-type';
-import { ClassType } from './class-type';
-import { MediaType } from './media-type';
-import { URLTemplate } from './url-template';
-
-export interface RequestFactory {
-  readonly baseUrl: URLTemplate;
-
-  request(requestSpec: RequestSpec<unknown>): Observable<Request>;
-
-  response(request: Request, dataExpected?: boolean): Observable<Response>;
-
-  response<B>(
-    requestSpec: RequestSpec<B>,
-    dataExpected?: boolean
-  ): Observable<Response>;
-
-  result<B, R>(
-    requestSpec: RequestSpec<B>,
-    resultType: [ClassType<R>]
-  ): Observable<R>;
-
-  result<B, R>(
-    requestSpec: RequestSpec<B>,
-    resultType: [ClassType<Array<unknown>>, ClassType<R>]
-  ): Observable<Array<R>>;
-
-  result<B, R>(
-    requestSpec: RequestSpec<B>,
-    resultType: [ClassType<Set<unknown>>, ClassType<R>]
-  ): Observable<Set<R>>;
-
-  result<B, R>(requestSpec: RequestSpec<B>, resultType: AnyType): Observable<R>;
-
-  result<B>(requestSpec: RequestSpec<B>): Observable<void>;
-
-  events(requestSpec: RequestSpec<void>): ExtEventSource;
-
-  events<E>(
-    requestSpec: RequestSpec<void>,
-    eventTypes: EventTypes<E>
-  ): Observable<E>;
-}
-
-export interface ExtEventSource extends EventSource {
-  connect(): void;
-}
-
-export type RequestMethod =
-  | 'GET'
-  | 'PUT'
-  | 'POST'
-  | 'PATCH'
-  | 'DELETE'
-  | 'HEAD'
-  | 'OPTIONS';
-
-export interface RequestSpec<B> {
-  method: RequestMethod;
-  pathTemplate: string;
-  pathParameters?: Record<string, unknown>;
-  queryParameters?: Record<string, unknown>;
-  body?: B;
-  bodyType?: AnyType;
-  contentTypes?: (MediaType | string)[];
-  acceptTypes?: (MediaType | string)[];
-  headers?: HeadersInit;
-}
-
-export interface EventTypes<E> {
-  [key: string]: ClassList<ClassType<E>>;
-}
-
-export type RequestAdapter = (request: Request) => Observable<Request>;

package/src/url-encoder.ts

@@ -1,173 +0,0 @@
-import { URLQueryParamsEncoder } from './media-type-encoder';
-import { DateTime } from 'luxon';
-import { JsonStringifier } from '@outfoxx/jackson-js';
-
-export class URLEncoder implements URLQueryParamsEncoder {
-  static get default(): URLEncoder {
-    return new URLEncoder(
-      URLEncoder.ArrayEncoding.BRACKETED,
-      URLEncoder.BoolEncoding.NUMERIC,
-      URLEncoder.DateEncoding.ISO8601
-    );
-  }
-
-  constructor(
-    private arrayEncoding: URLEncoder.ArrayEncoding,
-    private boolEncoding: URLEncoder.BoolEncoding,
-    private dateEncoding: URLEncoder.DateEncoding,
-    private json = new JsonStringifier(),
-    private encoder = new TextEncoder()
-  ) {}
-
-  encode<T = unknown>(value: T): ArrayBuffer | SharedArrayBuffer {
-    const parameters = this.json.transform(value);
-
-    return this.encoder.encode(this.encodeQueryString(parameters));
-  }
-
-  encodeQueryString(parameters: Record<string, unknown>): string {
-    const components: [string, string][] = [];
-
-    for (const key of Object.keys(parameters).sort()) {
-      components.push(...this.encodeQueryComponent(key, parameters[key]));
-    }
-    return components.map((e) => `${e[0]}=${e[1]}`).join('&');
-  }
-
-  encodeQueryComponent(key: string, value: unknown): [string, string][] {
-    const components: [string, string][] = [];
-
-    if (value === undefined) {
-      return components;
-    }
-
-    if (value instanceof Array) {
-      // encode key according to `arrayEncoding`
-      for (const item of value) {
-        components.push(
-          ...this.encodeQueryComponent(
-            encodeArrayKey(key, this.arrayEncoding),
-            item
-          )
-        );
-      }
-    } else if (DateTime.isDateTime(value) || value instanceof DateTime) {
-      //
-      components.push([
-        encodeURIComponent(key),
-        encodeURIComponent(encodeDate(value, this.dateEncoding)),
-      ]);
-    } else if (typeof value === 'boolean') {
-      //
-      components.push([
-        encodeURIComponent(key),
-        encodeURIComponent(encodeBoolean(value, this.boolEncoding)),
-      ]);
-    } else if (typeof value === 'object') {
-      //
-      const rec = (value ?? {}) as Record<string, unknown>;
-
-      for (const nestedKey of Object.keys(rec)) {
-        components.push(
-          ...this.encodeQueryComponent(`${key}[${nestedKey}]`, rec[nestedKey])
-        );
-      }
-    } else {
-      //
-      components.push([
-        encodeURIComponent(key),
-        encodeURIComponent(`${value}`),
-      ]);
-    }
-
-    return components;
-  }
-}
-
-function encodeArrayKey(
-  key: string,
-  encoding: URLEncoder.ArrayEncoding
-): string {
-  return encoding === URLEncoder.ArrayEncoding.BRACKETED ? `${key}[]` : key;
-}
-
-function encodeBoolean(
-  value: boolean,
-  encoding: URLEncoder.BoolEncoding
-): string {
-  switch (encoding) {
-    case URLEncoder.BoolEncoding.NUMERIC:
-      return value ? '1' : '0';
-    case URLEncoder.BoolEncoding.LITERAL:
-      return value ? 'true' : 'false';
-    default:
-      throw new Error('unknown boolean encoding');
-  }
-}
-
-function encodeDate(
-  value: Date | DateTime,
-  encoding: URLEncoder.DateEncoding
-): string {
-  value = value instanceof Date ? DateTime.fromJSDate(value) : value;
-  switch (encoding) {
-    case URLEncoder.DateEncoding.SECONDS_SINCE_EPOCH:
-      return `${value.toSeconds()}`;
-    case URLEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-      return `${value.toMillis()}`;
-    case URLEncoder.DateEncoding.ISO8601:
-      return value.toISO();
-    default:
-      throw new Error('unknown date encoding');
-  }
-}
-
-export namespace URLEncoder {
-  /**
-   * Configures how `Array` parameters are encoded.
-   */
-  export enum ArrayEncoding {
-    /**
-     * An empty set of square brackets is appended to the key for every value. This is the default behavior.
-     */
-    BRACKETED,
-    /**
-     * No brackets are appended. The key is encoded as is.
-     */
-    UNBRACKETED,
-  }
-
-  /**
-   * Configures how `Bool` parameters are encoded.
-   */
-  export enum BoolEncoding {
-    /**
-     * Encode `true` as `1` and `false` as `0`. This is the default behavior.
-     */
-    NUMERIC,
-    /**
-     * Encode `true` and `false` as string literals.
-     */
-    LITERAL,
-  }
-
-  /**
-   * Configures how `Date` parameters are encoded.
-   */
-  export enum DateEncoding {
-    /**
-     * Encode the `Date` as a UNIX timestamp (floating point seconds since epoch).
-     */
-    SECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode the `Date` as UNIX millisecond timestamp (integer milliseconds since epoch).
-     */
-    MILLISECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode the `Date` as an ISO-8601-formatted string (in RFC 3339 format). This is the default behavior.
-     */
-    ISO8601,
-  }
-}

package/src/url-template.ts

@@ -1,21 +0,0 @@
-import { URI } from 'uri-template-lite';
-
-export class URLTemplate {
-  constructor(
-    public template: string,
-    public parameters: Record<string, unknown> = {}
-  ) {}
-
-  complete(relativeTemplate: string, parameters: Record<string, unknown>): URL {
-    const allParameters = Object.assign({}, this.parameters, parameters);
-    const baseTempl = this.template.endsWith('/')
-      ? this.template.slice(0, -1)
-      : this.template;
-    const relTempl =
-      relativeTemplate.startsWith('/') || !relativeTemplate.length
-        ? relativeTemplate
-        : `/${relativeTemplate}`;
-
-    return new URL(URI.expand(baseTempl + relTempl, allParameters));
-  }
-}

package/src/util/base64.ts

@@ -1,77 +0,0 @@
-const chars =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-/* tslint:disable:no-bitwise */
-
-// Use a lookup table to find the index.
-const lookup = new Uint8Array(256);
-for (let i = 0; i < chars.length; i++) {
-  lookup[chars.charCodeAt(i)] = i;
-}
-
-export namespace Base64 {
-  export function encode(buffer: ArrayBufferLike): string {
-    return encodeSlice(buffer, 0, buffer.byteLength);
-  }
-
-  export function encodeSlice(
-    buffer: ArrayBufferLike,
-    offset: number,
-    length: number
-  ): string {
-    const bytes = new Uint8Array(buffer, offset, length);
-    const len = bytes.length;
-    let base64 = '';
-
-    for (let i = 0; i < len; i += 3) {
-      base64 += chars[bytes[i] >> 2];
-      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
-      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
-      base64 += chars[bytes[i + 2] & 63];
-    }
-
-    if (len % 3 === 2) {
-      base64 = base64.substring(0, base64.length - 1) + '=';
-    } else if (len % 3 === 1) {
-      base64 = base64.substring(0, base64.length - 2) + '==';
-    }
-
-    return base64;
-  }
-
-  export function decode(base64: string): ArrayBuffer {
-    base64 = base64.replace(/[ \n]+/g, '');
-
-    const length = base64.length;
-    let bufferLength = Math.floor(length * 0.75);
-    let i: number;
-    let p = 0;
-    let encoded1: number;
-    let encoded2: number;
-    let encoded3: number;
-    let encoded4: number;
-
-    if (base64[length - 1] === '=') {
-      bufferLength--;
-      if (base64[length - 2] === '=') {
-        bufferLength--;
-      }
-    }
-
-    const arrayBuffer = new ArrayBuffer(bufferLength);
-    const bytes = new Uint8Array(arrayBuffer);
-
-    for (i = 0; i < length; i += 4) {
-      encoded1 = lookup[base64.charCodeAt(i)];
-      encoded2 = lookup[base64.charCodeAt(i + 1)];
-      encoded3 = lookup[base64.charCodeAt(i + 2)];
-      encoded4 = lookup[base64.charCodeAt(i + 3)];
-
-      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
-    }
-
-    return arrayBuffer;
-  }
-}

package/src/util/hex.ts

@@ -1,15 +0,0 @@
-export namespace Hex {
-  export function decode(hex: string): ArrayBuffer {
-    const values = hex.match(/[\da-f]{2}/gi);
-    if (!values) {
-      throw Error('Invalid hex string');
-    }
-    return new Uint8Array(values.map((b) => parseInt(b, 16))).buffer;
-  }
-
-  export function encode(buffer: ArrayBuffer, separator = ''): string {
-    return Array.from(new Uint8Array(buffer))
-      .map((value) => value.toString(16).padStart(2, '0'))
-      .join(separator);
-  }
-}

package/src/util/rxjs.ts

@@ -1,18 +0,0 @@
-import { from, Observable, throwError } from 'rxjs';
-import { catchError } from 'rxjs/operators';
-import { Problem } from '../problem';
-
-export function nullifyNotFound<T>(): (
-  source: Observable<T>
-) => Observable<T | null> {
-  return function <T>(source: Observable<T>): Observable<T | null> {
-    return source.pipe(
-      catchError((error) => {
-        if (!(error instanceof Problem) || error.status !== 404) {
-          return throwError(error);
-        }
-        return from([null]);
-      })
-    );
-  };
-}

package/src/util/stream-rxjs.ts

@@ -1,28 +0,0 @@
-import { Observable } from 'rxjs';
-
-export function fromStream(
-  stream: ReadableStream<Uint8Array>
-): Observable<ArrayBuffer> {
-  return new Observable((subscriber) => {
-    let reader: ReadableStreamDefaultReader | undefined;
-    (async function readLoop() {
-      try {
-        reader = stream.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (value !== undefined) {
-            subscriber.next(value);
-          }
-
-          if (done) {
-            subscriber.complete();
-            return;
-          }
-        }
-      } catch (e) {
-        subscriber.error(e);
-      }
-    })();
-    return () => reader?.cancel();
-  });
-}