graphql-scalars | custom GraphQL scalar types for creating precise type | GraphQL library

Custom type/scalar ... it should be obvious that you need custom validation.

Both parseValue and parseLiteral are quarded by MyScalar.from.

Already "accepted" (validated 'on input') value usually doesn't need additional validation 'on output' (serialize). It seams that you sometimes could use it to "correct" data/format/value but probably you would do it on resolver level (read DB - before returning data that should match type[-s]).

AFAIK There is no way to inform system how to validate your custom types/scalars - simply can't be supported.

You have (should) to implement the same validation (equal to used on API/backend) rules before sending custom data (variables).

This is intended behavior. The BigInt scalar can represent integers that are larger than what JavaScript supports (9007199254740991), so the value is always serialized as a string in the response.

"Date" and "DateTime" can be tricky. For example, is "15:00" 3:00pm Pacific Time?

Many (most) implementations resolve the problem by storing "datetime" as a large integer with respect to some "epoch". For example, "0" might represent "number of seconds since Jan 1, 1970".

Perhaps you might consider storing your GraphQL "DateTime" as an ISO 8601 string, or using this module: https://www.npmjs.com/package/graphql-iso-date

At the "schema" level (vs. JS code, as I suggested above), you might consider this:

GraphQL Spec

3.5 Scalars:

Scalars ScalarTypeDefinition DescriptionoptscalarNameDirectivesConstopt Scalar types represent primitive leaf values in a GraphQL type system. GraphQL responses take the form of a hierarchical tree; the leaves on these trees are GraphQL scalars.

All GraphQL scalars are representable as strings, though depending on the response format being used, there may be a more appropriate primitive for the given scalar type, and server should use those types when appropriate.

GraphQL provides a number of built‐in scalars, but type systems can add additional scalars with semantic meaning. For example, a GraphQL system could define a scalar called Time which, while serialized as a string, promises to conform to ISO‐8601. When querying a field of type Time, you can then rely on the ability to parse the result with an ISO‐8601 parser and use a client‐specific primitive for time.

I used to get this error due to low or intermittent internet bandwidth.

From the docs:

[The @client directive] tells Apollo Client to fetch the field data locally (either from the cache or using a local resolver), instead of sending it to our GraphQL server.

If the directive is present on a field, Apollo will attempt to resolve the field using the provided resolver, or fall back to fetching directly from the cache if one doesn't exist. You can initialize your cache with pretty much any sort of data at the root level (taking care to include __typename fields for objects) and you should be able to fetch it without having to also provide a resolver for it. On the other hand, providing a resolver can provide you with more granular control over what's actually fetched from the cache -- i.e. you could initialize the cache with an array of items, but use a resolver to provide a way to filter or sort them.

There's an import nuance here: Fetching without a resolver only works when there's data in the cache to fetch. That's why it's important to provide initial state for these fields when building your client. If you have a more deeply nested @client field (for example, maybe you're including additional information alongside data fetched from the server), you also technically don't have to write a resolver. But we typically do write them because there is no existing data in the cache for those nested fields.