@outfoxx/sunday 1.0.9 → 1.1.0-alpha.11

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/media-type-decoder.ts

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

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/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,
-  }
-}