refactor: migrate Coercing in SecondsSinceEpochScalar to Long

Refs: #157

Author: clutcher

src/main/java/graphql/scalars/datetime/SecondsSinceEpochScalar.java

@@ -55,18 +55,18 @@ private static Temporal convertEpochSecondsToTemporal(long epochSeconds) {
     }
 
     static {
-        Coercing<TemporalAccessor, String> coercing = new Coercing<>() {
+        Coercing<TemporalAccessor, Long> coercing = new Coercing<>() {
             @Override
-            public String serialize(Object input, GraphQLContext graphQLContext, Locale locale) throws CoercingSerializeException {
+            public Long serialize(Object input, GraphQLContext graphQLContext, Locale locale) throws CoercingSerializeException {
                 try {
                     if (input instanceof Number) {
                         Number number = (Number) input;
-                        return Long.toString(number.longValue());
+                        return number.longValue();
                     }
                     if (input instanceof String) {
                         String string = (String) input;
                         if (string.matches("\\d+")) {
-                            return string;
+                            return Long.parseLong(string);
                         }
                         throw new CoercingSerializeException(
                                 "Invalid seconds since epoch value : '" + string + "'. Expected a string containing only digits."
@@ -76,20 +76,20 @@ public String serialize(Object input, GraphQLContext graphQLContext, Locale loca
                         TemporalAccessor temporalAccessor = (TemporalAccessor) input;
                         if (temporalAccessor instanceof Instant) {
                             Instant instant = (Instant) temporalAccessor;
-                            return Long.toString(instant.getEpochSecond());
+                            return instant.getEpochSecond();
                         } else if (temporalAccessor instanceof LocalDateTime) {
                             LocalDateTime localDateTime = (LocalDateTime) temporalAccessor;
-                            return Long.toString(localDateTime.toEpochSecond(ZoneOffset.UTC));
+                            return localDateTime.toEpochSecond(ZoneOffset.UTC);
                         } else if (temporalAccessor instanceof ZonedDateTime) {
                             ZonedDateTime zonedDateTime = (ZonedDateTime) temporalAccessor;
-                            return Long.toString(zonedDateTime.toEpochSecond());
+                            return zonedDateTime.toEpochSecond();
                         } else if (temporalAccessor instanceof OffsetDateTime) {
                             OffsetDateTime offsetDateTime = (OffsetDateTime) temporalAccessor;
-                            return Long.toString(offsetDateTime.toEpochSecond());
+                            return offsetDateTime.toEpochSecond();
                         } else {
                             try {
                                 Instant instant = Instant.from(temporalAccessor);
-                                return Long.toString(instant.getEpochSecond());
+                                return instant.getEpochSecond();
                             } catch (Exception e) {
                                 throw new CoercingSerializeException(
                                         "Unable to convert TemporalAccessor to seconds since epoch because of : '" + e.getMessage() + "'."
@@ -158,8 +158,8 @@ public TemporalAccessor parseLiteral(Value<?> input, CoercedVariables variables,
 
             @Override
             public Value<?> valueToLiteral(Object input, GraphQLContext graphQLContext, Locale locale) {
-                String s = serialize(input, graphQLContext, locale);
-                return StringValue.newStringValue(s).build();
+                Long value = serialize(input, graphQLContext, locale);
+                return IntValue.newIntValue(java.math.BigInteger.valueOf(value)).build();
             }
 
         };
@@ -168,7 +168,7 @@ public Value<?> valueToLiteral(Object input, GraphQLContext graphQLContext, Loca
                                     .name("SecondsSinceEpoch")
                                     .description("Scalar that represents a point in time as seconds since the Unix epoch (Unix timestamp). " +
                                             "Accepts integers or strings containing integers as input values. " +
-                                            "Returns a string containing the number of seconds since epoch (January 1, 1970, 00:00:00 UTC).")
+                                            "Returns a Long representing the number of seconds since epoch (January 1, 1970, 00:00:00 UTC).")
                                     .coercing(coercing)
                                     .build();
     }

src/test/groovy/graphql/scalars/datetime/SecondsSinceEpochScalarTest.groovy

@@ -51,16 +51,16 @@ class SecondsSinceEpochScalarTest extends AbstractScalarTest {
         result.isEqualTo(expectedValue)
         where:
         input        | expectedValue
-        "0"          | mkStringValue("0")
-        "1"          | mkStringValue("1")
-        "1609459200" | mkStringValue("1609459200")
-        "1640995200" | mkStringValue("1640995200")
-        0            | mkStringValue("0")
-        1            | mkStringValue("1")
-        1609459200   | mkStringValue("1609459200")
-        1640995200   | mkStringValue("1640995200")
-        Instant.ofEpochSecond(1609459200) | mkStringValue("1609459200")
-        ZonedDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | mkStringValue("1609459200")
+        "0"          | mkIntValue(0)
+        "1"          | mkIntValue(1)
+        "1609459200" | mkIntValue(1609459200)
+        "1640995200" | mkIntValue(1640995200)
+        0            | mkIntValue(0)
+        1            | mkIntValue(1)
+        1609459200   | mkIntValue(1609459200)
+        1640995200   | mkIntValue(1640995200)
+        Instant.ofEpochSecond(1609459200) | mkIntValue(1609459200)
+        ZonedDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | mkIntValue(1609459200)
     }
 
     @Unroll
@@ -100,12 +100,12 @@ class SecondsSinceEpochScalarTest extends AbstractScalarTest {
         result == expectedValue
         where:
         input                                                                  | expectedValue
-        Instant.ofEpochSecond(0)                                               | "0"
-        Instant.ofEpochSecond(1)                                               | "1"
-        Instant.ofEpochSecond(1609459200)                                      | "1609459200"
-        LocalDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | "1609459200"
-        ZonedDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | "1609459200"
-        OffsetDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | "1609459200"
+        Instant.ofEpochSecond(0)                                               | 0L
+        Instant.ofEpochSecond(1)                                               | 1L
+        Instant.ofEpochSecond(1609459200)                                      | 1609459200L
+        LocalDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | 1609459200L
+        ZonedDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | 1609459200L
+        OffsetDateTime.ofInstant(Instant.ofEpochSecond(1609459200), ZoneOffset.UTC) | 1609459200L
     }
 
     def "secondsSinceEpoch serialisation bad inputs"() {
@@ -132,4 +132,4 @@ class SecondsSinceEpochScalarTest extends AbstractScalarTest {
         mkStringValue("2022-01-01")          | CoercingParseLiteralException
         mkStringValue("2022-01-01T00:00:00Z")| CoercingParseLiteralException
     }
-}
+}