gatsby-source-sanity
Version:
Gatsby source plugin for building websites using Sanity.io as a backend.
166 lines • 7.12 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var graphql_1 = require("gatsby/graphql");
var normalize_1 = require("./normalize");
var builtins = ['ID', 'String', 'Boolean', 'Int', 'Float', 'JSON', 'DateTime', 'Date'];
var wantedNodeTypes = ['ObjectTypeDefinition', 'UnionTypeDefinition', 'InterfaceTypeDefinition'];
exports.rewriteGraphQLSchema = function (schemaSdl, context) {
var ast = graphql_1.parse(schemaSdl);
var transformedAst = transformAst(ast, context);
var transformed = graphql_1.print(transformedAst);
return transformed;
};
function transformAst(ast, context) {
return __assign(__assign({}, ast), { definitions: ast.definitions
.filter(isWantedAstNode)
.map(function (node) { return transformDefinitionNode(node, context); }) });
}
function isWantedAstNode(astNode) {
var node = astNode;
return wantedNodeTypes.includes(node.kind) && node.name.value !== 'RootQuery';
}
function transformDefinitionNode(node, context) {
switch (node.kind) {
case 'ObjectTypeDefinition':
return transformObjectTypeDefinition(node, context);
case 'UnionTypeDefinition':
return transformUnionTypeDefinition(node, context);
case 'InterfaceTypeDefinition':
return transformInterfaceTypeDefinition(node, context);
default:
return node;
}
}
function transformObjectTypeDefinition(node, context) {
var fields = node.fields || [];
var jsonTargets = fields.map(getJsonAliasTargets).filter(Boolean);
var blockFields = jsonTargets.map(makeBlockField);
var interfaces = (node.interfaces || []).map(maybeRewriteType);
var isDocumentType = interfaces.some(function (item) { return item.kind === 'NamedType' && item.name.value === 'SanityDocument'; });
// Implement Gatsby node interface if it is a document
if (isDocumentType) {
interfaces.push({ kind: 'NamedType', name: { kind: 'Name', value: 'Node' } });
}
return __assign(__assign({}, node), { name: __assign(__assign({}, node.name), { value: getTypeName(node.name.value) }), interfaces: interfaces, directives: [{ kind: 'Directive', name: { kind: 'Name', value: 'dontInfer' } }], fields: __spreadArrays(fields
.filter(function (field) { return !getJsonAliasTargets(field); })
.map(function (field) { return transformFieldNodeAst(field, node, context); }), blockFields) });
}
function transformUnionTypeDefinition(node, context) {
return __assign(__assign({}, node), { types: (node.types || []).map(maybeRewriteType), name: __assign(__assign({}, node.name), { value: getTypeName(node.name.value) }) });
}
function transformInterfaceTypeDefinition(node, context) {
var fields = node.fields || [];
return __assign(__assign({}, node), { fields: fields.map(function (field) { return transformFieldNodeAst(field, node, context); }), name: __assign(__assign({}, node.name), { value: getTypeName(node.name.value) }) });
}
function unwrapType(typeNode) {
if (['NonNullType', 'ListType'].includes(typeNode.kind)) {
var wrappedType = typeNode;
return unwrapType(wrappedType.type);
}
return typeNode;
}
function getJsonAliasTargets(field) {
var alias = (field.directives || []).find(function (dir) { return dir.name.value === 'jsonAlias'; });
if (!alias) {
return null;
}
var forArg = (alias.arguments || []).find(function (arg) { return arg.name.value === 'for'; });
if (!forArg) {
return null;
}
return graphql_1.valueFromAST(forArg.value, graphql_1.GraphQLString, {});
}
function makeBlockField(name) {
return {
kind: 'FieldDefinition',
name: {
kind: 'Name',
value: name,
},
arguments: [],
directives: [],
type: {
kind: 'ListType',
type: {
kind: 'NamedType',
name: {
kind: 'Name',
value: 'SanityBlock',
},
},
},
};
}
function makeNullable(nodeType) {
if (nodeType.kind === 'NamedType') {
return maybeRewriteType(nodeType);
}
if (nodeType.kind === 'ListType') {
var unwrapped = maybeRewriteType(unwrapType(nodeType));
return {
kind: 'ListType',
type: makeNullable(unwrapped),
};
}
return maybeRewriteType(nodeType.type);
}
function transformFieldNodeAst(node, parent, context) {
var field = __assign(__assign({}, node), { name: maybeRewriteFieldName(node, parent, context), type: rewireIdType(makeNullable(node.type)), description: undefined, directives: [] });
if (field.type.kind === 'NamedType' && field.type.name.value === 'Date') {
field.directives.push({ kind: 'Directive', name: { kind: 'Name', value: 'dateformat' } });
}
return field;
}
function rewireIdType(nodeType) {
if (nodeType.kind === 'NamedType' && nodeType.name.value === 'ID') {
return __assign(__assign({}, nodeType), { name: { kind: 'Name', value: 'String' } });
}
return nodeType;
}
function maybeRewriteType(nodeType) {
var type = nodeType;
if (typeof type.name === 'undefined') {
return nodeType;
}
// Gatsby has a date type, but not a datetime, so rewire it
if (type.name.value === 'DateTime') {
return __assign(__assign({}, type), { name: { kind: 'Name', value: 'Date' } });
}
if (builtins.includes(type.name.value)) {
return type;
}
return __assign(__assign({}, type), { name: { kind: 'Name', value: getTypeName(type.name.value) } });
}
function maybeRewriteFieldName(field, parent, context) {
if (!normalize_1.RESTRICTED_NODE_FIELDS.includes(field.name.value)) {
return field.name;
}
var parentTypeName = parent.name.value;
var newFieldName = normalize_1.getConflictFreeFieldName(field.name.value);
if (parentTypeName !== 'Block') {
context.reporter.warn("[sanity] Type `" + parentTypeName + "` has field with name `" + field.name.value + "`, which conflicts with Gatsby's internal properties. Renaming to `" + newFieldName + "`");
}
return __assign(__assign({}, field.name), { value: newFieldName });
}
function getTypeName(name) {
return name.startsWith('Sanity') ? name : "Sanity" + name;
}
//# sourceMappingURL=rewriteGraphQLSchema.js.map