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

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

@@ -1,335 +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 {
-  ChronoField,
-  DateTimeFormatter,
-  DateTimeFormatterBuilder,
-  Instant,
-  LocalDate,
-  LocalDateTime,
-  LocalTime,
-  OffsetDateTime,
-  OffsetTime,
-  ResolverStyle,
-  ZonedDateTime,
-} from '@js-joda/core';
-import { JsonIncludeType, JsonStringifier } from '@outfoxx/jackson-js';
-import { CustomMapper, Serializer } from '@outfoxx/jackson-js/dist/@types';
-import 'reflect-metadata';
-import { AnyType } from '../any-type';
-import { Base64 } from '../util/base64';
-import { encodeSeconds, secondsToNumber } from '../util/temporal';
-import { StructuredMediaTypeEncoder } from './media-type-encoder';
-
-export class JSONEncoder implements StructuredMediaTypeEncoder {
-  static get default(): JSONEncoder {
-    return new JSONEncoder(
-      JSONEncoder.DateEncoding.DECIMAL_SECONDS_SINCE_EPOCH,
-    );
-  }
-
-  private readonly customSerializers: CustomMapper<Serializer>[];
-  private stringifier = new JsonStringifier();
-
-  constructor(readonly dateEncoding: JSONEncoder.DateEncoding) {
-    this.customSerializers = [
-      {
-        type: () => Date,
-        mapper: this.dateSerializer,
-      },
-      {
-        type: () => Instant,
-        mapper: this.instantSerializer,
-      },
-      {
-        type: () => ZonedDateTime,
-        mapper: this.zonedDateTimeSerializer,
-      },
-      {
-        type: () => OffsetDateTime,
-        mapper: this.offsetDateTimeSerializer,
-      },
-      {
-        type: () => OffsetTime,
-        mapper: this.offsetTimeSerializer,
-      },
-      {
-        type: () => LocalDateTime,
-        mapper: this.localDateTimeSerializer,
-      },
-      {
-        type: () => LocalDate,
-        mapper: this.localDateSerializer,
-      },
-      {
-        type: () => LocalTime,
-        mapper: this.localTimeSerializer,
-      },
-      {
-        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],
-    });
-  }
-
-  encodeObject<T>(
-    value: T,
-    type?: AnyType,
-    includeNulls = false,
-  ): Record<string, 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 instantSerializer: Serializer = (_, value: Instant) => {
-    if (value == null) {
-      return null;
-    }
-
-    switch (this.dateEncoding) {
-      case JSONEncoder.DateEncoding.ISO8601:
-        return DateTimeFormatter.ISO_INSTANT.format(value);
-      case JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-        return value.toEpochMilli();
-      case JSONEncoder.DateEncoding.DECIMAL_SECONDS_SINCE_EPOCH:
-        return secondsToNumber(value.epochSecond(), value.nano());
-    }
-  };
-
-  private zonedDateTimeSerializer: Serializer = (_, value: ZonedDateTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    switch (this.dateEncoding) {
-      case JSONEncoder.DateEncoding.ISO8601:
-        return DateTimeFormatter.ISO_ZONED_DATE_TIME.format(value);
-      case JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-        return value.toInstant().toEpochMilli();
-      case JSONEncoder.DateEncoding.DECIMAL_SECONDS_SINCE_EPOCH:
-        const instant = value.toInstant();
-        return secondsToNumber(instant.epochSecond(), instant.nano());
-    }
-  };
-
-  private offsetDateTimeSerializer: Serializer = (_, value: OffsetDateTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    switch (this.dateEncoding) {
-      case JSONEncoder.DateEncoding.ISO8601:
-        return DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(value);
-      case JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH:
-        return value.toInstant().toEpochMilli();
-      case JSONEncoder.DateEncoding.DECIMAL_SECONDS_SINCE_EPOCH:
-        const instant = value.toInstant();
-        return secondsToNumber(instant.epochSecond(), instant.nano());
-    }
-  };
-
-  private offsetTimeFormatter = new DateTimeFormatterBuilder()
-    .parseCaseInsensitive()
-    .append(DateTimeFormatter.ISO_LOCAL_TIME)
-    .appendOffsetId()
-    .toFormatter(ResolverStyle.STRICT);
-
-  private offsetTimeSerializer: Serializer = (_, value: OffsetTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    if (this.dateEncoding == JSONEncoder.DateEncoding.ISO8601) {
-      return this.offsetTimeFormatter.format(value);
-    } else {
-      return [
-        value.hour(),
-        value.minute(),
-        ...encodeSeconds(
-          value.second(),
-          this.dateEncoding == JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH
-            ? value.get(ChronoField.MILLI_OF_SECOND)
-            : value.nano(),
-        ),
-        value.offset().toString(),
-      ];
-    }
-  };
-
-  private localDateTimeSerializer: Serializer = (_, value: LocalDateTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    if (this.dateEncoding == JSONEncoder.DateEncoding.ISO8601) {
-      return DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value);
-    } else {
-      return [
-        value.year(),
-        value.monthValue(),
-        value.dayOfMonth(),
-        value.hour(),
-        value.minute(),
-        ...encodeSeconds(
-          value.second(),
-          this.dateEncoding == JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH
-            ? value.get(ChronoField.MILLI_OF_SECOND)
-            : value.nano(),
-        ),
-      ];
-    }
-  };
-
-  private localDateSerializer: Serializer = (_, value: LocalDate) => {
-    if (value == null) {
-      return null;
-    }
-
-    if (this.dateEncoding == JSONEncoder.DateEncoding.ISO8601) {
-      return DateTimeFormatter.ISO_LOCAL_DATE.format(value);
-    } else {
-      return [value.year(), value.monthValue(), value.dayOfMonth()];
-    }
-  };
-
-  private localTimeSerializer: Serializer = (_, value: LocalTime) => {
-    if (value == null) {
-      return null;
-    }
-
-    if (this.dateEncoding == JSONEncoder.DateEncoding.ISO8601) {
-      return DateTimeFormatter.ISO_LOCAL_TIME.format(value);
-    } else {
-      return [
-        value.hour(),
-        value.minute(),
-        ...encodeSeconds(
-          value.second(),
-          this.dateEncoding == JSONEncoder.DateEncoding.MILLISECONDS_SINCE_EPOCH
-            ? value.get(ChronoField.MILLI_OF_SECOND)
-            : value.nano(),
-        ),
-      ];
-    }
-  };
-
-  private dateSerializer: Serializer = (_, 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.DECIMAL_SECONDS_SINCE_EPOCH:
-        return value.getTime() / 1000.0;
-    }
-  };
-
-  private urlSerializer: Serializer = (_, value: URL) => {
-    if (value == null) {
-      return null;
-    }
-
-    return value.toString();
-  };
-
-  private arrayBufferSerializer: Serializer = (_, value: ArrayBuffer) => {
-    if (value == null) {
-      return null;
-    }
-
-    return Base64.encode(value);
-  };
-}
-
-export namespace JSONEncoder {
-  /**
-   * Configures how temporal values are encoded.
-   */
-  export enum DateEncoding {
-    /**
-     * Encode temporal values numerically using seconds with decimal
-     * sub-second precision.
-     */
-    DECIMAL_SECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode temporal values numerically using integer milliseconds.
-     */
-    MILLISECONDS_SINCE_EPOCH,
-
-    /**
-     * Encode temporal values values as an ISO-8601-formatted string (in
-     * RFC 3339 format). This is the default behavior.
-     */
-    ISO8601,
-  }
-}

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

