const formatDate = ({
date,
fromNow,
difference,
formatString,
locale = `en`,
}) => {
const normalizedDate = JSON.parse(JSON.stringify(date))
if (formatString) {
return moment
.utc(normalizedDate, ISO_8601_FORMAT, true)
.locale(locale)
.format(formatString)
} else if (fromNow) {
return moment
.utc(normalizedDate, ISO_8601_FORMAT, true)
.locale(locale)
.fromNow()
} else if (difference) {
return moment().diff(
moment.utc(normalizedDate, ISO_8601_FORMAT, true).locale(locale),
difference
)
}
return normalizedDate
}
function inferGraphQLType({
exampleValue,
selector,
...otherArgs
}): ?GraphQLFieldConfig<*, *> {
if (exampleValue == null || isEmptyObjectOrArray(exampleValue)) return
let fieldName = selector.split(`.`).pop()
if (Array.isArray(exampleValue)) {
exampleValue = exampleValue[0]
if (exampleValue == null) return
let headType
// If the array contains objects, than treat them as "nodes"
// and create an object type.
if (_.isObject(exampleValue)) {
headType = new GraphQLObjectType({
name: createTypeName(fieldName),
fields: inferObjectStructureFromNodes({
...otherArgs,
exampleValue,
selector,
}),
})
// Else if the values are simple values, just infer their type.
} else {
let inferredType = inferGraphQLType({
...otherArgs,
exampleValue,
selector,
})
invariant(
inferredType,
`Could not infer graphQL type for value: ${exampleValue}`
)
headType = inferredType.type
}
return { type: new GraphQLList(headType) }
}
// Check if this is a date.
// All the allowed ISO 8601 date-time formats used.
const momentDate = moment.utc(exampleValue, ISO_8601_FORMAT, true)
if (momentDate.isValid()) {
return {
type: GraphQLString,
args: {
formatString: {
type: GraphQLString,
},
fromNow: {
type: GraphQLBoolean,
description: oneLine`
Returns a string generated with Moment.js' fromNow function`,
},
difference: {
type: GraphQLString,
description: oneLine`
Returns the difference between this date and the current time.
Defaults to miliseconds but you can also pass in as the
measurement years, months, weeks, days, hours, minutes,
and seconds.`,
},
},
resolve(object, { fromNow, difference, formatString }) {
const date = JSON.parse(JSON.stringify(object[fieldName]))
if (formatString) {
return moment.utc(date, ISO_8601_FORMAT, true).format(formatString)
} else if (fromNow) {
return moment.utc(date, ISO_8601_FORMAT, true).fromNow()
} else if (difference) {
return moment().diff(
moment.utc(date, ISO_8601_FORMAT, true),
difference
)
} else {
return date
}
},
}
}
switch (typeof exampleValue) {
case `boolean`:
return { type: GraphQLBoolean }
case `string`:
return { type: GraphQLString }
case `object`:
return {
type: new GraphQLObjectType({
name: createTypeName(fieldName),
fields: inferObjectStructureFromNodes({
...otherArgs,
exampleValue,
selector,
}),
}),
}
case `number`:
return _.isInteger(exampleValue)
? { type: GraphQLInt }
: { type: GraphQLFloat }
default:
return null
}
}
/**
* @param {*} value
* @return {boolean}
*/
function isDate(value) {
const momentDate = moment.utc(value, ISO_8601_FORMAT, true)
return typeof value !== `number` && momentDate.isValid()
}
exports.onCreateNode = ({ node, actions, getNode, reporter }) => {
const { createNodeField } = actions
let slug
if (node.internal.type === `File`) {
const parsedFilePath = parseFilepath(node.relativePath)
if (node.sourceInstanceName === `docs`) {
if (parsedFilePath.name !== `index` && parsedFilePath.dir !== ``) {
slug = `/${parsedFilePath.dir}/${parsedFilePath.name}/`
} else if (parsedFilePath.dir === ``) {
slug = `/${parsedFilePath.name}/`
} else {
slug = `/${parsedFilePath.dir}/`
}
}
if (slug) {
createNodeField({ node, name: `slug`, value: slug })
}
} else if (
node.internal.type === `MarkdownRemark` &&
getNode(node.parent).internal.type === `File`
) {
const fileNode = getNode(node.parent)
const parsedFilePath = parseFilepath(fileNode.relativePath)
// Add slugs for docs pages
if (fileNode.sourceInstanceName === `docs`) {
if (parsedFilePath.name !== `index` && parsedFilePath.dir !== ``) {
slug = `/${parsedFilePath.dir}/${parsedFilePath.name}/`
} else if (parsedFilePath.dir === ``) {
slug = `/${parsedFilePath.name}/`
} else {
slug = `/${parsedFilePath.dir}/`
}
// Set released status and `published at` for blog posts.
if (_.includes(parsedFilePath.dir, `blog`)) {
let released = false
const date = _.get(node, `frontmatter.date`)
if (date) {
released = moment.utc().isSameOrAfter(moment.utc(date))
}
createNodeField({ node, name: `released`, value: released })
const canonicalLink = _.get(node, `frontmatter.canonicalLink`)
const publishedAt = _.get(node, `frontmatter.publishedAt`)
createNodeField({
node,
name: `publishedAt`,
value: canonicalLink
? publishedAt || url.parse(canonicalLink).hostname
: null,
})
}
}
// Add slugs for package READMEs.
if (
fileNode.sourceInstanceName === `packages` &&
parsedFilePath.name === `README`
) {
slug = `/packages/${parsedFilePath.dir}/`
createNodeField({
node,
name: `title`,
value: parsedFilePath.dir,
})
createNodeField({ node, name: `package`, value: true })
}
if (slug) {
createNodeField({ node, name: `anchor`, value: slugToAnchor(slug) })
createNodeField({ node, name: `slug`, value: slug })
}
} else if (node.internal.type === `AuthorYaml`) {
slug = `/contributors/${slugify(node.id, {
lower: true,
})}/`
createNodeField({ node, name: `slug`, value: slug })
} else if (node.internal.type === `SitesYaml` && node.main_url) {
const parsed = url.parse(node.main_url)
const cleaned = parsed.hostname + parsed.pathname
slug = `/showcase/${slugify(cleaned)}`
createNodeField({ node, name: `slug`, value: slug })
// determine if screenshot is available
const screenshotNode = node.children
.map(childID => getNode(childID))
.find(node => node.internal.type === `Screenshot`)
createNodeField({ node, name: `hasScreenshot`, value: !!screenshotNode })
} else if (node.internal.type === `StartersYaml` && node.repo) {
// To develop on the starter showcase, you'll need a GitHub
// personal access token. Check the `www` README for details.
// Default fields are to avoid graphql errors.
const { owner, name: repoStub } = parseGHUrl(node.repo)
const defaultFields = {
slug: `/${owner}/${repoStub}/`,
stub: repoStub,
name: ``,
description: ``,
stars: 0,
lastUpdated: ``,
owner: ``,
githubFullName: ``,
gatsbyMajorVersion: [[`no data`, `0`]],
allDependencies: [[`no data`, `0`]],
gatsbyDependencies: [[`no data`, `0`]],
miscDependencies: [[`no data`, `0`]],
}
if (!process.env.GITHUB_API_TOKEN) {
return createNodeField({
node,
name: `starterShowcase`,
value: {
...defaultFields,
},
})
} else {
return Promise.all([
getpkgjson(node.repo),
githubApiClient.request(`
query {
repository(owner:"${owner}", name:"${repoStub}") {
name
stargazers {
totalCount
}
createdAt
pushedAt
owner {
login
}
nameWithOwner
}
}
`),
])
.then(results => {
const [pkgjson, githubData] = results
const {
stargazers: { totalCount: stars },
pushedAt: lastUpdated,
owner: { login: owner },
name,
nameWithOwner: githubFullName,
} = githubData.repository
const { dependencies = [], devDependencies = [] } = pkgjson
const allDependencies = Object.entries(dependencies).concat(
Object.entries(devDependencies)
)
const gatsbyMajorVersion = allDependencies
.filter(([key, _]) => key === `gatsby`)
.map(version => {
let [gatsby, versionNum] = version
if (versionNum === `latest` || versionNum === `next`) {
return [gatsby, `2`]
}
return [gatsby, versionNum.replace(/\D/g, ``).charAt(0)]
})
// If a new field is added here, make sure a corresponding
// change is made to "defaultFields" to not break DX
const starterShowcaseFields = {
slug: `/${owner}/${repoStub}/`,
stub: repoStub,
name,
description: pkgjson.description,
stars,
lastUpdated,
owner,
githubFullName,
gatsbyMajorVersion,
allDependencies,
gatsbyDependencies: allDependencies
.filter(
([key, _]) => ![`gatsby-cli`, `gatsby-link`].includes(key) // remove stuff everyone has
)
.filter(([key, _]) => key.includes(`gatsby`)),
miscDependencies: allDependencies.filter(
([key, _]) => !key.includes(`gatsby`)
),
}
createNodeField({
node,
name: `starterShowcase`,
value: starterShowcaseFields,
})
})
.catch(err => {
reporter.panicOnBuild(
`Error getting repo data for starter "${repoStub}":\n
${err.message}`
)
})
}
} else if (node.internal.type === `CreatorsYaml`) {
// Creator pages
const validTypes = {
individual: `people`,
agency: `agencies`,
company: `companies`,
}
if (!validTypes[node.type]) {
throw new Error(
`Creators must have a type of “individual”, “agency”, or “company”, but invalid type “${
node.type
}” was provided for ${node.name}.`
)
}
slug = `/creators/${validTypes[node.type]}/${slugify(node.name, {
lower: true,
})}`
createNodeField({ node, name: `slug`, value: slug })
}
// end Creator pages
return null
}
// Check if this is a date.
// All the allowed ISO 8601 date-time formats used.
function shouldInfer(value) {
var momentDate = moment.utc(value, ISO_8601_FORMAT, true);
return momentDate.isValid() && typeof value !== `number`;
}
var date = void 0;
if (source[fieldName]) {
date = JSON.parse(JSON.stringify(source[fieldName]));
} else {
return null;
}
if (_.isPlainObject(args)) {
var fromNow = args.fromNow,
difference = args.difference,
formatString = args.formatString,
_args$locale = args.locale,
locale = _args$locale === undefined ? `en` : _args$locale;
if (formatString) {
return moment.utc(date, ISO_8601_FORMAT, true).locale(locale).format(formatString);
} else if (fromNow) {
return moment.utc(date, ISO_8601_FORMAT, true).locale(locale).fromNow();
} else if (difference) {
return moment().diff(moment.utc(date, ISO_8601_FORMAT, true).locale(locale), difference);
}
}
return date;
}
});
function getType() {
return type;
}
//# sourceMappingURL=type-date.js.map
description: oneLine`
Configures the locale Moment.js will use to format the date.`,
},
},
resolve(source, args, context, { fieldName }) {
let date
if (source[fieldName]) {
date = JSON.parse(JSON.stringify(source[fieldName]))
} else {
return null
}
if (_.isPlainObject(args)) {
const { fromNow, difference, formatString, locale = `en` } = args
if (formatString) {
return moment
.utc(date, ISO_8601_FORMAT, true)
.locale(locale)
.format(formatString)
} else if (fromNow) {
return moment
.utc(date, ISO_8601_FORMAT, true)
.locale(locale)
.fromNow()
} else if (difference) {
return moment().diff(
moment.utc(date, ISO_8601_FORMAT, true).locale(locale),
difference
)
}
}