@uxf/scripts 11.61.4 → 11.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.61.4",
+    "version": "11.62.0",
     "description": "",
     "main": "index.js",
     "bin": {

package/src/uxf-sitemap-check/index.js

@@ -8,15 +8,23 @@ const robotsTxtParser = require("robots-txt-parser");
 const { HTTP_USERNAME, HTTP_PASSWORD } = process.env;
 
 /**
- * @typedef {{parentUrl: (string | undefined), isImg: boolean, ttl: number, url: string, status: number, message: (string | undefined), skipped: boolean, html: (string | null)}} UrlCheckResponse
+ * @typedef {{parentUrl: (string | undefined), isImg: boolean, isWebPage: boolean, ttl: number, url: string, status: number, message: (string | undefined), skipped: boolean, html: (string | null), redirected: boolean}} UrlCheckResponse
+ */
+
+/**
+ * @typedef {{url: string, parentUrl: (string | undefined), canonicalUrl: (string | null), isImg: boolean, isWebPage: boolean, ttl: number, status: number, message: (string | undefined), skipped: boolean, indexable: boolean, redirected: boolean}} TestedUrlDto
  */
 
 const MAX_TTL = 3;
 const IMAGES_LABEL = "🏞 Images:";
 const URLS_LABEL = "🔗 Links:";
 
+/**
+ * @type TestedUrlDto[]
+ */
 const TESTED_URLS = [];
 const URLS_TO_CHECK = new Set();
+const ERRORS = [];
 
 const robotsParser = robotsTxtParser({ userAgent: "uxf-bot", allowOnNeutral: false });
 
@@ -73,6 +81,7 @@ function createErrorList(errors) {
 function createErrorResult(errors) {
     let parentPages = "";
     let nestedPages = "";
+    let generalErrors = "";
 
     const parentPagesErrors = errors.filter((url) => url.parentUrl === undefined);
     if (parentPagesErrors.length > 0) {
@@ -103,7 +112,14 @@ function createErrorResult(errors) {
         }
     }
 
-    return parentPages + nestedPages;
+    if (ERRORS.length > 0) {
+        generalErrors = `\n\nGeneral errors:\n`;
+        for (const error of ERRORS) {
+            generalErrors += `${createTabSpace(1)}${error}\n`;
+        }
+    }
+
+    return parentPages + nestedPages + generalErrors;
 }
 
 /**
@@ -163,11 +179,13 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
             url,
             parentUrl,
             isImg: isImageUrl(url),
+            isWebPage: false,
             ttl,
             status: 0,
             message: "invalid url: " + url,
             skipped: false,
             html: null,
+            redirected: false,
         };
     }
 
@@ -184,11 +202,13 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
                     url,
                     parentUrl,
                     isImg: isImageUrl(url),
+                    isWebPage: true,
                     ttl,
                     status: 0,
                     message: "blocked by robots.txt",
                     skipped: true,
                     html: null,
+                    redirected: false,
                 };
             }
         }
@@ -201,11 +221,13 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
             url,
             parentUrl,
             isImg: isImageUrl(url),
+            isWebPage: true,
             ttl,
             status: errorStatus,
             message: e.message,
             skipped: errorStatus !== undefined,
             html: null,
+            redirected: false,
         };
     }
 
@@ -220,10 +242,12 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
             url,
             parentUrl,
             isImg: isImageUrl(url),
+            isWebPage: response.headers.get("content-type").includes("text/html"),
             ttl,
             status: response.status,
             skipped: false,
             html: await response.text(),
+            redirected: response.redirected,
         };
     } catch (e) {
         const status = Number.parseInt((e && e.response && e.response.status) || -1, 10);
@@ -232,11 +256,13 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
             url,
             parentUrl,
             isImg: isImageUrl(url),
+            isWebPage: true,
             ttl,
             status,
             message: e.message,
             skipped: false,
             html: null,
+            redirected: false,
         };
     }
 }
@@ -245,7 +271,7 @@ async function fetchUrl(url, webUrl, parentUrl = undefined, ttl = 1) {
  * @param url {string}
  * @param webUrl {string}
  * @param parentUrl {string | undefined}
- * @return {UrlCheckResponse}
+ * @return {result: UrlCheckResponse|TestedUrlDto, fromCache: boolean}
  */
 async function testUrl(url, webUrl, parentUrl = undefined) {
     const indexInChecked = TESTED_URLS.findIndex((result) => result.url === url);
@@ -253,16 +279,26 @@ async function testUrl(url, webUrl, parentUrl = undefined) {
         const result = await fetchUrl(url, webUrl, parentUrl);
         TESTED_URLS.push({
             isImg: result.isImg,
+            isWebPage: result.isWebPage,
             message: result.message,
             parentUrl: result.parentUrl,
             skipped: result.skipped,
             status: result.status,
             ttl: result.ttl,
             url: result.url,
+            redirected: result.redirected,
+            indexable:
+                result.isWebPage && typeof result.html === "string"
+                    ? cheerio.load(result.html)("meta[name='robots']").attr("content") !== "noindex"
+                    : false,
+            canonicalUrl:
+                result.isWebPage && typeof result.html === "string"
+                    ? (cheerio.load(result.html)("link[rel='canonical']").attr("href") ?? null)
+                    : null,
         });
-        return result;
+        return { result, fromCache: false };
     }
-    return TESTED_URLS[indexInChecked];
+    return { result: TESTED_URLS[indexInChecked], fromCache: true };
 }
 
 /**
@@ -283,14 +319,14 @@ async function testSitemapUrls(urls, webUrl, sitemapUrl, skip, withNested, withI
         const url = urls[i];
         const changedUrl = webUrl ? `${webUrl}${new URL(url).pathname}` : url;
 
-        const result = await testUrl(changedUrl, webUrl);
+        const { result, fromCache } = await testUrl(changedUrl, webUrl);
         printProgress();
 
-        if (withNested && result.status === 200) {
+        if (withNested && !fromCache && result.status === 200) {
             await testNestedUrls(result.html, changedUrl, i, webUrl ?? sitemapUrl.split("/").slice(0, 3).join("/"));
         }
 
-        if (withImages && result.status === 200) {
+        if (withImages && !fromCache && result.status === 200) {
             await testNestedImages(result.html, changedUrl, i, webUrl ?? sitemapUrl.split("/").slice(0, 3).join("/"));
         }
     }
@@ -304,13 +340,20 @@ async function testSitemapUrls(urls, webUrl, sitemapUrl, skip, withNested, withI
  * @return {Promise<void>}
  */
 async function testNestedUrls(html, parentUrl, parentIndex, webUrl) {
-    const $ = cheerio.load(html);
-    const urls = createCorrectLinks(
-        $("a[href]").map((i, node) => $(node).attr("href")),
-        webUrl,
-    );
+    try {
+        const $ = cheerio.load(html.toString());
+        let urls = createCorrectLinks(
+            $("a[href]").map((i, node) => $(node).attr("href")),
+            webUrl,
+        );
+
+        // FIXME
+        urls = urls.filter((url) => url.startsWith(webUrl) || url.startsWith("/"));
 
-    await testNested(urls, parentIndex, parentUrl, createTabSpace() + URLS_LABEL, webUrl);
+        await testNested(urls, parentIndex, parentUrl, createTabSpace() + URLS_LABEL, webUrl);
+    } catch (e) {
+        ERRORS.push(`Can't test all nested pages for ${parentUrl} - ${e.message}`);
+    }
 }
 
 /**
@@ -321,13 +364,17 @@ async function testNestedUrls(html, parentUrl, parentIndex, webUrl) {
  * @return {Promise<void>}
  */
 async function testNestedImages(html, parentUrl, parentIndex, webUrl) {
-    const $ = cheerio.load(html);
-    const images = createCorrectLinks(
-        $("img[src]").map((i, node) => $(node).attr("src")),
-        webUrl,
-    );
+    try {
+        const $ = cheerio.load(html);
+        const images = createCorrectLinks(
+            $("img[src]").map((i, node) => $(node).attr("src")),
+            webUrl,
+        );
 
-    await testNested(images, parentIndex, parentUrl, createTabSpace() + IMAGES_LABEL, webUrl);
+        await testNested(images, parentIndex, parentUrl, createTabSpace() + IMAGES_LABEL, webUrl);
+    } catch (e) {
+        ERRORS.push(`Can't test all nested images for ${parentUrl} - ${e.message}`);
+    }
 }
 
 /**
@@ -426,6 +473,24 @@ async function sendGoogleChatMessage(resultErrors, webhookUrl) {
     );
 }
 
+/**
+ * @param webUrl {string}
+ * @return {string[]}
+ */
+function getPagesShouldBeInSitemap(webUrl) {
+    return TESTED_URLS.filter((u) => u.indexable)
+        .filter(
+            (dto) =>
+                (dto.canonicalUrl ?? dto.url).startsWith(webUrl) &&
+                !(dto.canonicalUrl ?? dto.url).includes("?") &&
+                dto.status === 200 &&
+                dto.ttl <= 1 &&
+                !dto.redirected &&
+                dto.isWebPage,
+        )
+        .map((url) => (url.canonicalUrl ?? url.url).toLowerCase());
+}
+
 /**
  * @param sitemapUrl {string}
  * @param skip {number}
@@ -453,17 +518,32 @@ module.exports = async function run(sitemapUrl, skip, withNested, withImages, go
     }
 
     const startTime = performance.now();
-    await testSitemapUrls(await Sitemap.getSitemap(sitemapUrl), webUrl, sitemapUrl, skip, withNested, withImages);
+    const sitemapUrls = await Sitemap.getSitemap(sitemapUrl);
+    await testSitemapUrls(sitemapUrls, webUrl, sitemapUrl, skip, withNested, withImages);
     const finishTime = performance.now();
 
+    const shouldBeInSitemap = getPagesShouldBeInSitemap(webUrl);
+
     const errors = TESTED_URLS.filter((r) => r.status !== 200 && r.skipped === false);
+    const duplicates = [...new Set(sitemapUrls.filter((item, index, self) => self.indexOf(item) !== index))];
     const skippedUrls = TESTED_URLS.filter((r) => r.status !== 200 && r.skipped === true);
     const ok = TESTED_URLS.filter((r) => r.status === 200);
+    const missingInSitemap = shouldBeInSitemap.filter((testedUrl) => !sitemapUrls.includes(testedUrl));
 
-    if (errors.length > 0) {
+    if (missingInSitemap.length > 0 || duplicates.length > 0 || errors.length > 0 || ERRORS.length > 0) {
+        const duplicatesText = duplicates.map((url) => `${createTabSpace()}${url}`).join("\n");
+        const missingText = missingInSitemap.map((url) => `${createTabSpace()}${url}`).join("\n");
         const errorText = createErrorResult(errors);
-        logErrors(errorText, "\n\n\nErrors:\n");
-        await sendGoogleChatMessage(errorText, googleWebhookUrl);
+        if (duplicatesText) {
+            logErrors(duplicatesText, "\n\n\nDuplicated pages in sitemap:\n");
+        }
+        if (missingText) {
+            logErrors(missingText, "\n\n\nMissing pages in sitemap:\n");
+        }
+        if (errorText) {
+            logErrors(errorText, "\n\n\nErrors:\n");
+        }
+        await sendGoogleChatMessage(duplicatesText + missingText + errorText, googleWebhookUrl);
     }
 
     if (skippedUrls.length > 0) {