feat: Added support for time formatted strings

The `time` format is used to specify that a JSON string should conform
to the ISO-8601 standard for defining a time _without_ a date as a
string. In this implementation a `time.Time` value is generated given
this type of formatted string.

https://json-schema.org/draft/2020-12/json-schema-validation.html#name-dates-times-and-duration

Some extra work was required here to make this work since the
`time.Time.UnmarshalJSON` implementation expects to only be given a full
timestamps with both a date AND a time. If you gave it just "2023-01-02"
you would get an error. To get around this a new `SerializableTime` type
was added which knows to to properly marshal/unmarshal as a pure time.
This breaks a bit from how the tool has worked before because this would
now make it expected as an import in client code.

The `SerializableTime` type transparently extends the `time.Time` type
and just changes the JSON related methods.

Author: durandj

README.md

@@ -64,6 +64,18 @@ This will create `schema1.go` (declared as `package myproject`) and `stuff/schem
                  schema $id                  full import URL
 ```
 
+### Special types
+
+In a few cases, special types are used to help with serializing/deserializing
+data frrom JSON. Namely a custom types is provided for the following semantic
+types:
+
+* `SerializableDate`
+* `SerializableTime`
+
+These types are needed because there is no native type provided by Go which
+properly handles them.
+
 ## Status
 
 While not finished, go-jsonschema can be used today. Aside from some minor features, only specific validations remain to be fully implemented.
@@ -133,7 +145,7 @@ While not finished, go-jsonschema can be used today. Aside from some minor featu
     - [ ] `oneOf`
     - [ ] `not`
   - [ ] Semantic formats (§7.3)
-    - [ ] Dates and times
+    - [x] Dates and times
     - [ ] Email addresses
     - [ ] Hostnames
     - [ ] IP addresses

pkg/codegen/utils.go

@@ -83,6 +83,21 @@ func PrimitiveTypeFromJSONSchemaType(jsType, format string, pointer bool) (Type,
 				},
 			}
 
+		case "time":
+			t = NamedType{
+				Package: &Package{
+					QualifiedName: "types",
+					Imports: []Import{
+						{
+							QualifiedName: "github.com/atombender/go-jsonschema/types",
+						},
+					},
+				},
+				Decl: &TypeDecl{
+					Name: "SerializableTime",
+				},
+			}
+
 		default:
 			t = PrimitiveType{"string"}
 		}

tests/data/core/time.go.output

@@ -0,0 +1,35 @@
+// Code generated by github.com/atombender/go-jsonschema, DO NOT EDIT.
+
+package test
+
+import "encoding/json"
+import "fmt"
+import "github.com/atombender/go-jsonschema/types"
+
+type TimeMyObject struct {
+	// MyTime corresponds to the JSON schema field "myTime".
+	MyTime types.SerializableTime `json:"myTime" yaml:"myTime" mapstructure:"myTime"`
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (j *TimeMyObject) UnmarshalJSON(b []byte) error {
+	var raw map[string]interface{}
+	if err := json.Unmarshal(b, &raw); err != nil {
+		return err
+	}
+	if v, ok := raw["myTime"]; !ok || v == nil {
+		return fmt.Errorf("field myTime in TimeMyObject: required")
+	}
+	type Plain TimeMyObject
+	var plain Plain
+	if err := json.Unmarshal(b, &plain); err != nil {
+		return err
+	}
+	*j = TimeMyObject(plain)
+	return nil
+}
+
+type Time struct {
+	// MyObject corresponds to the JSON schema field "myObject".
+	MyObject *TimeMyObject `json:"myObject,omitempty" yaml:"myObject,omitempty" mapstructure:"myObject,omitempty"`
+}

tests/data/core/time.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "id": "http://example.com/object",
+  "type": "object",
+  "title": "object",
+  "properties": {
+    "myObject": {
+      "type": "object",
+      "required": [
+        "myTime"
+      ],
+      "properties": {
+        "myTime": {
+          "type": "string",
+          "format": "time"
+        }
+      }
+    }
+  }
+}

