gatsby-source-tilda/dist/source-nodes.js

Gatsby source plugin for building websites using the tilda.cc CMS as a data source

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.sourceNodes = void 0;
const is_online_1 = __importDefault(require("is-online"));
const plugin_options_1 = require("./plugin-options");
const download_assets_1 = require("./download-assets");
const create_tilda_pages_1 = require("./create-tilda-pages");
const fetch_data_1 = require("./fetch-data");
const consts_1 = require("./consts");
const sourceNodes = async ({ actions: { createNode, createNodeField, touchNode, deleteNode }, createNodeId, createContentDigest, getNode, getNodes, store, cache, reporter, }, configOptions) => {
    const online = await (0, is_online_1.default)();
    // If the user knows they are offline, serve them cached result
    // For prod builds though always fail if we can't get the latest data
    if (!online && process.env.NODE_ENV !== 'production') {
        getNodes()
            .filter((n) => n.internal.owner === consts_1.OWNER)
            .forEach((n) => touchNode(n));
        reporter.info('Using Offline cache ⚠️');
        reporter.info('Cache may be invalidated if you edit package.json, gatsby-node.js or gatsby-config.js files');
        return;
    }
    const config = (0, plugin_options_1.createPluginConfig)(configOptions);
    if (config.skip) {
        reporter.info(`Skip tilda sync...`);
        return;
    }
    // fetch tilda data
    reporter.info(`Fetch Tilda Pages for projectId: ${config.projectId}...`);
    let pages = await (0, fetch_data_1.fetchPages)({ pluginConfig: config, reporter });
    pages = pages.filter((p) => !config.exclude.find((item) => item === p.alias));
    reporter.info(`Fetch Tilda Pages info...`);
    const pagesInfo = await Promise.all(pages.map((p) => {
        reporter.info(`Fetching '${p.alias}' – '${p.title}' info...`);
        return (0, fetch_data_1.fetchPageInfo)({
            pageId: p.id,
            pluginConfig: config,
            reporter,
        });
    }));
    // get new, updated and deleted pages
    const tildaPageNodes = getNodes().filter((n) => n.internal.owner === consts_1.OWNER && n.internal.type === consts_1.PAGE_TYPE);
    const tildaAssetsNodes = getNodes().filter((n) => n.internal.owner === consts_1.OWNER && n.internal.type === consts_1.PAGE_ASSET_TYPE);
    const deletedPageNodes = tildaPageNodes.filter((n) => !pages.find((p) => p.id === n.pageId));
    const deletedAssets = tildaAssetsNodes.filter((n) => deletedPageNodes.find((pN) => pN.pageId === n.pageId));
    const newPages = pages.filter((p) => !tildaPageNodes.find((n) => p.id === n.pageId));
    const updatedPages = pages.filter((p) => tildaPageNodes.find((n) => p.id === n.pageId && n.published !== p.published));
    // const notModifiedPages = pages.filter((p) =>
    //   tildaPageNodes.find((n) => p.id === n.pageId && n.published === p.published)
    // );
    const notModifiedPgs = tildaPageNodes.filter((n) => pages.find((p) => p.id === n.pageId && n.published === p.published));
    // process deleted tilda pages and assets
    const deleteTildaNode = (node) => deleteNode(node);
    deletedPageNodes.forEach(deleteTildaNode);
    deletedAssets.forEach(deleteTildaNode);
    // clear deleted assets from cache
    await Promise.all(deletedAssets.map(async (asset) => {
        const { id, url } = asset;
        const remoteDataCacheKey = `tilda-asset-${id}-${url}`;
        await cache.del(remoteDataCacheKey);
    }));
    // create nodes for all tilda assets
    let tildaAssets = [];
    pagesInfo.forEach((pageInfo) => {
        tildaAssets = tildaAssets.concat([...pageInfo.css, ...pageInfo.js, ...pageInfo.images].map((item) => ({
            ...item,
            pageId: pageInfo.id,
        })));
    });
    reporter.info('');
    reporter.info(`Total TildaPages: ${tildaPageNodes.length}`);
    reporter.info(`Created/Updated pages: ${[...newPages, ...updatedPages].length}`);
    reporter.info(`Unmodified pages: ${notModifiedPgs.length}`);
    reporter.info(`Deleted pages: ${deletedPageNodes.length}`);
    reporter.info('');
    reporter.info(`Total TildaAssets: ${tildaAssets.length}`);
    reporter.info(`Cached TildaAssets: ${tildaAssetsNodes.length}`);
    reporter.info(`Deleted assets: ${deletedAssets.length}`);
    reporter.info('');
    // touch unmodified pages to keep from garbage collection
    notModifiedPgs.forEach((pageNode) => {
        touchNode(pageNode);
    });
    // create nodes for all tilda pages
    await Promise.all((0, create_tilda_pages_1.createTildaPages)({
        actions: { createNode },
        createNodeId,
        createContentDigest,
    }, config, pagesInfo));
    await Promise.all((0, create_tilda_pages_1.createTildaPageAssets)({
        actions: { createNode },
        createNodeId,
        createContentDigest,
    }, tildaAssets));
    const tildaAssetNodes = getNodes().filter((n) => n.internal.owner === consts_1.OWNER && n.internal.type === consts_1.PAGE_ASSET_TYPE);
    if (config.downloadAssets) {
        //   download locally all tilda assets from imported pages
        await (0, download_assets_1.downloadTildaAssets)({
            actions: { createNode, createNodeField, touchNode },
            createNodeId,
            store,
            cache,
            getNode,
            getNodes,
            reporter,
            assetNodes: tildaAssetNodes,
        });
    }
};
exports.sourceNodes = sourceNodes;