Add Timestamp scalar (SecondsSinceEpochScalar)

[clutcher]

Can we extend scalars with additional timestamp scalar?

Something like this:

import graphql.GraphQLContext;
import graphql.execution.CoercedVariables;
import graphql.language.IntValue;
import graphql.language.StringValue;
import graphql.language.Value;
import graphql.schema.Coercing;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.Locale;

public class TimestampScalar implements Coercing<TemporalAccessor, String> {

    @Override
    public String serialize(Object dataFetcherResult, GraphQLContext graphQLContext, Locale locale) {
        if (!(dataFetcherResult instanceof TemporalAccessor temporalAccessor)) {
            return null;
        }

        switch (temporalAccessor) {
            case Instant instant -> {
                return Long.toString(instant.getEpochSecond());
            }
            case LocalDateTime localDateTime -> {
                return Long.toString(localDateTime.toEpochSecond(ZoneOffset.UTC));
            }
            case ZonedDateTime zonedDateTime -> {
                return Long.toString(zonedDateTime.toEpochSecond());
            }
            case OffsetDateTime offsetDateTime -> {
                return Long.toString(offsetDateTime.toEpochSecond());
            }
            default -> {
                try {
                    Instant instant = Instant.from(temporalAccessor);
                    return Long.toString(instant.getEpochSecond());
                } catch (Exception e) {
                    return null;
                }
            }
        }
    }


    @Override
    public TemporalAccessor parseValue(Object input, GraphQLContext graphQLContext, Locale locale) {
        if (input instanceof Number number) {
            return convertEpochSecondsToTemporal(number.longValue());
        }
        if (input instanceof String string) {
            return convertToTemporal(string);
        }
        return null;
    }

    @Override
    public TemporalAccessor parseLiteral(Value<?> input, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
        if (input instanceof StringValue stringValue) {
            return convertToTemporal(stringValue.getValue());
        }
        if (input instanceof IntValue intValue) {
            try {
                long epochSeconds = intValue.getValue().longValue();
                return Instant.ofEpochSecond(epochSeconds).atZone(ZoneOffset.UTC);
            } catch (Exception _) {
            }
        }
        return null;
    }

    @NotNull
    private static Temporal convertToTemporal(String value) {
        if (StringUtils.isNumeric(value)) {
            long epochSeconds = Long.parseLong(value);
            return Instant.ofEpochSecond(epochSeconds).atZone(ZoneOffset.UTC);
        }

        return Instant.parse(value);
    }

    @NotNull
    private static TemporalAccessor convertEpochSecondsToTemporal(long epochSeconds) {
        return Instant.ofEpochSecond(epochSeconds).atZone(ZoneOffset.UTC);
    }
}

[bbakerman]

Naming is hard but really your implementation is a TemporalAccessorScalar or perhaps SecondsSinceEpochScalar since its inputs / outputs are always numbers as seconds from epoch

Timestamp is such a loaded word and I would not call it that. We currently have a few time related scalars

AccurateDurationScalar.java
DateScalar.java
DateTimeScalar.java
LocalTimeCoercing.java
NominalDurationScalar.java
TimeScalar.java
YearMonthScalar.java
YearScalar.java

Whats in this scalar thats not covered by them in your view?? Is it that its a a scalar that is less precise - it will accept a broad ranged of time related values ??

[clutcher]

@bbakerman For me timestamp always refers to unix time/timestamp term. Suppose for purpose of library SecondsSinceEpochScalar would be a better naming.

As you already noticed at the end I want to receive from frontend 1750059268 and convert it in java to LocalDateTime/ZonedDateTime/Instant (or any other compatible TemporalAccessor). Similarly I want to send to frontend any time object as seconds since epoch 1750059268. Some of frontend graphql clients converts time in Number and some into String, so scalar should support both for input.

In codebase I see only DateTimeScalar, DateScalar, TimeScalar, LocalTime with LocalTimeCoercing. All of them works with date time formats like "2025-06-16T07:34:24+00:00" and I don't see any way to use/reuse them to work with seconds since epoch.

[bbakerman]

Yup makes sense - We would accept a PR - we are looking to do a new release of the project soon

I would base you new Scalar on code in #159 as the target

We are updating the Scalars to remove the deprecated method usages and updated the base tests as well so it would be a pain to have a new scalar that also needed to be migrated

[clutcher]

@bbakerman Ok. I'll prepare PR in that branch today-tomorrow.

[clutcher]

@bbakerman I created PR #163 to valueToLiteral_support branch.

[clutcher]

@bbakerman I have a side question. Do you want to add Email scalar to library? Compared to Timestamp we use it in single microservice, so it doesn't bother us, but could be benefitial for someone else.