@@ -1,34 +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 { AnyType } from '../any-type';
-
-export interface MediaTypeDecoder {
-  decode<T>(response: Response, type: AnyType): Promise<T>;
-}
-
-export interface TextMediaTypeDecoder extends MediaTypeDecoder {
-  decodeText<T>(text: string, type: AnyType): T;
-}
-
-export interface StructuredMediaTypeDecoder extends MediaTypeDecoder {
-  decodeObject<T>(data: unknown, type: AnyType): T;
-}
-
-export function isStructuredMediaTypeDecoder(
-  decoder: MediaTypeDecoder | StructuredMediaTypeDecoder | undefined,
-): decoder is StructuredMediaTypeDecoder {
-  const rec = decoder as unknown as Record<string, unknown>;
-  return !!rec.decodeObject ?? false;
-}

package/src/media-type-codecs/media-type-decoders.ts

@@ -1,86 +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 { AnyTextDecoder } from './any-text-decoder';
-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: MediaType,
-    decoder: MediaTypeDecoder,
-  ): MediaTypeDecodersBuilder;
-
-  build(): MediaTypeDecoders;
-}
-export interface MediaTypeDecodersBuilderConstructor {
-  new (): MediaTypeDecodersBuilder;
-}
-
-export class MediaTypeDecoders {
-  static Builder: MediaTypeDecodersBuilderConstructor = class Builder
-    implements MediaTypeDecodersBuilder
-  {
-    decoders = new Map<MediaType, MediaTypeDecoder>();
-
-    add(
-      mediaType: MediaType,
-      decoder: MediaTypeDecoder,
-    ): MediaTypeDecodersBuilder {
-      this.decoders.set(mediaType, decoder);
-      return this;
-    }
-
-    addDefaults(): MediaTypeDecodersBuilder {
-      return this.add(MediaType.OctetStream, BinaryDecoder.default)
-        .add(MediaType.JSON, JSONDecoder.default)
-        .add(MediaType.CBOR, CBORDecoder.default)
-        .add(MediaType.EventStream, BinaryDecoder.default)
-        .add(MediaType.AnyText, AnyTextDecoder.default)
-        .add(MediaType.X509CACert, BinaryDecoder.default)
-        .add(MediaType.X509UserCert, BinaryDecoder.default);
-    }
-
-    build(): MediaTypeDecoders {
-      return new MediaTypeDecoders(this.decoders);
-    }
-  };
-
-  static DEFAULT: MediaTypeDecoders = new MediaTypeDecoders.Builder()
-    .addDefaults()
-    .build();
-
-  constructor(private decoders: Map<MediaType, MediaTypeDecoder>) {}
-
-  supports(mediaType: MediaType): boolean {
-    return Array.from(this.decoders.keys()).some((key) =>
-      key.compatible(mediaType),
-    );
-  }
-
-  find(mediaType: MediaType): MediaTypeDecoder {
-    const found = Array.from(this.decoders.entries()).find(([type]) =>
-      type.compatible(mediaType),
-    );
-    if (!found) {
-      throw Error(`Unsupported media type - ${mediaType}`);
-    }
-    return found[1];
-  }
-}

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

