@allurereport/ci 3.18.0 → 3.19.0

package/dist/detectors/gitlab.d.ts

@@ -1,2 +1,16 @@
 import { type CiDescriptor } from "@allurereport/core-api";
-export declare const gitlab: CiDescriptor;
+export type GitlabCiDescriptor = CiDescriptor & {
+    projectId: string;
+    projectPath: string;
+    projectDirectory: string;
+    pipelineSource: string;
+    ciJobName: string;
+    currentJobId: string;
+    currentJobUrl: string;
+    mergeRequestProjectId: string;
+    restApiUrl: string;
+    graphqlApiUrl: string;
+    ref: string;
+    jobArtifactsUrlBase: string;
+};
+export declare const gitlab: GitlabCiDescriptor;

package/dist/detectors/gitlab.js

@@ -1,15 +1,18 @@
 import { CiType, GitProvider } from "@allurereport/core-api";
 import { getEnv } from "../utils.js";
+const GITLAB_DEFAULT_SERVER_URL = "https://gitlab.com";
+const stripTrailingSlashes = (value) => value.replace(/\/+$/, "");
 const getMergeRequestProjectUrl = () => getEnv("CI_MERGE_REQUEST_PROJECT_URL") || getEnv("CI_PROJECT_URL");
-const isTagPipeline = () => Boolean(getEnv("CI_COMMIT_TAG"));
-const getSourceBranch = () => {
-    if (isTagPipeline()) {
-        return undefined;
+const getSourceRef = () => getEnv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME") || getEnv("CI_COMMIT_REF_NAME") || undefined;
+const getServerUrl = () => stripTrailingSlashes(getEnv("CI_SERVER_URL") || GITLAB_DEFAULT_SERVER_URL);
+const getRestApiUrl = () => stripTrailingSlashes(getEnv("CI_API_V4_URL") || `${getServerUrl()}/api/v4`);
+const getGraphqlApiUrl = () => {
+    const explicit = getEnv("CI_API_GRAPHQL_URL");
+    if (explicit) {
+        return stripTrailingSlashes(explicit);
     }
-    return (getEnv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME") ||
-        getEnv("CI_COMMIT_BRANCH") ||
-        getEnv("CI_COMMIT_REF_NAME") ||
-        undefined);
+    const restApiUrl = getRestApiUrl();
+    return restApiUrl.replace(/\/api\/v4$/, "/api/graphql");
 };
 export const gitlab = {
     type: CiType.Gitlab,
@@ -28,6 +31,9 @@ export const gitlab = {
     get jobName() {
         return getEnv("CI_PROJECT_NAME");
     },
+    get ciJobName() {
+        return getEnv("CI_JOB_NAME");
+    },
     get jobRunUid() {
         return getEnv("CI_PIPELINE_ID");
     },
@@ -38,14 +44,14 @@ export const gitlab = {
         return getEnv("CI_PIPELINE_ID");
     },
     get jobRunBranch() {
-        return getSourceBranch() || "";
+        return getSourceRef() || "";
     },
     get pullRequestUrl() {
         const mergeRequestIID = getEnv("CI_MERGE_REQUEST_IID");
         if (!mergeRequestIID) {
             return "";
         }
-        const projectUrl = getMergeRequestProjectUrl().replace(/\/+$/, "");
+        const projectUrl = stripTrailingSlashes(getMergeRequestProjectUrl());
         return projectUrl ? `${projectUrl}/-/merge_requests/${mergeRequestIID}` : "";
     },
     get pullRequestName() {
@@ -64,7 +70,7 @@ export const gitlab = {
             : undefined;
     },
     get sourceBranch() {
-        return getSourceBranch();
+        return getSourceRef();
     },
     get targetBranch() {
         return getEnv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME") || undefined;
@@ -79,4 +85,38 @@ export const gitlab = {
             }
             : undefined;
     },
+    get projectId() {
+        return getEnv("CI_PROJECT_ID");
+    },
+    get projectPath() {
+        return getEnv("CI_PROJECT_PATH");
+    },
+    get projectDirectory() {
+        return getEnv("CI_PROJECT_DIR");
+    },
+    get pipelineSource() {
+        return getEnv("CI_PIPELINE_SOURCE");
+    },
+    get currentJobId() {
+        return getEnv("CI_JOB_ID");
+    },
+    get currentJobUrl() {
+        return getEnv("CI_JOB_URL");
+    },
+    get mergeRequestProjectId() {
+        return getEnv("CI_MERGE_REQUEST_PROJECT_ID");
+    },
+    get restApiUrl() {
+        return getRestApiUrl();
+    },
+    get graphqlApiUrl() {
+        return getGraphqlApiUrl();
+    },
+    get ref() {
+        return getSourceRef() || "";
+    },
+    get jobArtifactsUrlBase() {
+        return (`${new URL(getServerUrl()).protocol}//${getEnv("CI_PROJECT_ROOT_NAMESPACE_SLUG")}.${getEnv("CI_PAGES_DOMAIN") || "gitlab.io"}` +
+            `/-/${getEnv("CI_PROJECT_NAME")}/-/jobs/${this.currentJobId}/artifacts`);
+    },
 };

package/dist/helpers/gitlab/client.d.ts

@@ -0,0 +1,14 @@
+import { type AxiosResponse } from "axios";
+import { type GitlabCiDescriptor } from "../../detectors/gitlab.js";
+export type GitlabClient = {
+    ci: GitlabCiDescriptor;
+    query<T>(query: string, variables: Record<string, unknown>): Promise<T>;
+    requestJson<T>(method: "GET" | "POST" | "PUT", path: string, body?: unknown): Promise<{
+        data: T;
+        headers: AxiosResponse["headers"];
+    }>;
+    downloadArtifact(jobId: string, artifactPath: string): Promise<Uint8Array>;
+};
+export declare const createGitlabClient: (options?: {
+    token?: string;
+}) => GitlabClient;

package/dist/helpers/gitlab/client.js

@@ -0,0 +1,133 @@
+import axios from "axios";
+import { gitlab } from "../../detectors/gitlab.js";
+const REQUEST_TIMEOUT_MS = 10000;
+const isDecimalString = (value) => /^[0-9]+$/.test(value);
+const requireMetadata = (ci) => {
+    const missing = [];
+    if (!ci.detected) {
+        missing.push("GitLab CI");
+    }
+    if (!ci.projectId) {
+        missing.push("CI_PROJECT_ID");
+    }
+    if (!ci.projectPath) {
+        missing.push("CI_PROJECT_PATH");
+    }
+    if (!ci.projectDirectory) {
+        missing.push("CI_PROJECT_DIR");
+    }
+    if (!ci.jobRunUid) {
+        missing.push("CI_PIPELINE_ID");
+    }
+    if (!ci.pipelineSource) {
+        missing.push("CI_PIPELINE_SOURCE");
+    }
+    if (!ci.ciJobName) {
+        missing.push("CI_JOB_NAME");
+    }
+    if (!ci.ref) {
+        missing.push("CI_COMMIT_REF_NAME");
+    }
+    return missing;
+};
+const invalidNumericMetadata = (ci) => {
+    const invalid = [];
+    if (!isDecimalString(ci.projectId)) {
+        invalid.push("CI_PROJECT_ID");
+    }
+    if (!isDecimalString(ci.jobRunUid)) {
+        invalid.push("CI_PIPELINE_ID");
+    }
+    if (ci.currentJobId && !isDecimalString(ci.currentJobId)) {
+        invalid.push("CI_JOB_ID");
+    }
+    if (ci.mergeRequestProjectId && !isDecimalString(ci.mergeRequestProjectId)) {
+        invalid.push("CI_MERGE_REQUEST_PROJECT_ID");
+    }
+    return invalid;
+};
+const encodeArtifactPathSegment = (segment) => {
+    if (segment === ".") {
+        return "%2E";
+    }
+    if (segment === "..") {
+        return "%2E%2E";
+    }
+    return encodeURIComponent(segment);
+};
+const encodeArtifactPath = (artifactPath) => artifactPath.split("/").map(encodeArtifactPathSegment).join("/");
+const buildRestUrl = (restApiUrl, path) => new URL(path.replace(/^\/+/, ""), `${restApiUrl.href.replace(/\/+$/, "")}/`);
+const hasApiPathSuffix = (url, suffix) => url.pathname.replace(/\/+$/, "").endsWith(suffix);
+const assertTrustedApiUrl = (url, apiOrigin) => {
+    if (url.origin !== apiOrigin) {
+        throw new Error("GitLab API request left trusted origin");
+    }
+};
+export const createGitlabClient = (options) => {
+    const token = options?.token;
+    const ci = gitlab;
+    const missingMetadata = requireMetadata(ci);
+    if (missingMetadata.length > 0) {
+        throw new Error(`missing GitLab metadata: ${missingMetadata.join(", ")}`);
+    }
+    const invalidNumeric = invalidNumericMetadata(ci);
+    if (invalidNumeric.length > 0) {
+        throw new Error(`invalid numeric GitLab metadata: ${invalidNumeric.join(", ")}`);
+    }
+    const restApiUrl = new URL(ci.restApiUrl);
+    const graphqlApiUrl = new URL(ci.graphqlApiUrl);
+    if (!hasApiPathSuffix(restApiUrl, "/api/v4") || !hasApiPathSuffix(graphqlApiUrl, "/api/graphql")) {
+        throw new Error("invalid GitLab API endpoint paths");
+    }
+    if (restApiUrl.origin !== graphqlApiUrl.origin) {
+        throw new Error("GitLab API origins do not match");
+    }
+    const apiOrigin = restApiUrl.origin;
+    const requestOptions = {
+        headers: token ? { "private-token": token } : {},
+        sensitiveHeaders: ["private-token"],
+        timeout: REQUEST_TIMEOUT_MS,
+    };
+    return {
+        ci,
+        async query(query, variables) {
+            const { data: envelope } = await axios.request({
+                ...requestOptions,
+                url: graphqlApiUrl.href,
+                method: "POST",
+                data: { query, variables },
+            });
+            if (!envelope || typeof envelope !== "object") {
+                throw new Error("GitLab GraphQL response was invalid");
+            }
+            if (envelope.errors) {
+                throw new Error("GitLab GraphQL response contained errors");
+            }
+            if (!Object.hasOwn(envelope, "data")) {
+                throw new Error("GitLab GraphQL response omitted data");
+            }
+            return envelope.data;
+        },
+        async requestJson(method, path, body) {
+            const url = buildRestUrl(restApiUrl, path);
+            assertTrustedApiUrl(url, apiOrigin);
+            const { data, headers } = await axios.request({
+                ...requestOptions,
+                url: url.href,
+                method,
+                data: body,
+            });
+            return { data, headers };
+        },
+        async downloadArtifact(jobId, artifactPath) {
+            const url = buildRestUrl(restApiUrl, `/projects/${encodeURIComponent(ci.projectId)}/jobs/${encodeURIComponent(jobId)}/artifacts/${encodeArtifactPath(artifactPath)}`);
+            const { data } = await axios.request({
+                ...requestOptions,
+                url: url.href,
+                method: "GET",
+                responseType: "arraybuffer",
+            });
+            return data;
+        },
+    };
+};

package/dist/helpers/gitlab/comments.d.ts

@@ -0,0 +1,6 @@
+import type { ReportContext } from "../../reportContext.js";
+export declare const upsertGitlabJobNote: (options: {
+    token: string;
+    summary: ReportContext;
+    reportUrl: string;
+}) => Promise<void>;

package/dist/helpers/gitlab/comments.js

@@ -0,0 +1,128 @@
+import { gitlab } from "../../detectors/gitlab.js";
+import { createGitlabClient } from "./client.js";
+import { renderGitlabReportSummary } from "./summary.js";
+const MARKER_VERSION = "v1";
+const MAX_NOTE_SCAN_PAGES = 5;
+const NOTE_PAGE_SIZE = 100;
+const MAX_COMMENT_LENGTH = 60000;
+const isDecimalString = (value) => /^[0-9]+$/.test(value);
+const encodePathSegment = (value) => encodeURIComponent(value);
+const ownershipMarker = ({ jobName, pipelineId, jobId }) => `<!-- allure-gitlab-summary:${MARKER_VERSION}:${jobName}:${pipelineId}:${jobId} -->`;
+const parseNotes = (value) => {
+    if (!Array.isArray(value)) {
+        throw new Error("invalid notes response");
+    }
+    return value.map((note) => {
+        if (typeof note !== "object" || note === null) {
+            throw new Error("invalid notes response");
+        }
+        const { id, body } = note;
+        const textId = typeof id === "number" && Number.isInteger(id) ? String(id) : typeof id === "string" ? id : "";
+        if (!textId || typeof body !== "string") {
+            throw new Error("invalid notes response");
+        }
+        return { id: textId, body };
+    });
+};
+const markerPattern = new RegExp(`^<!-- allure-gitlab-summary:${MARKER_VERSION}:([A-Za-z0-9+/]+={0,2}):([0-9]+):([0-9]+) -->\\n`);
+const parseMarker = (body) => {
+    const match = body.match(markerPattern);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        jobName: match[1],
+        pipelineId: BigInt(match[2]),
+        jobId: BigInt(match[3]),
+    };
+};
+const compareLogicalRun = (left, right) => {
+    if (left.pipelineId > right.pipelineId) {
+        return 1;
+    }
+    if (left.pipelineId < right.pipelineId) {
+        return -1;
+    }
+    if (left.jobId > right.jobId) {
+        return 1;
+    }
+    if (left.jobId < right.jobId) {
+        return -1;
+    }
+    return 0;
+};
+const currentMarker = (client) => ({
+    jobName: Buffer.from(client.ci.ciJobName).toString("base64"),
+    pipelineId: BigInt(client.ci.jobRunUid),
+    jobId: BigInt(client.ci.currentJobId),
+});
+const notePath = (client, iid, page) => {
+    const base = `/projects/${encodePathSegment(client.ci.projectId)}/merge_requests/${encodePathSegment(iid)}/notes`;
+    return page === undefined ? base : `${base}?per_page=${NOTE_PAGE_SIZE}&page=${page}`;
+};
+const readOwnedNotes = async (client, iid, currentJobName) => {
+    const notes = [];
+    let page = 1;
+    for (let index = 0; index < MAX_NOTE_SCAN_PAGES; index += 1) {
+        const { data, headers } = await client.requestJson("GET", notePath(client, iid, page));
+        for (const note of parseNotes(data)) {
+            const marker = parseMarker(note.body);
+            if (marker?.jobName === currentJobName) {
+                notes.push({ note, marker });
+            }
+        }
+        const nextPageHeader = headers["x-next-page"];
+        if (typeof nextPageHeader !== "string") {
+            throw new Error("incomplete note scan");
+        }
+        const nextPage = nextPageHeader.trim();
+        if (!nextPage) {
+            return notes;
+        }
+        const expectedNextPage = String(page + 1);
+        if (!isDecimalString(nextPage) || nextPage !== expectedNextPage) {
+            throw new Error("incomplete note scan");
+        }
+        page += 1;
+    }
+    throw new Error("incomplete note scan");
+};
+const selectNewestOwnedNote = (notes) => notes.reduce((selected, candidate) => {
+    if (!selected || compareLogicalRun(candidate.marker, selected.marker) > 0) {
+        return candidate;
+    }
+    return selected;
+}, undefined);
+export const upsertGitlabJobNote = async (options) => {
+    const iid = gitlab.pullRequest?.id;
+    if (!iid || !isDecimalString(iid)) {
+        throw new Error("missing merge request");
+    }
+    if (gitlab.projectId && gitlab.mergeRequestProjectId && gitlab.mergeRequestProjectId !== gitlab.projectId) {
+        throw new Error("cross-project merge request");
+    }
+    const client = createGitlabClient(options);
+    if (!client.ci.currentJobId || !isDecimalString(client.ci.currentJobId)) {
+        throw new Error("missing current job");
+    }
+    const current = currentMarker(client);
+    const reportUrl = new URL(options.reportUrl);
+    if ((reportUrl.protocol !== "http:" && reportUrl.protocol !== "https:") || reportUrl.username || reportUrl.password) {
+        throw new Error("invalid report URL");
+    }
+    const body = `${ownershipMarker(current)}\n${renderGitlabReportSummary(options.summary, reportUrl)}`;
+    if (body.length > MAX_COMMENT_LENGTH) {
+        throw new Error("comment too large");
+    }
+    const ownedNotes = await readOwnedNotes(client, iid, current.jobName);
+    const selected = selectNewestOwnedNote(ownedNotes);
+    if (selected && compareLogicalRun(selected.marker, current) > 0) {
+        throw new Error("newer owned note exists");
+    }
+    if (selected) {
+        await client.requestJson("PUT", `${notePath(client, iid)}/${encodePathSegment(selected.note.id)}`, { body });
+    }
+    else {
+        await client.requestJson("POST", notePath(client, iid), { body });
+    }
+};

package/dist/helpers/gitlab/history.d.ts

@@ -0,0 +1,4 @@
+export declare const restoreGitlabHistory: (options: {
+    token?: string;
+    historyPath: string;
+}) => Promise<void>;

package/dist/helpers/gitlab/history.js

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, relative, sep } from "node:path";
+import { createGitlabClient } from "./client.js";
+const previousGitlabJobQuery = `query PreviousGitlabJob($path: ID!, $ref: String!, $source: String!, $job: String!) {
+  project(fullPath: $path) {
+    pipelines(ref: $ref, source: $source, first: 100) {
+      nodes { id source job(name: $job) { id name status retried } }
+    }
+  }
+}`;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const decodeGitlabId = (value, type) => {
+    if (typeof value !== "string") {
+        throw new Error("invalid id");
+    }
+    const typeName = type === "Pipeline" ? "Pipeline" : "Build";
+    const match = value.match(new RegExp(`^gid://gitlab/Ci::${typeName}/([0-9]+)$`));
+    if (!match) {
+        throw new Error("invalid id");
+    }
+    return { text: match[1], value: BigInt(match[1]) };
+};
+const parseJob = (value) => {
+    if (value === null) {
+        return null;
+    }
+    if (!isRecord(value)) {
+        throw new Error("invalid job");
+    }
+    const { id, name, status, retried } = value;
+    if (typeof id !== "string" || typeof name !== "string" || typeof status !== "string") {
+        throw new Error("invalid job");
+    }
+    if (retried !== true && retried !== false && retried !== null) {
+        throw new Error("invalid job");
+    }
+    return { id, name, status, retried };
+};
+const parsePipelines = (response) => {
+    if (!isRecord(response) || !isRecord(response.project)) {
+        throw new Error("invalid project");
+    }
+    const { pipelines } = response.project;
+    if (!isRecord(pipelines) || !Array.isArray(pipelines.nodes)) {
+        throw new Error("invalid pipelines");
+    }
+    return pipelines.nodes.map((node) => {
+        if (!isRecord(node) ||
+            typeof node.id !== "string" ||
+            typeof node.source !== "string" ||
+            !Object.hasOwn(node, "job")) {
+            throw new Error("invalid pipeline");
+        }
+        return {
+            id: node.id,
+            source: node.source,
+            job: parseJob(node.job),
+        };
+    });
+};
+const selectPreviousJobId = (client, nodes) => {
+    const currentPipelineId = BigInt(client.ci.jobRunUid);
+    let previousPipelineId;
+    let selectedJobId;
+    for (const node of nodes) {
+        const pipelineId = decodeGitlabId(node.id, "Pipeline");
+        if (previousPipelineId !== undefined && pipelineId.value >= previousPipelineId) {
+            throw new Error("invalid pipeline order");
+        }
+        previousPipelineId = pipelineId.value;
+        if (node.source !== client.ci.pipelineSource) {
+            throw new Error("invalid pipeline source");
+        }
+        const { job } = node;
+        const jobId = job ? decodeGitlabId(job.id, "Build") : undefined;
+        if (selectedJobId || pipelineId.value >= currentPipelineId || !job || !jobId) {
+            continue;
+        }
+        if (job.name !== client.ci.ciJobName) {
+            continue;
+        }
+        if (job.status !== "SUCCESS" && job.status !== "FAILED") {
+            continue;
+        }
+        if (job.retried === true) {
+            continue;
+        }
+        selectedJobId = jobId.text;
+    }
+    return selectedJobId;
+};
+const projectRelativePath = (projectDirectory, historyPath) => relative(projectDirectory, historyPath).split(sep).join("/");
+export const restoreGitlabHistory = async (options) => {
+    const client = createGitlabClient(options);
+    const response = await client.query(previousGitlabJobQuery, {
+        path: client.ci.projectPath,
+        ref: client.ci.ref,
+        source: client.ci.pipelineSource,
+        job: client.ci.ciJobName,
+    });
+    const selectedJobId = selectPreviousJobId(client, parsePipelines(response));
+    if (!selectedJobId) {
+        throw new Error("no matching prior job in returned pipeline window");
+    }
+    const bytes = await client.downloadArtifact(selectedJobId, projectRelativePath(client.ci.projectDirectory, options.historyPath));
+    if (bytes.byteLength === 0) {
+        throw new Error("empty history artifact");
+    }
+    await mkdir(dirname(options.historyPath), { recursive: true });
+    await writeFile(options.historyPath, bytes);
+};

package/dist/helpers/gitlab/index.d.ts

@@ -0,0 +1,4 @@
+export { createGitlabClient } from "./client.js";
+export { upsertGitlabJobNote } from "./comments.js";
+export { restoreGitlabHistory } from "./history.js";
+export type { GitlabClient } from "./client.js";

package/dist/helpers/gitlab/index.js

@@ -0,0 +1,3 @@
+export { createGitlabClient } from "./client.js";
+export { upsertGitlabJobNote } from "./comments.js";
+export { restoreGitlabHistory } from "./history.js";

package/dist/helpers/gitlab/summary.d.ts

@@ -0,0 +1,2 @@
+import type { ReportContext } from "../../reportContext.js";
+export declare const renderGitlabReportSummary: (summary: ReportContext, reportUrl: URL) => string;

package/dist/helpers/gitlab/summary.js

@@ -0,0 +1,19 @@
+import { renderReportSummaryMarkdown } from "../../reportMarkdown.js";
+const reportHref = (report, reportUrl) => {
+    const { href, reportPath } = report;
+    if (href && /^[A-Za-z][A-Za-z0-9+.-]*:/.test(href)) {
+        return href;
+    }
+    if (reportPath !== undefined) {
+        const path = reportPath.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+        return new URL(`${path ? `${path}/` : ""}index.html`, reportUrl).href;
+    }
+    return href ? new URL(href, reportUrl).href : undefined;
+};
+export const renderGitlabReportSummary = (summary, reportUrl) => {
+    const context = {
+        ...summary,
+        reports: summary.reports.map((report) => ({ ...report, href: reportHref(report, reportUrl) })),
+    };
+    return renderReportSummaryMarkdown(context, { includeArtifacts: false });
+};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
-export * from "./reportContext.js";
-export * from "./reportMarkdown.js";
+export { restoreGitlabHistory, upsertGitlabJobNote } from "./helpers/gitlab/index.js";
+export type { GitlabCiDescriptor } from "./detectors/gitlab.js";

package/dist/index.js

@@ -1,5 +1,6 @@
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
-export * from "./reportContext.js";
-export * from "./reportMarkdown.js";
+export { restoreGitlabHistory, upsertGitlabJobNote } from "./helpers/gitlab/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/ci",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "description": "Utilities set to get useful report data from different CI",
   "keywords": [
     "allure",
@@ -32,8 +32,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.18.0",
-    "@allurereport/plugin-api": "3.18.0",
+    "@allurereport/core-api": "3.19.0",
+    "@allurereport/plugin-api": "3.19.0",
+    "axios": "^1.20.0",
     "glob": "^13.0.6"
   },
   "devDependencies": {