Add support for DateTime field for Go, JS, Python

core/data/tests/test_custom_serialize_deserialize_functions/input.rs

@@ -0,0 +1,16 @@
+#[typeshare]
+#[serde(rename_all = "camelCase")]
+pub struct Foo {
+    pub time: time::OffsetDateTime,
+    pub time2: time::OffsetDateTime,
+    pub time3: time::OffsetDateTime,
+    pub bytes: Vec<u8>,
+    pub bytes2: Vec<u8>
+}
+
+#[typeshare]
+#[serde(rename_all = "camelCase")]
+pub struct TwoFoo {
+    pub time: time::OffsetDateTime,
+    pub bytes: Vec<u8>,
+}

core/data/tests/test_custom_serialize_deserialize_functions/output.go

@@ -0,0 +1,18 @@
+package proto
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type Foo struct {
+	Time time.Time `json:"time"`
+	Time2 time.Time `json:"time2"`
+	Time3 time.Time `json:"time3"`
+	Bytes []byte `json:"bytes"`
+	Bytes2 []byte `json:"bytes2"`
+}
+type TwoFoo struct {
+	Time time.Time `json:"time"`
+	Bytes []byte `json:"bytes"`
+}

core/data/tests/test_custom_serialize_deserialize_functions/output.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, PlainSerializer
+from typing import Annotated
+
+
+def serialize_binary_data(value: bytes) -> list[int]:
+        return list(value)
+
+def deserialize_binary_data(value):
+     if isinstance(value, list):
+         if all(isinstance(x, int) and 0 <= x <= 255 for x in value):
+            return bytes(value)
+         raise ValueError("All elements must be integers in the range 0-255 (u8).")
+     elif isinstance(value, bytes):
+            return value
+     raise TypeError("Content must be a list of integers (0-255) or bytes.")
+
+def serialize_datetime_data(utc_time: datetime) -> str:
+        return utc_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+def parse_rfc3339(date_str: str) -> datetime:
+    date_formats = [
+        "%Y-%m-%dT%H:%M:%SZ",   
+        "%Y-%m-%dT%H:%M:%S.%fZ"
+    ]
+
+    for fmt in date_formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            continue
+
+    raise ValueError(f"Invalid RFC 3339 date format: {date_str}")
+
+class Foo(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    time: Annotated[datetime, BeforeValidator(parse_rfc3339), PlainSerializer(serialize_datetime_data)]
+    time_2: Annotated[datetime, BeforeValidator(parse_rfc3339), PlainSerializer(serialize_datetime_data)] = Field(alias="time2")
+    time_3: Annotated[datetime, BeforeValidator(parse_rfc3339), PlainSerializer(serialize_datetime_data)] = Field(alias="time3")
+    bytes: Annotated[bytes, BeforeValidator(deserialize_binary_data), PlainSerializer(serialize_binary_data)]
+    bytes_2: Annotated[bytes, BeforeValidator(deserialize_binary_data), PlainSerializer(serialize_binary_data)] = Field(alias="bytes2")
+
+class TwoFoo(BaseModel):
+    time: Annotated[datetime, BeforeValidator(parse_rfc3339), PlainSerializer(serialize_datetime_data)]
+    bytes: Annotated[bytes, BeforeValidator(deserialize_binary_data), PlainSerializer(serialize_binary_data)]
+

core/data/tests/test_byte_translation/output.ts → core/data/tests/test_custom_serialize_deserialize_functions/output.ts

@@ -1,6 +1,14 @@
 export interface Foo {
-	thisIsBits: Uint8Array;
-	thisIsRedundant: Uint8Array;
+	time: Date;
+	time2: Date;
+	time3: Date;
+	bytes: Uint8Array;
+	bytes2: Uint8Array;
+}
+
+export interface TwoFoo {
+	time: Date;
+	bytes: Uint8Array;
 }
 
 /**
@@ -10,13 +18,19 @@ export interface Foo {
  * These functions allow for flexible encoding and decoding of data, ensuring that complex types are properly handled when converting between TS objects and JSON
  */
 export const ReviverFunc = (key: string, value: unknown): unknown => {
+    if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(value) && (key == "time" || key == "time2" || key == "time3")) {
+        return new Date(value);
+    }
     if (Array.isArray(value) && value.every(v => Number.isInteger(v) && v >= 0 && v <= 255) && value.length > 0)  {
         return new Uint8Array(value);
     }
     return value;
 };
 
 export const ReplacerFunc = (key: string, value: unknown): unknown => {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
     if (value instanceof Uint8Array) {
         return Array.from(value);
     }

core/data/tests/test_serde_iso8601/output.py

@@ -1,9 +1,27 @@
 from __future__ import annotations
 
 from datetime import datetime
-from pydantic import BaseModel
+from pydantic import BaseModel, BeforeValidator, PlainSerializer
+from typing import Annotated
 
 
+def serialize_datetime_data(utc_time: datetime) -> str:
+        return utc_time.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+def parse_rfc3339(date_str: str) -> datetime:
+    date_formats = [
+        "%Y-%m-%dT%H:%M:%SZ",   
+        "%Y-%m-%dT%H:%M:%S.%fZ"
+    ]
+
+    for fmt in date_formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            continue
+
+    raise ValueError(f"Invalid RFC 3339 date format: {date_str}")
+
 class Foo(BaseModel):
-    time: datetime
+    time: Annotated[datetime, BeforeValidator(parse_rfc3339), PlainSerializer(serialize_datetime_data)]
 

core/src/language/go.rs

@@ -9,7 +9,7 @@ use crate::{
     rust_types::{RustEnum, RustEnumVariant, RustField, RustStruct, RustTypeAlias},
     topsort::topsort,
 };
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap, HashSet};
 
 use super::CrateTypes;
 