@@ -1,45 +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 { 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;
-}
-
-export interface StructuredMediaTypeEncoder extends MediaTypeEncoder {
-  encodeObject<T = unknown>(
-    value: T,
-    type?: AnyType,
-    includeNulls?: boolean,
-  ): Record<string, unknown>;
-}
-
-export function isStructuredMediaTypeEncoder(
-  encoder: MediaTypeEncoder | StructuredMediaTypeEncoder | undefined,
-): encoder is StructuredMediaTypeEncoder {
-  const rec = encoder as unknown as Record<string, unknown>;
-  return !!rec.encodeObject ?? false;
-}

package/src/media-type-codecs/media-type-encoders.ts

@@ -1,88 +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 { MediaType } from '../media-type';
-import { AnyTextEncoder } from './any-text-encoder';
-import { BinaryEncoder } from './binary-encoder';
-import { CBOREncoder } from './cbor-encoder';
-import { JSONEncoder } from './json-encoder';
-import { MediaTypeEncoder } from './media-type-encoder';
-import { WWWFormUrlEncoder } from './www-form-url-encoder';
-
-export interface MediaTypeEncodersBuilder {
-  addDefaults(): MediaTypeEncodersBuilder;
-
-  add(
-    mediaType: MediaType,
-    encoder: MediaTypeEncoder,
-  ): MediaTypeEncodersBuilder;
-
-  build(): MediaTypeEncoders;
-}
-export interface MediaTypeEncodersBuilderConstructor {
-  new (): MediaTypeEncodersBuilder;
-}
-
-export class MediaTypeEncoders {
-  static Builder: MediaTypeEncodersBuilderConstructor = class Builder
-    implements MediaTypeEncodersBuilder
-  {
-    encoders = new Map<MediaType, MediaTypeEncoder>();
-
-    add(
-      mediaType: MediaType,
-      encoder: MediaTypeEncoder,
-    ): MediaTypeEncodersBuilder {
-      this.encoders.set(mediaType, encoder);
-      return this;
-    }
-
-    addDefaults(): MediaTypeEncodersBuilder {
-      return this.add(MediaType.OctetStream, BinaryEncoder.default)
-        .add(MediaType.WWWFormUrlEncoded, WWWFormUrlEncoder.default)
-        .add(MediaType.JSON, JSONEncoder.default)
-        .add(MediaType.JSONStructured, JSONEncoder.default)
-        .add(MediaType.CBOR, CBOREncoder.default)
-        .add(MediaType.AnyText, AnyTextEncoder.default)
-        .add(MediaType.X509CACert, BinaryEncoder.default)
-        .add(MediaType.X509UserCert, BinaryEncoder.default);
-    }
-
-    build(): MediaTypeEncoders {
-      return new MediaTypeEncoders(this.encoders);
-    }
-  };
-
-  static DEFAULT: MediaTypeEncoders = new MediaTypeEncoders.Builder()
-    .addDefaults()
-    .build();
-
-  constructor(private encoders: Map<MediaType, MediaTypeEncoder>) {}
-
-  supports(mediaType: MediaType): boolean {
-    return Array.from(this.encoders.keys()).some((key) =>
-      key.compatible(mediaType),
-    );
-  }
-
-  find(mediaType: MediaType): MediaTypeEncoder {
-    const found = Array.from(this.encoders.entries()).find(([type]) =>
-      type.compatible(mediaType),
-    );
-    if (!found) {
-      throw Error(`Unsupported media type - ${mediaType}`);
-    }
-    return found[1];
-  }
-}