How does one use this custom scalar if we're using buildSchema to build our schema, e.g.:

module.exports = buildSchema(`
  type User {
    id: ID!
    email: String!
    firstName: String!
    lastName: String!
    signupDate: DateTime!
  }

I just updated to Apollo Server 2.0 and I keep getting the following error whenever I run any query/mutation which uses the Date scalar type I've defined using graphql-iso-date:

Unknown type "DateTime". Did you mean "Date"?

resolvers.js

const { GraphQLDateTime } = require('graphql-iso-date')

const scalarResolvers = {
  Date: GraphQLDateTime
}

...

const resolvers = [scalarResolvers, exampleResolver1, exampleResolver2]

module.exports = mergeResolvers(resolvers)

types.js

const scalarTypes = gql`
	scalar Date
`

const typeDefs = [scalarTypes, exampleType1, exampleType2]

module.exports = mergeTypes(typeDefs)

Query type definition:

type Query {
	allUsers(
		limit: Int
		page: Int
		sort: String
		minDate: Date
		maxDate: Date
	): paginatedUsers
}

I get the error whenever I execute this:

query ($limit: Int!, $page: Int!, $sort: String!, $minDate: Date, $maxDate: Date) {
    allUsers(
      limit: $limit
      page: $page
      sort: $sort
      minDate: $minDate
      maxDate: $maxDate
    ) {
      docs {
        _id
		firstName
		lastName
		permanentAddress
		createdAt
      }
      total
      limit
      page
      pages
      prev
      next
    }
  }

Another weird thing is that on introspection, the schema in GraphQL Playground says minDate and maxDate are DateTime even though I've defined them as Date in my schema definition.

allUsers(
	limit: Int
	page: Int
	sort: String
	minDate: DateTime
	maxDate: DateTime
): paginatedUsers

Will you support graphql 16.3.0?

I think it would be very useful to allow posix timestamps (kind== int or string) to be parsed into DateTime format. Any reason you can think of not to include this?

I'm receiving dates in the ISO8601 compatible format 2018-06-13T18:24:53.000+0000 from a database.
GraphQLDateTime from graphql-iso-date won't parse these strings into dates because of the lack of a colon in the timezone offset part.

I'm automatically creating resolvers and objects from a database schema (salesforce describe), and it's a bit hacky to test if i'm receiving a date field from the database and then convert from the 8601 string to a Date object or a 3339 string.

Ideally graphql-iso-date should also support the limited ISO8601 grammar as described in Appendix A of the ISO3339 RFC. This would allow for parsing most dates, without having to handle the full mess that is the ISO8601 format.

I'll probably open a pull request in a few days once I get some free time and see how big an undertaking this will be

Use the Travis build stages to simplify the deployment process. This will remove the need for the travis-after-all script.

How to return null instead of throw Error for invalid DateTime?

In my resolvers, I use something like:

const resolvers = {
  AllowedColor: {
    RED: '#f00',
    GREEN: '#0f0',
    BLUE: '#00f',
  }
};

(example taken from the Apollo Docs)

Unfortunately, adding these internal values results in an error:

C:...\node_modules\graphql-tools\dist\transforms\visitSchema.js:1
Error: Can't find type DateTime.

Everything works fine when using "regular" enums without internal values. On the other hand, the code above works as intended when graphql-iso-date isn't used.

I made this codesandbox, just uncomment the section with the enum resolver to see the problem in action.

Any ideas how to fix this issue?

Update peerDependencies in package.json.

https://github.com/graphql/graphql-js/releases/tag/v14.0.0

Hi,

I have dates in the format of 2019-12-18T04:41:32.428+0000 and I get the error DateTime cannot represent an invalid date-time-string 2019-12-18T04:41:32.428+0000.. I think this is a valid date however. Any idea why it doesn't like this?

I have datetime strings that are not recognized as a valid value, it throws following error:

found "2021-10-31T05:55:00+0000"; DateTime cannot represent an invalid date-time-string 2021-10-31T05:55:00+0000

If I add a colon it works: "2021-10-31T05:55:00+00:00"; Is it possible to add support for the non-colon datetime string as it is also a valid iso string?

If Service A has a mutation accepting a GraphQLDate input and it needs to delegate or forward that to another Service B with the same signature, the GraphQLDate yyyy-mm-dd string will be converted to a full DateTime string yyyy-mm-ddT00:00:00Z before arriving at Service B which fails validation.

For example, if the same mutation exists both in Service A and Service B, with A delegating the mutation to Service B:

Mutation {
  updateUser(input: UserInput!): User!
}

type User {
  id: ID!
  dob: GraphQLDate!
}

input UserInput {
  id: ID!
  dob: GraphQLDate!
}

And a client mutates Service A with the following

mutation updateUser($input: UserInput) {
  updateUser(input: $input) {
    id
    dob
  }
}

{
  "input": {
    "id": "1234",
    "dob": "2000-01-01"
  }
}

When service B receives the mutation, it will see the following as the input because it is being parsed to a JS Date object in service A:

{
  "input": {
    "id": "1234",
    "dob": "2000-01-01T00:00:00Z"
  }
}

Which fails validation.

You are already stripping the time component when serializing the GraphQL date. Can we do the same when parsing so that values can be passed from service to service?

Export flow type definitions for the library so that people using flow will also be able to use in combination with this library.

Currently TypeErrors are thrown when parsing or serialization fails. I think these should be wrapped with locatedError.

This gives more insightful results:

{
  "errors": [{
    "message": "Variable \"$dateTime\" got invalid value {\"dateTime\":\"0\"}; Expected type DateTime at value.dateTime; DateTime cannot represent an invalid date-time-string 0.",
    "locations": [{
      "line": 2,
      "column": 11
    }]
  }]
}

Folks customizing formatError() will be able to identify the thrown exception as coming from the GraphQL layer, rather than being an exception thrown by resolver code. This is important to avoid leaking implementation errors, whilst still returning feedback to clients when they send incorrect values.

Would you take a PR that makes this change?

Version 2.30.1 of eslint-plugin-flowtype just got published.

This version is covered by your current version range and after updating it in your project the build failed.

As eslint-plugin-flowtype is “only” a devDependency of this project it might not break production or downstream projects, but “only” your build or test tools – preventing new deploys or publishes.

I recommend you give this issue a high priority. I’m sure you can resolve this 💪

Your Greenkeeper Bot 🌴

Where an RFC 3339 compliant date-time string has a time-zone other than UTC, it is shifted to UTC. For example, the date-time string "2016-01-01T14:10:20+01:00" is shifted to "2016-01-01T13:10:20Z".

Would there be consideration to add a type that allows offsets?

> new Date('10/30/1975').getDate()
30
> new Date('1975-10-30').getDate()
29

I'm on EDT (US eastern daylight time). My server is not, so it gets 30 for both.

Looks like the datetime regex rejects the following:

DateTime cannot represent an invalid date-time-string 2017-07-06T00:00:00.

...because there is no trailing "Z". Is that an accurate interpretation of the specification?

Here are some regexes in the wild that successfully match it:
http://jsfiddle.net/wq7tjec7/14/
https://www.myintervals.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/
https://www.regextester.com/94925

Thanks for the package!

Please add an example for using graphsql-iso-date with the 'makeExecutableSchema' function from 'graphql-tools'

Thanks !!

I'm using DateTime in my model, but when I use simple date formats like '1-1-2020' in my queries, they fail validation. Why is that? The back-end date may contain both a date and a time, but like any other query language I want to be able to query these fields with simple date formats or with more specific DateTime formats. Why can't I query a DateTime with a Date?

I'm trying to figure out the best way to accomplish the above and having some trouble with it. Any advice?

graphql-iso-date version 3.6.1
graphql version 14.3.0

I input a UTC time string in graphql as "14:30:00Z", and it is returned correctly as "14:30:00.000Z", but in the mysql database the time is stored a few hours off according to my system timezone (10:30:00). Mysql is set to use UTC, so I am not sure why this is happening.

I am using Typescript 2.3.4 and got this error:

TS7016: Could not find a declaration file for module 'graphql-iso-date'. '<project>/node_modules/graphql-iso-date/dist/index.js' implicitly has an 'any' type.

A declaration file could be added here or on https://github.com/DefinitelyTyped/DefinitelyTyped

Consider this example:

# Schema
type LogInput {
  message: String!
  createdAt: Date!
}

type Log {
  id: ID!
  message: String!
  createdAt: Date!
}

type Mutation {
  createLog(log: LogInput!): Log!
}

# query
mutation {
  createLog({
    message: "Hello, World!",
    createdAt: "2017-01-001" # invalid
  }) {
    message,
    createdAt
  }
}

In this example, parsing silently fails and sets the createdAt to null. I think it would be more useful to thrown an error in this case.

Hi,
I think it would be helpful to add an example on how to use the package from the client side ( JS for example ) specially when using a date argument as mutation input.

Is there any plan to support GraphQL 15 as the peer dependency goes up to ^14.0.0

GraphQL versions 15 and 16 are currently not supported in the dependencies. Opening this issue to upgrade the dependencies.

It can be recognized by new Date(), but I have to add resolver for DateTime:

  createdAt({ createdAt }) {
    return new Date(createdAt);
  },

Hello,
There's a problem here when the number is more than 32bit and I believe it will be a problem in the future. Could you please fix this?

Could you implement the same formats (including the time ones) that you propose in graphql/graphql-js#557 ?

This is a good foundation and a good interim solution, but it only covers date (without timezone) not time.

Thanks in advance

In newer versions of Flow (>=0.95) the types for JSON.stringify have been changed which is causing errors when using graphql-iso-date.

Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/date/index.js.flow:48:11

Cannot add 'Date canno...' and JSON.stringify(...) because undefined [1] is incompatible with string [2].

     node_modules/graphql-iso-date/dist/date/index.js.flow
      44│       )
      45│     } else {
      46│       throw new TypeError(
 [2]  47│         'Date cannot represent a non string, or non Date type ' +
      48│           JSON.stringify(value)
      49│       )
      50│     }
      51│   },

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;


Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/date/index.js.flow:55:50

Cannot coerce JSON.stringify(...) to string because undefined [1] should not be coerced.

     node_modules/graphql-iso-date/dist/date/index.js.flow
      52│   parseValue (value) {
      53│     if (!(typeof value === 'string' || value instanceof String)) {
      54│       throw new TypeError(
      55│         `Date cannot represent non string type ${JSON.stringify(value)}`
      56│       )
      57│     }
      58│

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;


Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/dateTime/index.js.flow:64:43

Cannot add 'DateTime c...' + 'non numeri...' and JSON.stringify(...) because undefined [1] is incompatible with
string [2].

     node_modules/graphql-iso-date/dist/dateTime/index.js.flow
      60│       )
      61│     } else {
      62│       throw new TypeError(
 [2]  63│         'DateTime cannot be serialized from a non string, ' +
      64│         'non numeric or non Date type ' + JSON.stringify(value)
      65│       )
      66│     }
      67│   },

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;


Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/dateTime/index.js.flow:71:54

Cannot coerce JSON.stringify(...) to string because undefined [1] should not be coerced.

     node_modules/graphql-iso-date/dist/dateTime/index.js.flow
      68│   parseValue (value) {
      69│     if (!(typeof value === 'string' || value instanceof String)) {
      70│       throw new TypeError(
      71│         `DateTime cannot represent non string type ${JSON.stringify(value)}`
      72│       )
      73│     }
      74│

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;


Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/time/index.js.flow:55:31

Cannot add 'Time canno...' + 'or non Dat...' and JSON.stringify(...) because undefined [1] is incompatible with
string [2].

     node_modules/graphql-iso-date/dist/time/index.js.flow
      51│       )
      52│     } else {
      53│       throw new TypeError(
 [2]  54│         'Time cannot be serialized from a non string, ' +
      55│         'or non Date type ' + JSON.stringify(value)
      56│       )
      57│     }
      58│   },

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;


Error ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈ node_modules/graphql-iso-date/dist/time/index.js.flow:62:50

Cannot coerce JSON.stringify(...) to string because undefined [1] should not be coerced.

     node_modules/graphql-iso-date/dist/time/index.js.flow
      59│   parseValue (value: mixed): Date {
      60│     if (!(typeof value === 'string' || value instanceof String)) {
      61│       throw new TypeError(
      62│         `Time cannot represent non string type ${JSON.stringify(value)}`
      63│       )
      64│     }
      65│

     /private/tmp/flow/flowlib_2a9f9c93/core.js
 [1] 491│     ): string | void;



Found 6 errors

Returning null in the resolver for a nullable DateTime gives 1970-01-01T00:00:00.000Z

typeDefs = `
  type User {
    dob: DateTime
  }
`

resolvers = {
  User: {
    dob: () => null
  }
}

I would expect returning null to have the query response also be null instead of 1970-01-01T00:00:00.000Z

I just begin a tutorial with graphql that use your lib, they use [email protected] so I had to do npm i -force to install your lib since you don't allow GraphQL 15, is there a reason or will that be possible soon ?

There should be a space in the description here.

Hi,

i am getting bellow error can someone please help me. in typedef.graphql file i am using bellow

type TimestampType {
createdAt: DateTime
createdBy: ProfileType
modifiedAt: DateTime
modifiedBy: ProfileType
}

mergeSchemas.js:49
throw new Error("Can't find type " + name + ".");
^

Error: Can't find type DateTime.

Seems odd that ES native expression of time (UNIX timestamp in milliseconds) is not supported as a valid input; only the truncated (seconds) format is accepted. This requires a superfluous new Date(timestamp) wrapper.

eg I have a type E with following statements

const GraphqlISODate  = require('graphql-iso-date');
const {GraphQLDate} = GraphqlISODate;

module.exports = gql`
type E {
 ... 
 purchaseDate: GraphQLDate
}
`

But I got error with GraphQLDate not found, how can I resolved it?