@griddo/cx 1.72.4 → 1.72.7

package/gatsby-config.js

@@ -32,6 +32,7 @@ const CONFIG = {
 
 if (assetPrefix) {
   CONFIG.assetPrefix = assetPrefix;
+  CONFIG.pathPrefix = '';
 }
 
 module.exports = CONFIG;

package/gatsby-node.js

@@ -70,9 +70,31 @@ exports.onPreInit = async () => {
   initCache();
   await folders.prepareStaticFolder();
   await SettingsService.getAll();
-  updatedSites = await sites.checkSites();
-  helpers.log('info', 'RENDERING SITES ===>', updatedSites);
-  await RobotsService.loadRobots();
+  try {
+    const { sitesToRender, sitesToUnpublish } = await sites.checkSites();
+
+    if (sitesToRender.length === 0 && sitesToUnpublish.length === 0) {
+      console.log(
+        '\n',
+        JSON.stringify({ sitesToRender, sitesToUnpublish }, null, 2),
+        '\n'
+      );
+
+      helpers.log('warning', 'There are no sites to update');
+      process.exit(0);
+    }
+
+    helpers.log('info', 'RENDERING SITES ===>', sitesToRender);
+    await sites.unpublishSites(sitesToUnpublish);
+    helpers.log('success', 'UNPUBLISHED SITES ->', sitesToUnpublish);
+    await folders.deleteSites([...sitesToRender]);
+    await RobotsService.loadRobots();
+
+    updatedSites = sitesToRender;
+  } catch (err) {
+    console.log(err.message);
+    process.exit(1);
+  }
 };
 
 // -----------------------------------------------------------------------------
@@ -83,7 +105,9 @@ exports.createPages = async ({ actions }) => {
   for (const site of updatedSites) {
     const cache = !site.shouldBeUpdated;
     const NavService = new NavigationService();
+
     const { id: siteID, slug: siteSlug, theme, favicon } = site;
+
     const {
       siteInfo,
       validPagesIds,
@@ -139,7 +163,7 @@ exports.createPages = async ({ actions }) => {
         showBasicMetaRobots,
       },
       BUILD_MODE,
-      siteScript
+      siteScript,
     };
 
     helpers.log('info', 'VALID PAGES -->', validPagesIds);
@@ -173,27 +197,27 @@ exports.createPages = async ({ actions }) => {
       // Multi-page (pagination) or single-page
       isList
         ? await utils.renderListPages(
-          {
-            rootPage: page,
-            pages: utils.getList(distributorTemplate),
-            isRoot: false,
-            defaultLang,
-            distributorTemplate,
-          },
-          additionalInfo,
-          actions.createPage
-        )
+            {
+              rootPage: page,
+              pages: utils.getList(distributorTemplate),
+              isRoot: false,
+              defaultLang,
+              distributorTemplate,
+            },
+            additionalInfo,
+            actions.createPage
+          )
         : await utils.renderPage(
-          {
-            ...page,
-            template: distributorTemplate,
-            isRoot: false,
-            defaultLang,
-            multiPageElements,
-          },
-          additionalInfo,
-          actions.createPage
-        );
+            {
+              ...page,
+              template: distributorTemplate,
+              isRoot: false,
+              defaultLang,
+              multiPageElements,
+            },
+            additionalInfo,
+            actions.createPage
+          );
 
       buildProcessData[siteID].publishHashes.push(page.hash);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@griddo/cx",
   "description": "Griddo SSG based on Gatsby",
-  "version": "1.72.4",
+  "version": "1.72.7",
   "authors": [
     "Álvaro Sánchez' <alvaro.sanches@secuoyas.com>",
     "Carlos Torres <carlos.torres@secuoyas.com>",
@@ -65,7 +65,7 @@
     "react-helmet": "^6.0.0"
   },
   "devDependencies": {
-    "@griddo/eslint-config-back": "^1.72.4",
+    "@griddo/eslint-config-back": "^1.72.7",
     "eslint": "^7.5.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-react": "7.14.3",
@@ -97,5 +97,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4b2082d98d7e776b382288a8bb80c43c1cf11626"
+  "gitHead": "560fef6f6b478792274a9c4cb76ccb748aa3bab0"
 }

package/scripts/griddo-exporter.js

@@ -1,84 +1,129 @@
 #!/usr/bin/env node
+require('dotenv').config();
+
 const { execSync } = require('child_process');
-const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
 const pkgDir = require('pkg-dir');
 
-const artifacts = ['dist', 'assets'];
+const helpers = require('../src/utils/helpers');
+const { initCache } = require('../src/utils/cache');
+const { findDomains } = require('../src/utils/domains');
 
-console.clear();
+const artifacts = ['dist', 'assets'];
 
 const currentPath = pkgDir.sync();
 const workingDirPath = pkgDir.sync(__dirname);
-const destDirPath = path.resolve(currentPath, 'exports');
+const baseOutputPath = path.resolve(currentPath, 'public');
+const destDirPath = path.resolve(currentPath, 'exports/sites');
 
-try {
-  console.log();
-  console.log(chalk.blue(' Griddo Exporter'));
-  console.log();
+// -----------------------------------------------------------------------------
+// Process Runner
+// -----------------------------------------------------------------------------
+const getEnvRunner = env => command => runner(command, env);
 
-  console.log(chalk.yellow(' Your sites are being exported'));
-
-  execSync('npm run build', {
+const runner = (command, env = {}) =>
+  execSync(command, {
     cwd: workingDirPath,
     stdio: 'inherit',
     shell: true,
+    env: {
+      ...process.env,
+      ...env,
+      GRIDDO_EXPORTER: true,
+    },
   });
 
-  console.log(chalk.green('  Your sites have been exported correctly'));
+const getAssetPrefix = domain => {
+  // TODO: Usar asset_prefix del dominio
+  if (!process.env.ASSET_PREFIX || !domain) return '';
+
+  if (!domain.startsWith('pro-')) return '';
+
+  return `${process.env.ASSET_PREFIX}/${domain}`;
+};
+
+// -----------------------------------------------------------------------------
+// Loggers
+// -----------------------------------------------------------------------------
+const logError = (...message) => helpers.log('error', ...message);
+const logInfo = (...message) => helpers.log('info', ...message);
+const logSuccess = (...message) => helpers.log('success', ...message);
+const logWarning = (...message) => helpers.log('warning', ...message);
 
-  execSync(`mkdir -p exports`, {
-    cwd: currentPath,
+// -----------------------------------------------------------------------------
+// Main Stuff
+// -----------------------------------------------------------------------------
+const runExportDomain = async domain => {
+  const run = getEnvRunner({
+    DOMAIN: domain,
+    ASSET_PREFIX: getAssetPrefix(domain),
   });
+  const domainDestDirPath = path.resolve(destDirPath, domain);
+
+  if (fs.existsSync(baseOutputPath)) {
+    logInfo(`Deleting base output path: ${baseOutputPath}`);
+    run(`rm -rf ${baseOutputPath}`);
+  }
+
+  run('npm run build');
+
+  logSuccess('Your sites have been exported correctly');
+
+  run(`mkdir -p ${domainDestDirPath}`);
 
   for (const dir of artifacts) {
     const cxDirSource = path.resolve(workingDirPath, dir);
-    const cxDirDest = path.resolve(destDirPath, dir);
-
-    if (fs.existsSync(cxDirSource)) {
-      // TODO: Use proper tools instead of execSync to delete and move files
-      try {
-	      if (fs.existsSync(cxDirDest)) {
-		      console.log(chalk.blue("Creando backup de " + cxDirDest + "..."));
-		      execSync(`mv ${cxDirDest} ${cxDirDest}-BACKUP`);
-	      }
-        //execSync(`mkdir -p ${cxDirDest}`);
-	      console.log(chalk.blue("Moviendo ficheros de " + cxDirSource + " a " + cxDirDest + "..."));
-        execSync(`mv ${cxDirSource} ${cxDirDest}`, {
-          cwd: workingDirPath,
-        });
-	      console.log(chalk.blue("Eliminando backup de " + cxDirDest + "..."));
-	      execSync(`rm -rf ${cxDirDest}-BACKUP`);
-      } catch {
-        console.log(
-          chalk.red(` Error moving files to ${cxDirDest}`),
-          componentDir,
-          error.message
-        );
-	      if (fs.existsSync(cxDirDest + "-BACKUP")) {
-                console.log(chalk.blue("Restaurando " + cxDirDest + "..."));
-                execSync(`mv ${cxDirDest}-BACKUP ${cxDirDest}`, {
-                         cwd: workingDirPath,
-                });
-	      }
-        continue;
+    const cxDirDest = path.resolve(domainDestDirPath, dir);
+    const cxDirDestBackup = `${cxDirDest}-BACKUP`;
+
+    if (!fs.existsSync(cxDirSource)) {
+      logError('Source directory has not been created:', cxDirSource);
+      continue;
+    }
+
+    try {
+      if (fs.existsSync(cxDirDest)) {
+        logInfo(`Creando backup de ${cxDirDest}...`);
+        run(`mv ${cxDirDest} ${cxDirDestBackup}`);
+      }
+
+      logInfo(`Moviendo ficheros de ${cxDirSource} a ${cxDirDest}...`);
+
+      run(`mv ${cxDirSource} ${cxDirDest}`);
+
+      logInfo(`Eliminando backup de ${cxDirDest}...`);
+      run(`rm -rf ${cxDirDestBackup}`);
+
+      logSuccess(`Your sites are ready to deploy at ${domainDestDirPath}`);
+    } catch (error) {
+      logError(`Error moving files to ${cxDirDest}`, error.message);
+
+      if (fs.existsSync(cxDirDestBackup)) {
+        logWarning(`Restaurando ${cxDirDest}...`);
+        run(`mv ${cxDirDestBackup} ${cxDirDest}`);
       }
-    } else {
-      console.log(
-        chalk.red("  There's been an error with your export"),
-        cxDirSource
-      );
       continue;
     }
   }
+};
+
+const launchExports = async () => {
+  logInfo('Griddo Exporter');
+
+  initCache();
+
+  const domains = await findDomains();
+
+  for (const domain of domains) {
+    logInfo(`Exporting domain ${domain}`);
+    await runExportDomain(domain);
+  }
+};
+
+console.clear();
 
-  console.log(
-    chalk.green(`  Your sites are ready to deploy at ${destDirPath}`)
-  );
-  console.log();
-} catch (err) {
-  console.log(chalk.red('ERROR'), err?.stdout?.toString());
-  console.log(chalk.red('ERROR'), err.message);
+launchExports().catch(err => {
+  console.error('ERROR', err?.stdout?.toString() || err);
   process.exit(1);
-}
+});

package/src/services/domains.js

@@ -0,0 +1,16 @@
+const api = require('./../api');
+
+const baseURL = process.env.API_URL;
+const ENDPOINTS = {
+  GET_ALL: `${baseURL}/domains`,
+};
+
+class DomainsService {
+  static async getAll() {
+    const { GET_ALL } = ENDPOINTS;
+    const response = await api.get(GET_ALL);
+    return response;
+  }
+}
+
+exports.default = DomainsService;

package/src/utils/cache.js

@@ -1,36 +1,46 @@
 const fs = require('fs');
+const path = require('path');
 const crypto = require('crypto');
 
 const apiCacheDirectory = './apiCache';
+const gatsbyCacheDirectory = path.resolve(__dirname, './../../.cache');
 
 const initCache = () => {
-    if (!fs.existsSync(apiCacheDirectory)) {
-        fs.mkdirSync(apiCacheDirectory);
-    }
+  // TODO: Make a domain-based cache to store and restore
+  if (fs.existsSync(gatsbyCacheDirectory)) {
+    fs.rmdirSync(gatsbyCacheDirectory, {
+      force: true,
+      recursive: true,
+    });
+  }
+  if (!fs.existsSync(apiCacheDirectory)) {
+    fs.mkdirSync(apiCacheDirectory);
+  }
 };
 
-const generateFilename = (petition) => {
-    const hashSum = crypto.createHash('sha256');
-    hashSum.update(JSON.stringify(petition));
-    return `${apiCacheDirectory}/${hashSum.digest('hex')}`;
+const generateFilename = petition => {
+  const hashSum = crypto.createHash('sha256');
+  hashSum.update(JSON.stringify(petition));
+  return `${apiCacheDirectory}/${hashSum.digest('hex')}`;
 };
 
 const saveCache = (petition, content = '') => {
-    const rightContent = typeof (content) === 'object' ? JSON.stringify(content) : content;
-    fs.writeFileSync(generateFilename(petition), rightContent, 'utf8');
+  const rightContent =
+    typeof content === 'object' ? JSON.stringify(content) : content;
+  fs.writeFileSync(generateFilename(petition), rightContent, 'utf8');
 };
 
-const getCache = (petition) => {
-    try {
-        const content = fs.readFileSync(generateFilename(petition));
-        return JSON.parse(content);
-    } catch {
-        return null;
-    }
+const getCache = petition => {
+  try {
+    const content = fs.readFileSync(generateFilename(petition));
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
 };
 
 module.exports = {
-    initCache,
-    saveCache,
-    getCache,
-};
+  initCache,
+  saveCache,
+  getCache,
+};

package/src/utils/domains.js

@@ -0,0 +1,24 @@
+const AuthService = require('../services/auth').default;
+const DomainsService = require('./../services/domains').default;
+
+const getDomainHostname = url => {
+  const urlObject = new URL(url);
+  return urlObject.hostname;
+};
+
+const getDomainSlugs = domains =>
+  domains
+    .filter(domain => !!domain.slug)
+    .map(domain => domain.slug.replace('/',''))
+    .reduce((acc, item) => acc.indexOf(item) < 0 ? [...acc, item] : acc, []);
+
+const findDomains = async () => {
+  await AuthService.login();
+  const domains = await DomainsService.getAll();
+
+  return getDomainSlugs(domains);
+};
+
+exports.getDomainHostname = getDomainHostname;
+exports.getDomainSlugs = getDomainSlugs;
+exports.findDomains = findDomains;

package/src/utils/folders.js

@@ -39,6 +39,9 @@ const deleteSites = async updatedSites => {
 };
 
 const updateDist = async () => {
+  const isGriddoExporter =
+    process.env.GRIDDO_EXPORTER && process.env.GRIDDO_EXPORTER === 'on';
+
   const src = './public';
   const dest = './dist';
 
@@ -54,6 +57,7 @@ const updateDist = async () => {
 
   const staticSrc = './dist/static';
   const staticDest = './assets/static';
+
   try {
     fs.copySync(src, dest);
     fs.copySync(pageDataSrc, pageDataDest);
@@ -63,6 +67,9 @@ const updateDist = async () => {
       const fileDest = `${assetsDest}/${file}`;
       fs.copySync(fileSrc, fileDest);
     });
+
+    if (isGriddoExporter) fs.rmSync(src, { recursive: true });
+
     helpers.log('success', 'SUCCESS!');
   } catch (err) {
     console.error(err);

package/src/utils/helpers.js

@@ -3,8 +3,18 @@ const LOGS = process.env.LOGS && JSON.parse(process.env.LOGS);
 
 // Terminal Log
 const log = (state, message, data) => {
-  const color = { error: 'red', info: 'cyan', success: 'green' };
-  const msg = { error: 'ERROR', info: 'INFO', success: 'SUCCESS' };
+  const color = {
+    error: 'red',
+    info: 'cyan',
+    success: 'green',
+    warning: 'yellow',
+  };
+  const msg = {
+    error: 'ERROR',
+    info: 'INFO',
+    success: 'SUCCESS',
+    warning: '! ',
+  };
 
   LOGS !== false &&
     state !== 'error' &&

package/src/utils/pages.js

@@ -93,14 +93,14 @@ async function renderSinglePage(page, additionalInfo, createPage) {
 
   if (assetPrefix) mappedPage.matchPath = fullPath.compose;
 
+  createPage(mappedPage);
+
   const exportFile = path.resolve(
     __dirname,
     '../../dist/',
     `./${filepath}index.html`
   );
 
-  createPage(mappedPage);
-
   const content = fs.existsSync(exportFile)
     ? fs.readFileSync(exportFile).toString()
     : '';
@@ -178,8 +178,9 @@ async function renderMultiplePages(page, additionalInfo, createPage) {
       ? paginatedPage.fullUrl.slice(0, -1)
       : paginatedPage.fullUrl;
     const rightSectionSlug = sectionSlug?.replace(/\//g, '');
-    const newCompose = `${compose}${compose.endsWith('/') ? '' : '/'
-      }${rightSectionSlug}`;
+    const newCompose = `${compose}${
+      compose.endsWith('/') ? '' : '/'
+    }${rightSectionSlug}`;
     paginatedPage.fullUrl = `${fullUrl}/${rightSectionSlug}`;
     paginatedPage.fullPath.compose = newCompose;
     paginatedPage.slug = newCompose;

package/src/utils/sites.js

@@ -9,7 +9,7 @@ const folders = require('./folders');
 
 const baseUrl = process.env.API_URL;
 const testSite = process.env.testSite && parseInt(process.env.testSite);
-const BYPASSRENDER = JSON.parse(process.env.BYPASSRENDER);
+const BYPASSRENDER = JSON.parse(process.env.BYPASSRENDER || false);
 const updateAllSitesAlways = process.env.updateAllSites === 'on';
 
 const checkSites = async () => {
@@ -28,26 +28,20 @@ const checkSites = async () => {
   if (updatedSites.length) {
     for (const updatedSite of updatedSites) {
       const langResponse = await SitesService.getLanguages(updatedSite.id);
-      const domains = langResponse.items.map(item => {
-        return { [item.id]: `${item.domain.slug}${item.path}` };
-      });
-
-      updatedSite.domains = domains;
+      updatedSite.domains = langResponse.items
+        .filter(
+          item => !process.env.DOMAIN || item.domain.slug.indexOf(process.env.DOMAIN) > 0
+        )
+        .map(item => ({ [item.id]: `${item.domain.slug}${item.path}` }));
     }
   }
 
   const sitesToRender = updatedSites.filter(site =>
-    testSite ? site.id === testSite : !!site.isPublished
+    testSite ? site.id === testSite : !!site.isPublished && site.domains.length > 0
   );
   const sitesToUnpublish = updatedSites.filter(site => !site.isPublished);
 
-  await unpublishSites(sitesToUnpublish);
-
-  helpers.log('success', 'UNPUBLISHED SITES ->', sitesToUnpublish);
-
-  await folders.deleteSites([...updatedSites]);
-
-  return [...sitesToRender];
+  return { sitesToRender, sitesToUnpublish };
 };
 
 const unpublishSites = async sites => {
@@ -190,6 +184,7 @@ const saveFile = (filePath, content) => {
 };
 
 exports.checkSites = checkSites;
+exports.unpublishSites = unpublishSites;
 exports.setPageRenderEnd = setPageRenderEnd;
 exports.getSiteData = getSiteData;
 exports.generateSitemaps = generateSitemaps;