tests/serialiable_date_test.go renamed to tests/serializable_date_test.go

@@ -0,0 +1,91 @@
+package tests_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/atombender/go-jsonschema/types"
+)
+
+func TestSerializableTimeMarshalsToJSON(t *testing.T) {
+	t.Parallel()
+
+	now := time.Now()
+	timeValue := types.SerializableTime{
+		Time: now,
+	}
+
+	output, err := json.Marshal(timeValue)
+	if err != nil {
+		t.Fatalf("Unable to marshal SerializableTime as JSON: %v", err)
+	}
+
+	stringifiedOutput := string(output)
+
+	expected := "\"" + now.Format("15:04:05") + "\""
+	if stringifiedOutput != expected {
+		t.Fatalf("Expected SerializableTime to marshal to %s but got %s", expected, stringifiedOutput)
+	}
+}
+
+func TestSerializableTimeUnmarshalsFromJSON(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(0, 1, 1, 15, 0o4, 0o5, 0, time.UTC)
+
+	input := "\"" + now.Format("15:04:05") + "\""
+
+	var timeValue types.SerializableTime
+	if err := json.Unmarshal([]byte(input), &timeValue); err != nil {
+		t.Fatalf("Unable to unmarshal %s to a SerializableTime: %s", input, err)
+	}
+
+	expected := types.SerializableTime{
+		Time: now,
+	}
+
+	if timeValue != expected {
+		t.Fatalf("Expected SerializableTime to unmarshal to %s but got %s", expected, timeValue)
+	}
+}
+
+func TestSerializableTimeUnmarshalJSONReturnsErrorForInvalidString(t *testing.T) {
+	t.Parallel()
+
+	testCases := []string{
+		"",
+		"15:04:05",
+		"\"15\"",
+		"\"15:04\"",
+		"\"2023-01-02T03:04:05Z\"",
+	}
+
+	for _, testCase := range testCases {
+		testCase := testCase
+
+		t.Run(fmt.Sprintf("Given '%s' expected UnmarshalJSON to return an error", testCase), func(t *testing.T) {
+			t.Parallel()
+
+			var timeValue types.SerializableTime
+			if err := timeValue.UnmarshalJSON([]byte(testCase)); err == nil {
+				t.Fatalf("Expected an error but got '%s'", timeValue)
+			}
+		})
+	}
+}
+
+func TestSerializableTimeUnmarshalJSONDoesNothingWhenGivenNull(t *testing.T) {
+	t.Parallel()
+
+	var timeValue types.SerializableTime
+	if err := timeValue.UnmarshalJSON([]byte("null")); err != nil {
+		t.Fatalf("Given 'null' expected UnmarshalJSON to be no-op but got an error: %v", err)
+	}
+
+	var zeroValue types.SerializableTime
+	if timeValue != zeroValue {
+		t.Fatalf("Given 'null' expected to stay at zero value but got %s", timeValue)
+	}
+}

tests/serializable_time_test.go

@@ -0,0 +1,40 @@
+package types
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+)
+
+var ErrTimeNotJSONString = errors.New("cannot parse non-string value as a time")
+
+type SerializableTime struct {
+	time.Time
+}
+
+func (t SerializableTime) MarshalJSON() ([]byte, error) {
+	return []byte("\"" + t.Format(time.TimeOnly) + "\""), nil
+}
+
+func (t *SerializableTime) UnmarshalJSON(data []byte) error {
+	stringifiedData := string(data)
+	if stringifiedData == "null" {
+		return nil
+	}
+
+	if !strings.HasPrefix(stringifiedData, "\"") || !strings.HasSuffix(stringifiedData, "\"") {
+		return ErrTimeNotJSONString
+	}
+
+	timeWithoutQuotes := stringifiedData[1 : len(stringifiedData)-1]
+
+	parsedTime, err := time.Parse(time.TimeOnly, timeWithoutQuotes)
+	if err != nil {
+		return fmt.Errorf("unable to parse time from JSON: %w", err)
+	}
+
+	t.Time = parsedTime
+
+	return nil
+}