@outfoxx/sunday 1.0.8 → 1.1.0-alpha.10

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

@@ -0,0 +1,328 @@
+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,20 @@
+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-decoders.ts → media-type-codecs/media-type-decoders.ts}

@@ -1,13 +1,16 @@
 import { BinaryDecoder } from './binary-decoder';
 import { CBORDecoder } from './cbor-decoder';
 import { JSONDecoder } from './json-decoder';
-import { MediaType } from './media-type';
+import { MediaType } from '../media-type';
 import { MediaTypeDecoder } from './media-type-decoder';
 
 export interface MediaTypeDecodersBuilder {
   addDefaults(): MediaTypeDecodersBuilder;
 
-  add(mediaType: string, decoder: MediaTypeDecoder): MediaTypeDecodersBuilder;
+  add(
+    mediaType: MediaType,
+    decoder: MediaTypeDecoder
+  ): MediaTypeDecodersBuilder;
 
   build(): MediaTypeDecoders;
 }
@@ -17,11 +20,12 @@ export interface MediaTypeDecodersBuilderConstructor {
 
 export class MediaTypeDecoders {
   static Builder: MediaTypeDecodersBuilderConstructor = class Builder
-    implements MediaTypeDecodersBuilder {
-    decoders = new Map<string, MediaTypeDecoder>();
+    implements MediaTypeDecodersBuilder
+  {
+    decoders = new Map<MediaType, MediaTypeDecoder>();
 
     add(
-      mediaType: string,
+      mediaType: MediaType,
       decoder: MediaTypeDecoder
     ): MediaTypeDecodersBuilder {
       this.decoders.set(mediaType, decoder);
@@ -30,7 +34,7 @@ export class MediaTypeDecoders {
 
     addDefaults(): MediaTypeDecodersBuilder {
       return this.add(MediaType.JSON, JSONDecoder.default)
-        .add(MediaType.OCTET_STREAM, new BinaryDecoder())
+        .add(MediaType.OctetStream, new BinaryDecoder())
         .add(MediaType.CBOR, CBORDecoder.default);
     }
 
@@ -43,17 +47,21 @@ export class MediaTypeDecoders {
     .addDefaults()
     .build();
 
-  constructor(private decoders: Map<string, MediaTypeDecoder>) {}
+  constructor(private decoders: Map<MediaType, MediaTypeDecoder>) {}
 
-  supports(mediaType: string): boolean {
-    return this.decoders.has(mediaType);
+  supports(mediaType: MediaType): boolean {
+    return Array.from(this.decoders.keys()).some((key) =>
+      key.compatible(mediaType)
+    );
   }
 
-  find(mediaType: string): MediaTypeDecoder {
-    const decoder = this.decoders.get(mediaType);
-    if (!decoder) {
+  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 decoder;
+    return found[1];
   }
 }

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

@@ -0,0 +1,31 @@
+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-encoders.ts → media-type-codecs/media-type-encoders.ts}

@@ -1,14 +1,17 @@
+import { MediaType } from '../media-type';
 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';
+import { WWWFormUrlEncoder } from './www-form-url-encoder';
 
 export interface MediaTypeEncodersBuilder {
   addDefaults(): MediaTypeEncodersBuilder;
 
-  add(mediaType: string, encoder: MediaTypeEncoder): MediaTypeEncodersBuilder;
+  add(
+    mediaType: MediaType,
+    encoder: MediaTypeEncoder
+  ): MediaTypeEncodersBuilder;
 
   build(): MediaTypeEncoders;
 }
@@ -18,11 +21,12 @@ export interface MediaTypeEncodersBuilderConstructor {
 
 export class MediaTypeEncoders {
   static Builder: MediaTypeEncodersBuilderConstructor = class Builder
-    implements MediaTypeEncodersBuilder {
-    encoders = new Map<string, MediaTypeEncoder>();
+    implements MediaTypeEncodersBuilder
+  {
+    encoders = new Map<MediaType, MediaTypeEncoder>();
 
     add(
-      mediaType: string,
+      mediaType: MediaType,
       encoder: MediaTypeEncoder
     ): MediaTypeEncodersBuilder {
       this.encoders.set(mediaType, encoder);
@@ -31,8 +35,8 @@ export class MediaTypeEncoders {
 
     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.OctetStream, BinaryEncoder.default)
+        .add(MediaType.WWWFormUrlEncoded, WWWFormUrlEncoder.default)
         .add(MediaType.CBOR, CBOREncoder.default);
     }
 
@@ -45,17 +49,21 @@ export class MediaTypeEncoders {
     .addDefaults()
     .build();
 
-  constructor(private encoders: Map<string, MediaTypeEncoder>) {}
+  constructor(private encoders: Map<MediaType, MediaTypeEncoder>) {}
 
-  supports(mediaType: string): boolean {
-    return this.encoders.has(mediaType);
+  supports(mediaType: MediaType): boolean {
+    return Array.from(this.encoders.keys()).some((key) =>
+      key.compatible(mediaType)
+    );
   }
 
-  find(mediaType: string): MediaTypeEncoder {
-    const encoder = this.encoders.get(mediaType);
-    if (!encoder) {
+  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 encoder;
+    return found[1];
   }
 }