gatsby-source-sanity/lib-es5/gatsby-node.js

"use strict";
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
    return cooked;
};
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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.setFieldsOnGraphQLNodeType = exports.onPreExtractQueries = exports.sourceNodes = exports.createSchemaCustomization = exports.createResolvers = exports.onPreBootstrap = void 0;
var path = require("path");
var oneline = require("oneline");
var split2_1 = __importDefault(require("split2"));
var through2_1 = __importDefault(require("through2"));
var fs_extra_1 = require("fs-extra");
var operators_1 = require("rxjs/operators");
var client_1 = __importDefault(require("@sanity/client"));
var pump_1 = require("./util/pump");
var rejectOnApiError_1 = require("./util/rejectOnApiError");
var normalize_1 = require("./util/normalize");
var getDocumentStream_1 = require("./util/getDocumentStream");
var cache_1 = require("./util/cache");
var removeSystemDocuments_1 = require("./util/removeSystemDocuments");
var handleDrafts_1 = require("./util/handleDrafts");
var handleListenerEvent_1 = require("./util/handleListenerEvent");
var handleWebhookEvent_1 = require("./util/handleWebhookEvent");
var remoteGraphQLSchema_1 = require("./util/remoteGraphQLSchema");
var debug_1 = __importDefault(require("./debug"));
var extendImageNode_1 = require("./images/extendImageNode");
var rewriteGraphQLSchema_1 = require("./util/rewriteGraphQLSchema");
var getGraphQLResolverMap_1 = require("./util/getGraphQLResolverMap");
var documentIds_1 = require("./util/documentIds");
var defaultConfig = {
    version: '1',
    overlayDrafts: false,
    graphqlTag: 'default',
};
var stateCache = {};
exports.onPreBootstrap = function (context, pluginConfig) { return __awaiter(void 0, void 0, void 0, function () {
    var config, reporter, actions, client, api, graphqlSdl, graphqlSdlKey, typeMap, typeMapKey, err_1;
    return __generator(this, function (_a) {
        switch (_a.label) {
            case 0:
                config = __assign(__assign({}, defaultConfig), pluginConfig);
                reporter = context.reporter, actions = context.actions;
                if (!actions.createTypes) {
                    reporter.panic(oneline(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n      You are using a version of Gatsby not supported by gatsby-source-sanity.\n      Either upgrade gatsby to >= 2.2.0 or downgrade to gatsby-source-sanity@^1.0.0\n    "], ["\n      You are using a version of Gatsby not supported by gatsby-source-sanity.\n      Either upgrade gatsby to >= 2.2.0 or downgrade to gatsby-source-sanity@^1.0.0\n    "]))));
                    return [2 /*return*/];
                }
                validateConfig(config, reporter);
                _a.label = 1;
            case 1:
                _a.trys.push([1, 4, , 5]);
                reporter.info('[sanity] Fetching remote GraphQL schema');
                client = getClient(config);
                return [4 /*yield*/, remoteGraphQLSchema_1.getRemoteGraphQLSchema(client, config)];
            case 2:
                api = _a.sent();
                reporter.info('[sanity] Transforming to Gatsby-compatible GraphQL SDL');
                return [4 /*yield*/, rewriteGraphQLSchema_1.rewriteGraphQLSchema(api, { config: config, reporter: reporter })];
            case 3:
                graphqlSdl = _a.sent();
                graphqlSdlKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.GRAPHQL_SDL);
                stateCache[graphqlSdlKey] = graphqlSdl;
                reporter.info('[sanity] Stitching GraphQL schemas from SDL');
                typeMap = remoteGraphQLSchema_1.getTypeMapFromGraphQLSchema(api);
                typeMapKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.TYPE_MAP);
                stateCache[typeMapKey] = typeMap;
                return [3 /*break*/, 5];
            case 4:
                err_1 = _a.sent();
                if (err_1.isWarning) {
                    err_1.message.split('\n').forEach(function (line) { return reporter.warn(line); });
                }
                else {
                    reporter.panic(err_1.stack);
                }
                return [3 /*break*/, 5];
            case 5: return [2 /*return*/];
        }
    });
}); };
exports.createResolvers = function (context, pluginConfig) {
    var typeMapKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.TYPE_MAP);
    var typeMap = (stateCache[typeMapKey] || remoteGraphQLSchema_1.defaultTypeMap);
    context.createResolvers(getGraphQLResolverMap_1.getGraphQLResolverMap(typeMap, pluginConfig, context));
};
exports.createSchemaCustomization = function (_a, pluginConfig) {
    var actions = _a.actions;
    var createTypes = actions.createTypes;
    var graphqlSdlKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.GRAPHQL_SDL);
    var graphqlSdl = stateCache[graphqlSdlKey];
    createTypes(graphqlSdl);
};
exports.sourceNodes = function (context, pluginConfig) { return __awaiter(void 0, void 0, void 0, function () {
    var config, dataset, overlayDrafts, watchMode, actions, getNode, createNodeId, createContentDigest, reporter, webhookBody, createNode, createParentChildLink, typeMapKey, typeMap, client, url, processingOptions, _a, numDocuments, inputStream, draftDocs, publishedNodes;
    return __generator(this, function (_b) {
        switch (_b.label) {
            case 0:
                config = __assign(__assign({}, defaultConfig), pluginConfig);
                dataset = config.dataset, overlayDrafts = config.overlayDrafts, watchMode = config.watchMode;
                actions = context.actions, getNode = context.getNode, createNodeId = context.createNodeId, createContentDigest = context.createContentDigest, reporter = context.reporter, webhookBody = context.webhookBody;
                createNode = actions.createNode, createParentChildLink = actions.createParentChildLink;
                typeMapKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.TYPE_MAP);
                typeMap = (stateCache[typeMapKey] || remoteGraphQLSchema_1.defaultTypeMap);
                client = getClient(config);
                url = client.getUrl("/data/export/" + dataset);
                processingOptions = {
                    typeMap: typeMap,
                    createNodeId: createNodeId,
                    createNode: createNode,
                    createContentDigest: createContentDigest,
                    createParentChildLink: createParentChildLink,
                    overlayDrafts: overlayDrafts,
                };
                _a = webhookBody &&
                    webhookBody.ids;
                if (!_a) return [3 /*break*/, 2];
                return [4 /*yield*/, handleWebhookEvent_1.handleWebhookEvent(context, { client: client, processingOptions: processingOptions })];
            case 1:
                _a = (_b.sent());
                _b.label = 2;
            case 2:
                if (_a) {
                    // If the payload was handled by the webhook handler, fall back.
                    // Otherwise, this may not be a Sanity webhook, but we should
                    // still attempt to refresh our data
                    return [2 /*return*/];
                }
                reporter.info('[sanity] Fetching export stream for dataset');
                numDocuments = 0;
                return [4 /*yield*/, getDocumentStream_1.getDocumentStream(url, config.token)];
            case 3:
                inputStream = _b.sent();
                draftDocs = [];
                publishedNodes = new Map();
                return [4 /*yield*/, pump_1.pump([
                        inputStream,
                        split2_1.default(JSON.parse),
                        rejectOnApiError_1.rejectOnApiError(),
                        overlayDrafts ? handleDrafts_1.extractDrafts(draftDocs) : handleDrafts_1.removeDrafts(),
                        removeSystemDocuments_1.removeSystemDocuments(),
                        through2_1.default.obj(function (doc, enc, cb) {
                            numDocuments++;
                            var type = normalize_1.getTypeName(doc._type);
                            if (!typeMap.objects[type]) {
                                reporter.warn("[sanity] Document \"" + doc._id + "\" has type " + doc._type + " (" + type + "), which is not declared in the GraphQL schema. Make sure you run \"graphql deploy\". Skipping document.");
                                cb();
                                return;
                            }
                            var node = normalize_1.processDocument(doc, processingOptions);
                            debug_1.default('Got document with ID %s (mapped to %s)', doc._id, node.id);
                            cb();
                        }),
                    ])];
            case 4:
                _b.sent();
                if (draftDocs.length > 0) {
                    reporter.info("[sanity] Overlaying " + draftDocs.length + " drafts");
                    draftDocs.forEach(function (draft) {
                        normalize_1.processDocument(draft, processingOptions);
                        var published = getNode(draft.id);
                        if (published) {
                            publishedNodes.set(documentIds_1.unprefixId(draft._id), published);
                        }
                    });
                }
                if (watchMode) {
                    reporter.info('[sanity] Watch mode enabled, starting a listener');
                    client
                        .listen('*[!(_id in path("_.**"))]')
                        .pipe(operators_1.filter(function (event) { return overlayDrafts || !event.documentId.startsWith('drafts.'); }))
                        .subscribe(function (event) { return handleListenerEvent_1.handleListenerEvent(event, publishedNodes, context, processingOptions); });
                }
                reporter.info("[sanity] Done! Exported " + numDocuments + " documents.");
                return [2 /*return*/];
        }
    });
}); };
exports.onPreExtractQueries = function (context, pluginConfig) { return __awaiter(void 0, void 0, void 0, function () {
    var getNodes, store, typeMapKey, typeMap, shouldAddFragments, program;
    return __generator(this, function (_a) {
        switch (_a.label) {
            case 0:
                getNodes = context.getNodes, store = context.store;
                typeMapKey = cache_1.getCacheKey(pluginConfig, cache_1.CACHE_KEYS.TYPE_MAP);
                typeMap = (stateCache[typeMapKey] || remoteGraphQLSchema_1.defaultTypeMap);
                shouldAddFragments = typeof typeMap.objects.SanityImageAsset !== 'undefined';
                if (!shouldAddFragments) {
                    shouldAddFragments = getNodes().some(function (node) {
                        return Boolean(node.internal && node.internal.type === 'SanityImageAsset');
                    });
                }
                if (!shouldAddFragments) return [3 /*break*/, 2];
                program = store.getState().program;
                return [4 /*yield*/, fs_extra_1.copy(path.join(__dirname, '..', 'fragments', 'imageFragments.js'), program.directory + "/.cache/fragments/sanity-image-fragments.js")];
            case 1:
                _a.sent();
                _a.label = 2;
            case 2: return [2 /*return*/];
        }
    });
}); };
exports.setFieldsOnGraphQLNodeType = function (context, pluginConfig) { return __awaiter(void 0, void 0, void 0, function () {
    var type, fields;
    return __generator(this, function (_a) {
        type = context.type;
        fields = {};
        if (type.name === 'SanityImageAsset') {
            fields = __assign(__assign({}, fields), extendImageNode_1.extendImageNode(context, pluginConfig));
        }
        return [2 /*return*/, fields];
    });
}); };
function validateConfig(config, reporter) {
    if (!config.projectId) {
        throw new Error('[sanity] `projectId` must be specified');
    }
    if (!config.dataset) {
        throw new Error('[sanity] `dataset` must be specified');
    }
    if (config.overlayDrafts && !config.token) {
        reporter.warn('[sanity] `overlayDrafts` is set to `true`, but no token is given');
    }
    var inDevelopMode = process.env.gatsby_executing_command === 'develop';
    if (config.watchMode && !inDevelopMode) {
        reporter.warn('[sanity] Using `watchMode` when not in develop mode might prevent your build from completing');
    }
}
function getClient(config) {
    var projectId = config.projectId, dataset = config.dataset, token = config.token;
    return new client_1.default({
        projectId: projectId,
        dataset: dataset,
        token: token,
        useCdn: false,
    });
}
var templateObject_1;
//# sourceMappingURL=gatsby-node.js.map