@outfoxx/sunday 1.0.9 → 1.1.0-alpha.11

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

@@ -0,0 +1,342 @@
+// 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;
+    }
+
+    switch (this.dateEncoding) {
+      case JSONEncoder.DateEncoding.ISO8601:
+        return this.offsetTimeFormatter.format(value);
+      default:
+        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;
+    }
+
+    switch (this.dateEncoding) {
+      case JSONEncoder.DateEncoding.ISO8601:
+        return DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value);
+      default:
+        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;
+    }
+
+    switch (this.dateEncoding) {
+      case JSONEncoder.DateEncoding.ISO8601:
+        return DateTimeFormatter.ISO_LOCAL_DATE.format(value);
+      default:
+        return [value.year(), value.monthValue(), value.dayOfMonth()];
+    }
+  };
+
+  private localTimeSerializer: Serializer = (_, value: LocalTime) => {
+    if (value == null) {
+      return null;
+    }
+
+    switch (this.dateEncoding) {
+      case JSONEncoder.DateEncoding.ISO8601:
+        return DateTimeFormatter.ISO_LOCAL_TIME.format(value);
+      default:
+        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

@@ -0,0 +1,34 @@
+// 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

@@ -0,0 +1,81 @@
+// 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 { 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.JSON, JSONDecoder.default)
+        .add(MediaType.OctetStream, 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<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

@@ -0,0 +1,45 @@
+// 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

@@ -0,0 +1,83 @@
+// 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 { 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.JSON, JSONEncoder.default)
+        .add(MediaType.OctetStream, BinaryEncoder.default)
+        .add(MediaType.WWWFormUrlEncoded, WWWFormUrlEncoder.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<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];
+  }
+}