92 basic date time types (#94)

* Parse and emit date/time type
* Fix ConstantTypeDefParser to skip not explicitly annotated type
* Config date time type target type literal
* Simplify and add test for Context, now super type check is based on String, due to TypeMirror cannot be acquired by name for a dependency class
* Update javadoc on SharedType

Author: cuzfrog

annotation/src/main/java/online/sharedtype/SharedType.java

@@ -49,6 +49,7 @@
  * <p>
  * <b>Cyclic Reference:</b>
  * <ul>
+ *     <li>Typescript: Cyclic referenced field will be optional.</li>
  *     <li>Rust: Cyclic references will be wrapped in {@code Option<Box<T>>}.</li>
  * </ul>
  *
@@ -83,14 +84,22 @@
  * </ul>
  *
  * <p>
- * <b>Maps:</b>
+ * <b>Maps:</b><br>
  * Key must be String or numeric types. Enum is support given that its value is a literal.
  * Custom map types are supported, e.g. a class that extends HashMap. But the type itself is treated as a mapType, so its structure will not be emitted.
  * <ul>
  *     <li>Typescript: e.g. {@code Record<string, T>} where {@code T} can be a reified type. If the key is enum, it will be a {@code Partial<Record<?, ?>>}</li>
  *     <li>Rust: e.g. {@code HashMap<String, T>}, {@code HashMap<EnumType, T>}</li>
  * </ul>
  *
+ * <p>
+ * <b>Date and Time:</b><br>
+ * By default, types that are recognized as date and time are emitted as strings, date/time types are configured via global properties.
+ * The emitted target type can be configured via global properties or via this annotation.
+ * Target type can be any type literal, but SharedType will not verify its validity in emitted code.
+ * </p>
+ *
+ * <br>
  * <p><a href="https://github.com/SharedType/sharedtype">SharedType Website</a></p>
  *
  * @author Cause Chung
@@ -152,6 +161,12 @@
      */
     String[] rustMacroTraits() default {};
 
+    /**
+     * Type literal to be emitted for date/time types. How a java type is considered a date/time type is defined by global properties.
+     * @return any literal, e.g. "String", "chrono::DateTime". When empty, fallback to global default.
+     */
+    String rustTargetDatetimeTypeLiteral() default "";
+
     /**
      * How to render optional fields in Typescript.
      * @return combination of "?", "null", "undefined", the latter 2 are rendered as union types. If empty, fallback to global default.
@@ -173,6 +188,12 @@
      */
     String typescriptFieldReadonlyType() default "";
 
+    /**
+     * Type literal to be emitted for date/time types. How a java type is considered a date/time type is defined by global properties.
+     * @return any literal, e.g. "string", "Date". When empty, fallback to global default.
+     */
+    String typescriptTargetDatetimeTypeLiteral() default "";
+
     /**
      * Mark a method as an accessor regardless of its name.
      * Getter prefixes are configured in global properties.

client-test/typescript/src/types.java17.ts

@@ -3,6 +3,8 @@ import {
     EnumTShirt, type JavaRecord, type AnotherJavaClass, type RecursiveClass, type MapClass,
     type OptionalMethod,
     type ArrayClass,
+    type JavaTimeClass,
+    type JodaTimeClass,
 } from "./index.java17";
 
 export const list1: EnumGalaxy[] = ["Andromeda", "MilkyWay", "Triangulum"];
@@ -106,3 +108,24 @@ optionalMethods.nestedValueOptional = "bar";
 export const arrayClass: ArrayClass = {
     arr: ["abc"],
 }
+
+export const javaTime: JavaTimeClass = {
+    utilDate: new Date(),
+    sqlDate: new Date(),
+    localDate: new Date(),
+    localTime: new Date(),
+    localDateTime: new Date(),
+    zonedDateTime: new Date(),
+    offsetDateTime: new Date(),
+    offsetTime: new Date(),
+    instant: new Date(),
+}
+
+export const jodaTime: JodaTimeClass = {
+    jodaDateTime: "2022-01-01T00:00:00.000+08:00",
+    jodaLocalDate: "2022-01-01T00:00:00.000+08:00",
+    jodaMonthDay: "2022-01-01T00:00:00.000+08:00",
+    jodaLocalTime: "2022-01-01T00:00:00.000+08:00",
+    jodaLocalDateTime: "2022-01-01T00:00:00.000+08:00",
+    jodaOffsetDateTime: "2022-01-01T00:00:00.000+08:00",
+}

internal/src/main/java/online/sharedtype/processor/domain/ArrayTypeInfo.java

@@ -9,6 +9,7 @@
  * Represents an array-like type.
  * During parsing, a predefined array-like type and its subtypes is captured as this class.
  * A type will be recognized as this type with higher priority than {@link ConcreteTypeInfo}.
+ * It has no counterpart typeDef, explicitly annotating {@code @SharedType} on an array type is ignored with a warning.
  * <br>
  * Predefined array-like types can be configured in global properties. Default is {@link java.lang.Iterable}.
  *

internal/src/main/java/online/sharedtype/processor/domain/ClassDef.java

@@ -69,10 +69,7 @@ public Set<ConcreteTypeInfo> typeInfoSet() {
     }
 
     public boolean isMapType() {
-        return typeInfoSet.stream().anyMatch(ConcreteTypeInfo::isMapType);
-    }
-    public boolean isArrayType() {
-        return typeInfoSet.stream().anyMatch(ConcreteTypeInfo::isArrayType);
+        return typeInfoSet.stream().anyMatch(t -> t.getKind() == ConcreteTypeInfo.Kind.MAP);
     }
 
     public void addSubtype(TypeDef subtype) {

internal/src/main/java/online/sharedtype/processor/domain/ConcreteTypeDef.java

@@ -12,7 +12,7 @@
 public abstract class ConcreteTypeDef implements TypeDef {
     private static final long serialVersionUID = 2346502341189835693L;
     /** Whether this type is explicitly annotated with {@link online.sharedtype.SharedType} */
-    private boolean annotated;
+    private final boolean annotated;
     /** Directly or indirectly referenced by a type that is annotated. */
     private boolean referencedByAnnotated;
 

internal/src/main/java/online/sharedtype/processor/domain/ConcreteTypeInfo.java

@@ -13,12 +13,17 @@
 import java.util.stream.Collectors;
 
 /**
- * Represents a primitive type or object type that requires its target representation,
- * and is not recognized as an array-like type.
+ * <p>
+ * Represents a general primitive type or object type that requires its target representation.
  * Like {@link java.lang.String} in typescript as "string", int in typescript as "number".
+ * </p>
+ * <p>
+ * Type with typical signature and render pattern like array-like types are represented as other type info.
+ * </p>
  *
- * @see ArrayTypeInfo
  * @author Cause Chung
+ * @see ArrayTypeInfo
+ * @see Kind
  */
 @EqualsAndHashCode(of = {"qualifiedName", "typeArgs"})
 @Builder(toBuilder = true)
@@ -29,19 +34,12 @@ public final class ConcreteTypeInfo implements TypeInfo {
     @Builder.Default
     private final List<TypeInfo> typeArgs = Collections.emptyList();
 
-    /** If this type is an Enum */
-    @Getter
-    private final boolean enumType;
-
-    /** If this type is map-like. */
-    @Getter
-    private final boolean mapType;
-
-    /** If this type is array-like. */
     @Getter
-    private final boolean arrayType;
+    private final Kind kind;
 
-    /** If this type is defined in global config as base Map type */
+    /**
+     * If this type is defined in global config as base Map type
+     */
     @Getter
     private final boolean baseMapType;
 
@@ -55,6 +53,7 @@ public final class ConcreteTypeInfo implements TypeInfo {
 
     /**
      * The counter-parting type definition.
+     *
      * @see #typeDef()
      */
     @Nullable
@@ -117,8 +116,17 @@ public List<TypeInfo> typeArgs() {
     public String toString() {
         return String.format("%s%s%s",
             qualifiedName,
-                typeArgs.isEmpty() ? "" : "<" + typeArgs.stream().map(TypeInfo::toString).collect(Collectors.joining(",")) + ">",
-                resolved ? "" : "?"
+            typeArgs.isEmpty() ? "" : "<" + typeArgs.stream().map(TypeInfo::toString).collect(Collectors.joining(",")) + ">",
+            resolved ? "" : "?"
         );
     }
+
+    /**
+     * Kind of types ConcreteTypeInfo can represent.
+     * Array is represented by ArrayTypeInfo.
+     * Date/Time is represented by DateTimeTypeInfo.
+     */
+    public enum Kind {
+        ENUM, MAP, OTHER
+    }
 }

internal/src/main/java/online/sharedtype/processor/domain/DateTimeInfo.java

@@ -0,0 +1,25 @@
+package online.sharedtype.processor.domain;
+
+import lombok.RequiredArgsConstructor;
+
+/**
+ * Represents a date/time type, which is simply be emitted as a string or any custom type literal.
+ * It has no counterpart typeDef, explicitly annotating {@code @SharedType} on a date/time type is ignored with a warning.
+ *
+ * @author Cause Chung
+ */
+@RequiredArgsConstructor
+public final class DateTimeInfo implements TypeInfo {
+    private static final long serialVersionUID = 5428192893749821359L;
+
+    private final String qualifiedName;
+
+    public String qualifiedName() {
+        return qualifiedName;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("DateTime(%s)", qualifiedName);
+    }
+}

internal/src/main/java/online/sharedtype/processor/domain/TypeDef.java

@@ -32,7 +32,6 @@ default List<TypeInfo> directSupertypes() {
     void setCyclicReferenced(boolean cyclicReferenced);
 
     boolean isAnnotated();
-    void setAnnotated(boolean annotated);
 
     boolean isReferencedByAnnotated();
     void setReferencedByAnnotated(boolean referencedByAnnotated);

internal/src/main/java/online/sharedtype/processor/domain/TypeInfo.java

@@ -23,10 +23,8 @@ public interface TypeInfo extends Serializable {
      *
      * @return true is this type and its dependency types are resolved.
      */
-    boolean resolved();
-
-    default boolean isEnumType() {
-        return false;
+    default boolean resolved() {
+        return true;
     }
 
     /**
@@ -35,5 +33,7 @@ default boolean isEnumType() {
      *                 value is a type argument, a concrete type e.g. Integer, or a generic type with concrete type parameter, e.g. {@code Tuple<String, String>}
      * @return a newly created type info if updated.
      */
-    TypeInfo reify(Map<TypeVariableInfo, TypeInfo> mappings);
+    default TypeInfo reify(Map<TypeVariableInfo, TypeInfo> mappings) {
+        return this;
+    }
 }

internal/src/main/java/online/sharedtype/processor/domain/TypeVariableInfo.java

@@ -43,11 +43,6 @@ public String qualifiedName() {
         return qualifiedName;
     }
 
-    @Override
-    public boolean resolved() {
-        return true;
-    }
-
     @Override
     public TypeInfo reify(Map<TypeVariableInfo, TypeInfo> mappings) {
         TypeInfo reifiedType = mappings.get(this);