@@ -18,6 +18,8 @@ use super::CrateTypes;
 pub struct Go {
     /// Name of the Go package.
     pub package: String,
+    /// BTreeSet<PackageName>
+    pub imports: BTreeSet<String>,
     /// Conversions from Rust type names to Go type names.
     pub type_mappings: HashMap<String, String>,
     /// Abbreviations that should be fully uppercased to comply with Go's formatting rules.
@@ -93,16 +95,17 @@ impl Language for Go {
             }
         }
 
+        let mut body: Vec<u8> = Vec::new();
         for thing in &items {
             match thing {
-                RustItem::Enum(e) => self.write_enum(w, e, &types_mapping_to_struct)?,
-                RustItem::Struct(s) => self.write_struct(w, s)?,
-                RustItem::Alias(a) => self.write_type_alias(w, a)?,
-                RustItem::Const(c) => self.write_const(w, c)?,
+                RustItem::Enum(e) => self.write_enum(&mut body, e, &types_mapping_to_struct)?,
+                RustItem::Struct(s) => self.write_struct(&mut body, s)?,
+                RustItem::Alias(a) => self.write_type_alias(&mut body, a)?,
+                RustItem::Const(c) => self.write_const(&mut body, c)?,
             }
         }
-
-        self.end_file(w)
+        self.write_all_imports(w)?;
+        w.write_all(&body)
     }
 
     fn type_map(&mut self) -> &HashMap<String, String> {
@@ -162,6 +165,10 @@ impl Language for Go {
             SpecialRustType::Bool => "bool".into(),
             SpecialRustType::F32 => "float32".into(),
             SpecialRustType::F64 => "float64".into(),
+            SpecialRustType::DateTime => {
+                self.add_import("time");
+                "time.Time".into()
+            }
         })
     }
 
@@ -176,8 +183,7 @@ impl Language for Go {
             )?;
         }
         writeln!(w, "package {}", self.package)?;
-        writeln!(w)?;
-        writeln!(w, "import \"encoding/json\"")?;
+        self.add_import("encoding/json");
         writeln!(w)?;
         Ok(())
     }
@@ -536,6 +542,27 @@ func ({short_name} {full_name}) MarshalJSON() ([]byte, error) {{
         };
         self.acronyms_to_uppercase(&name)
     }
+
+    fn add_import(&mut self, name: &str) {
+        self.imports.insert(name.to_string());
+    }
+
+    fn write_all_imports(&self, w: &mut dyn Write) -> std::io::Result<()> {
+        let mut imports = self.imports.iter().cloned().collect::<Vec<String>>();
+        imports.sort();
+        match imports.as_slice() {
+            [] => return Ok(()),
+            [import] => writeln!(w, "import \"{import}\"")?,
+            _ => {
+                writeln!(w, "import (")?;
+                for import in imports {
+                    writeln!(w, "\t\"{import}\"")?;
+                }
+                writeln!(w, ")")?
+            }
+        }
+        writeln!(w)
+    }
 }
 
 fn write_comment(w: &mut dyn Write, indent: usize, comment: &str) -> std::io::Result<()> {

core/src/language/kotlin.rs

@@ -74,9 +74,8 @@ impl Language for Kotlin {
                 )
             }
             SpecialRustType::Unit => "Unit".into(),
-            SpecialRustType::String => "String".into(),
             // Char in Kotlin is 16 bits long, so we need to use String
-            SpecialRustType::Char => "String".into(),
+            SpecialRustType::String | SpecialRustType::Char => "String".into(),
             // https://kotlinlang.org/docs/basic-types.html#integer-types
             SpecialRustType::I8 => "Byte".into(),
             SpecialRustType::I16 => "Short".into(),
@@ -90,6 +89,12 @@ impl Language for Kotlin {
             SpecialRustType::Bool => "Boolean".into(),
             SpecialRustType::F32 => "Float".into(),
             SpecialRustType::F64 => "Double".into(),
+            // TODO: https://github.com/1Password/typeshare/issues/237
+            SpecialRustType::DateTime => {
+                return Err(RustTypeFormatError::UnsupportedSpecialType(
+                    special_ty.to_string(),
+                ))
+            }
         })
     }