Improve date parsing

encoredev · Oct 24, 2024 · 531b8a2 · 531b8a2
1 parent 35cc61b
commit 531b8a2
Show file tree

Hide file tree

Showing 5 changed files with 39 additions and 20 deletions.
diff --git a/runtimes/core/src/api/error.rs b/runtimes/core/src/api/error.rs
@@ -40,7 +40,7 @@ impl Error {
         Self {
             code: ErrCode::InvalidArgument,
             message: public_msg.into(),
-            internal_message: Some(format!("{:#?}", cause.into())),
+            internal_message: Some(format!("{:?}", cause.into())),
             stack: None,
             details: None,
         }

diff --git a/runtimes/core/src/api/jsonschema/parse.rs b/runtimes/core/src/api/jsonschema/parse.rs
@@ -444,6 +444,16 @@ fn parse_basic_str(basic: &Basic, str: &str) -> APIResult<PValue> {
                 details: None,
             }),
 
+        Basic::DateTime => api::DateTime::parse_from_rfc3339(str)
+            .map(PValue::DateTime)
+            .map_err(|_err| api::Error {
+                code: api::ErrCode::InvalidArgument,
+                message: "invalid datetime".to_string(),
+                internal_message: Some(format!("invalid datetime string {:?}", str)),
+                stack: None,
+                details: None,
+            }),
+
         _ => Err(api::Error {
             code: api::ErrCode::InvalidArgument,
             message: "invalid value".to_string(),

diff --git a/runtimes/js/encore.dev/api/mod.ts b/runtimes/js/encore.dev/api/mod.ts
@@ -15,12 +15,12 @@ export type Method =
   | "CONNECT";
 
 export type Header<
-  TypeOrName extends string | number | boolean = string,
+  TypeOrName extends string | number | boolean | Date = string,
   Name extends string = ""
 > = TypeOrName extends string ? string : TypeOrName;
 
 export type Query<
-  TypeOrName extends string | number | boolean = string,
+  TypeOrName extends string | number | boolean | Date = string,
   Name extends string = ""
 > = TypeOrName extends string ? string : TypeOrName;
 
@@ -141,21 +141,21 @@ export interface StreamOut<Response> {
 
 export type StreamInOutHandlerFn<HandshakeData, Request, Response> =
   HandshakeData extends void
-    ? (stream: StreamInOut<Request, Response>) => Promise<void>
-    : (
-        data: HandshakeData,
-        stream: StreamInOut<Request, Response>
-      ) => Promise<void>;
+  ? (stream: StreamInOut<Request, Response>) => Promise<void>
+  : (
+    data: HandshakeData,
+    stream: StreamInOut<Request, Response>
+  ) => Promise<void>;
 
 export type StreamOutHandlerFn<HandshakeData, Response> =
   HandshakeData extends void
-    ? (stream: StreamOut<Response>) => Promise<void>
-    : (data: HandshakeData, stream: StreamOut<Response>) => Promise<void>;
+  ? (stream: StreamOut<Response>) => Promise<void>
+  : (data: HandshakeData, stream: StreamOut<Response>) => Promise<void>;
 
 export type StreamInHandlerFn<HandshakeData, Request, Response> =
   HandshakeData extends void
-    ? (stream: StreamIn<Request>) => Promise<Response>
-    : (data: HandshakeData, stream: StreamIn<Request>) => Promise<Response>;
+  ? (stream: StreamIn<Request>) => Promise<Response>
+  : (data: HandshakeData, stream: StreamIn<Request>) => Promise<Response>;
 
 export type StreamInOut<Request, Response> = StreamIn<Request> &
   StreamOut<Response>;

diff --git a/runtimes/js/src/pvalue.rs b/runtimes/js/src/pvalue.rs
@@ -207,6 +207,7 @@ impl ToNapiValue for &PVals {
 
 impl FromNapiValue for PVals {
     unsafe fn from_napi_value(env: sys::napi_env, napi_val: sys::napi_value) -> Result<Self> {
+        assert_type_of!(env, napi_val, ValueType::Object)?;
         let obj = JsObject::from_napi_value(env, napi_val)?;
 
         let mut map = PVals(PValues::new());

diff --git a/tsparser/src/parser/resources/apis/encoding.rs b/tsparser/src/parser/resources/apis/encoding.rs
@@ -10,6 +10,7 @@ use crate::parser::types::{
     Type, TypeChecker,
 };
 use crate::parser::Range;
+use crate::span_err::ErrReporter;
 
 /// Describes how an API endpoint can be encoded on the wire.
 #[derive(Debug, Clone)]
@@ -65,6 +66,7 @@ pub struct Param {
     pub loc: ParamData,
     pub typ: Type,
     pub optional: bool,
+    pub range: Range,
 }
 
 #[derive(Debug, Clone)]
@@ -450,6 +452,7 @@ fn extract_path_params(path: &Path, fields: &mut FieldMap) -> Result<Vec<Param>>
             loc: ParamData::Path { index },
             typ: f.typ.clone(),
             optional: f.optional,
+            range: f.range,
         });
     }
 
@@ -486,6 +489,7 @@ fn extract_loc_params(fields: &FieldMap, default_loc: ParamLocation) -> Vec<Para
             loc: param_data,
             typ: f.typ.clone(),
             optional: f.optional,
+            range: f.range,
         });
     }
     params
@@ -499,13 +503,17 @@ fn rewrite_path_types(req: &RequestEncoding, path: Path, raw: bool) -> Result<Pa
         .map(|param| (&param.name, param))
         .collect::<HashMap<_, _>>();
 
-    let typ_to_value_type = |typ: &Type| {
-        Ok(match typ {
-            Type::Basic(Basic::String) => ValueType::String,
-            Type::Basic(Basic::Boolean) => ValueType::Bool,
-            Type::Basic(Basic::Number | Basic::BigInt) => ValueType::Int,
-            typ => anyhow::bail!("unsupported path param type: {:?}", typ),
-        })
+    let typ_to_value_type = |param: &Param| match &param.typ {
+        Type::Basic(Basic::String) => ValueType::String,
+        Type::Basic(Basic::Boolean) => ValueType::Bool,
+        Type::Basic(Basic::Number | Basic::BigInt) => ValueType::Int,
+        typ => {
+            param
+                .range
+                .to_span()
+                .err(&format!("unsupported path parameter type: {:?}", typ));
+            ValueType::String
+        }
     };
 
     let mut segments = Vec::with_capacity(path.segments.len());
@@ -514,7 +522,7 @@ fn rewrite_path_types(req: &RequestEncoding, path: Path, raw: bool) -> Result<Pa
             Segment::Param { name, .. } => {
                 // Get the value type of the path parameter.
                 let value_type = match path_params.get(&name) {
-                    Some(param) => typ_to_value_type(&param.typ)?,
+                    Some(param) => typ_to_value_type(param),
                     None => {
                         // Raw endpoints assume path params are strings.
                         if raw {