@jam-comments/server-utilities 4.2.0 → 4.3.0

package/dist/cjs/utils.test.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const utils_1 = require("./utils");
+const _1 = require(".");
 const env = process.env;
 (0, vitest_1.beforeEach)(() => {
     vitest_1.vi.resetModules();
@@ -44,3 +45,45 @@ const env = process.env;
         });
     });
 });
+(0, vitest_1.describe)("createTempDirectory()", () => {
+    (0, vitest_1.it)("creates temp directory fresh", () => {
+        const mkdirSyncMock = vitest_1.vi.fn();
+        const existsSyncMock = vitest_1.vi.fn().mockReturnValue(false);
+        (0, vitest_1.expect)(() => (0, utils_1.createTempDirectory)(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        (0, vitest_1.expect)(mkdirSyncMock).toHaveBeenCalledWith(_1.TEMP_DIRECTORY);
+    });
+    (0, vitest_1.it)("does not throw error when it already exists", () => {
+        const mkdirSyncMock = vitest_1.vi.fn().mockImplementation(() => {
+            throw new Error("Directory already exists");
+        });
+        const existsSyncMock = vitest_1.vi.fn().mockReturnValue(true);
+        (0, vitest_1.expect)(() => (0, utils_1.createTempDirectory)(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        (0, vitest_1.expect)(mkdirSyncMock).not.toHaveBeenCalledWith();
+    });
+});
+(0, vitest_1.describe)("toSavedFileName()", () => {
+    (0, vitest_1.it)("replaces slashes with double colons", () => {
+        (0, vitest_1.expect)((0, utils_1.toSavedFileName)("/hey/there")).toEqual("hey::there");
+    });
+});
+(0, vitest_1.describe)("readFile()", () => {
+    (0, vitest_1.it)("reads the file", () => {
+        const readFileSyncMock = vitest_1.vi.fn().mockReturnValue("file contents");
+        (0, vitest_1.expect)((0, utils_1.readFile)("hey/there", readFileSyncMock)).toEqual("file contents");
+        (0, vitest_1.expect)(readFileSyncMock).toHaveBeenCalledWith(`${_1.TEMP_DIRECTORY}/hey::there`, "utf8");
+    });
+    (0, vitest_1.it)("returns null when file doesn't exist", () => {
+        const readFileSyncMock = vitest_1.vi.fn().mockImplementation(() => {
+            throw new Error("File not found");
+        });
+        (0, vitest_1.expect)((0, utils_1.readFile)("hey/there", readFileSyncMock)).toEqual(null);
+    });
+});
+(0, vitest_1.describe)("saveFile()", () => {
+    (0, vitest_1.it)("saves the file", async () => {
+        const writeFileMock = vitest_1.vi.fn();
+        const result = (0, utils_1.saveFile)("hey/there", "file contents", writeFileMock);
+        (0, vitest_1.expect)(writeFileMock).toHaveBeenCalledWith(`${_1.TEMP_DIRECTORY}/hey::there`, "file contents", vitest_1.expect.any(Function));
+        (0, vitest_1.expect)(result).toBeInstanceOf(Promise);
+    });
+});

package/dist/esm/index.js

@@ -1,3 +1,5 @@
-export { markupFetcher } from "./markupFetcher";
-export { reAppendMarkup } from "./utils";
+import path from "path";
+export const TEMP_DIRECTORY = path.join(process.cwd(), "_temp_jc");
+export { markupFetcher, fetchAll } from "./markupFetcher";
+export { reAppendMarkup, deleteTempDirectory } from "./utils";
 export { log, logError } from "./log";

package/dist/esm/markupFetcher.js

@@ -1,37 +1,93 @@
 import { injectSchema } from "./injectSchema";
-import { getEnvironment, isValidTimezone, parseJson } from "./utils";
-export const markupFetcher = (platform, fetchImplementation = fetch) => {
-    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
-        const trimmedTimezone = tz?.trim();
-        if (trimmedTimezone && !isValidTimezone(trimmedTimezone)) {
-            throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
-        }
-        const params = new URLSearchParams({
-            path: path || "/",
-            domain,
-        });
-        if (trimmedTimezone) {
-            params.set("tz", trimmedTimezone);
-        }
-        if (environment !== "production") {
-            params.set("stub", "true");
-        }
-        const requestUrl = `${baseUrl}/api/v3/markup?${params}`;
-        const response = await fetchImplementation(requestUrl, {
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                Accept: "application/json",
-                "X-Platform": platform,
-            },
-        });
-        if (response.status === 401) {
-            throw new Error(`Unauthorized! Are your domain and JamComments API key set correctly?`);
-        }
-        if (!response.ok) {
-            throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
+import { createTempDirectory, deleteTempDirectory, getEnvironment, isValidTimezone, parseJson, readFile, saveFile, } from "./utils";
+export async function fetchAll({ tz = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }, platform, fetchImplementation, batchMarkupFetcherImpl = batchMarkupFetcher) {
+    const fetchBatchMarkup = batchMarkupFetcherImpl(platform, fetchImplementation);
+    createTempDirectory();
+    let shouldKeepFetching = true;
+    let page = 1;
+    console.log("Fetching comments from JamComments! This might take a sec.");
+    try {
+        while (shouldKeepFetching) {
+            const { data: items, meta: { current_page, last_page }, } = await fetchBatchMarkup({
+                domain,
+                apiKey,
+                baseUrl,
+                environment,
+                page,
+                tz,
+            });
+            console.log(`Checking for comment data. Batch: ${current_page}/${last_page}`);
+            const saveMarkupPromises = items.map((item) => {
+                return saveFile(item.path, item.markup);
+            });
+            await Promise.all(saveMarkupPromises);
+            if (current_page === last_page) {
+                shouldKeepFetching = false;
+            }
+            else {
+                page++;
+            }
         }
-        const markup = await response.text();
+    }
+    catch (error) {
+        deleteTempDirectory();
+        throw error;
+    }
+}
+export function batchMarkupFetcher(platform, fetchImplementation = fetch) {
+    return async ({ tz = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), page = 1, }) => {
+        const response = await makeMarkupRequest({ tz, domain, apiKey, baseUrl, environment, page }, "/api/v3/markup/all", fetchImplementation, platform);
+        return response.json();
+    };
+}
+export async function fetchFreshMarkup({ tz = undefined, path, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }, fetchImplementation = fetch, platform) {
+    const response = await makeMarkupRequest({ tz, path, domain, apiKey, baseUrl, environment }, "/api/v3/markup", fetchImplementation, platform);
+    return response.text();
+}
+export async function makeMarkupRequest({ tz = undefined, path = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), page = undefined, }, baseServicePath, fetchImplementation = fetch, platform) {
+    const trimmedTimezone = tz?.trim();
+    if (trimmedTimezone && !isValidTimezone(trimmedTimezone)) {
+        throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
+    }
+    const params = new URLSearchParams({
+        domain,
+    });
+    if (path) {
+        params.set("path", path);
+    }
+    if (page) {
+        params.set("page", page.toString());
+    }
+    if (trimmedTimezone) {
+        params.set("tz", trimmedTimezone);
+    }
+    if (environment !== "production") {
+        params.set("stub", "true");
+    }
+    const requestUrl = `${baseUrl}${baseServicePath}?${params}`;
+    const response = await fetchImplementation(requestUrl, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+            "X-Platform": platform,
+        },
+    });
+    if (response.status === 401) {
+        throw new Error(`Unauthorized! Are your domain and JamComments API key set correctly?`);
+    }
+    if (!response.ok) {
+        throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
+    }
+    return response;
+}
+export function markupFetcher(platform, fetchImplementation = fetch) {
+    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
+        path = path || "/";
+        const savedFile = readFile(path);
+        const markup = savedFile
+            ? savedFile
+            : await fetchFreshMarkup({ tz, path, domain, apiKey, baseUrl, environment }, fetchImplementation, platform);
         if (schema) {
             const preparedSchema = typeof schema !== "string" ? JSON.stringify(schema) : schema;
             const parsedSchema = parseJson(preparedSchema);
@@ -42,4 +98,4 @@ export const markupFetcher = (platform, fetchImplementation = fetch) => {
         }
         return markup;
     };
-};
+}

package/dist/esm/markupFetcher.test.js

@@ -1,6 +1,201 @@
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import * as injectSchema from "./injectSchema";
-import { markupFetcher } from "./markupFetcher";
+import * as fetcherExports from "./markupFetcher";
+import { afterEach } from "node:test";
+import * as utilsExports from "./utils";
+const { deleteTempDirectory } = utilsExports;
+const { markupFetcher, batchMarkupFetcher } = fetcherExports;
+beforeEach(() => {
+    deleteTempDirectory();
+});
+afterEach(() => {
+    vi.resetAllMocks();
+});
+describe("fetchAll()", () => {
+    it("fetches all comments in a single request", async () => {
+        const saveFileSpy = vi.spyOn(utilsExports, "saveFile");
+        const mockBatchFetcher = vi.fn().mockReturnValue({
+            data: [
+                { path: "/test", markup: "markup1" },
+                { path: "/test2", markup: "markup2" },
+            ],
+            meta: {
+                current_page: 1,
+                from: 1,
+                last_page: 1,
+                path: "/test",
+                per_page: 10,
+                to: 2,
+                total: 2,
+            },
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        await fetcherExports.fetchAll({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        expect(batchMarkupFetcherMock).toHaveBeenCalledWith("test_platform", expect.anything());
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 1,
+            tz: undefined,
+        });
+        expect(saveFileSpy).toHaveBeenCalledTimes(2);
+        expect(saveFileSpy).toHaveBeenCalledWith("/test", "markup1");
+        expect(saveFileSpy).toHaveBeenCalledWith("/test2", "markup2");
+    });
+    it("fetches all comments in multiple requests", async () => {
+        const saveFileSpy = vi.spyOn(utilsExports, "saveFile");
+        const mockBatchFetcher = vi
+            .fn()
+            .mockReturnValueOnce({
+            data: [
+                { path: "/test", markup: "markup1" },
+                { path: "/test2", markup: "markup2" },
+            ],
+            meta: {
+                current_page: 1,
+                from: 1,
+                last_page: 2,
+                path: "/test",
+                per_page: 2,
+                to: 2,
+            },
+        })
+            .mockReturnValueOnce({
+            data: [
+                { path: "/test3", markup: "markup3" },
+                { path: "/test4", markup: "markup4" },
+            ],
+            meta: {
+                current_page: 2,
+                from: 3,
+                last_page: 2,
+                path: "/test",
+                per_page: 2,
+                to: 4,
+            },
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        await fetcherExports.fetchAll({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        expect(batchMarkupFetcherMock).toHaveBeenCalledWith("test_platform", expect.anything());
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 1,
+            tz: undefined,
+        });
+        expect(mockBatchFetcher).toHaveBeenCalledTimes(2);
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 2,
+            tz: undefined,
+        });
+        expect(saveFileSpy).toHaveBeenCalledTimes(4);
+        expect(saveFileSpy).toHaveBeenCalledWith("/test", "markup1");
+        expect(saveFileSpy).toHaveBeenCalledWith("/test2", "markup2");
+    });
+    it("deletes the temp directory of anything fails", async () => {
+        const deleteTempDirectorySpy = vi.spyOn(utilsExports, "deleteTempDirectory");
+        const mockBatchFetcher = vi.fn().mockImplementation(() => {
+            throw new Error("test error");
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        try {
+            await fetcherExports.fetchAll({
+                domain: "test.com",
+                apiKey: "123abc",
+                environment: "production",
+            }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        }
+        catch (e) {
+            expect(e.message).toEqual("test error");
+        }
+        expect(deleteTempDirectorySpy).toHaveBeenCalledOnce();
+    });
+});
+describe("batchMarkupFetcher", () => {
+    it("constructs fetch request correctly", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        });
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup/all?domain=test.com&page=1", expect.objectContaining({
+            headers: expect.objectContaining({
+                Accept: "application/json",
+                Authorization: "Bearer 123abc",
+                "X-Platform": "test",
+            }),
+            method: "GET",
+        }));
+        expect(result).toEqual("results!");
+    });
+    it("stubs comments", async () => {
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "development",
+        });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup/all?domain=test.com&page=1&stub=true", expect.anything());
+        expect(result).toEqual("results!");
+    });
+    it("uses different base URL", async () => {
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "http://ur-mom.com",
+            environment: "production",
+        });
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup/all?domain=test.com&page=1", expect.anything());
+        expect(result).toEqual("results!");
+    });
+});
 describe("markupFetcher", () => {
     it("constructs fetch request correctly", async () => {
         const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
@@ -19,7 +214,7 @@ describe("markupFetcher", () => {
             environment: "production",
         });
         expect(injectSchemaSpy).not.toHaveBeenCalled();
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.objectContaining({
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.objectContaining({
             headers: expect.objectContaining({
                 Accept: "application/json",
                 Authorization: "Bearer 123abc",
@@ -44,7 +239,7 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "development",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com&stub=true", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest&stub=true", expect.anything());
         expect(result).toEqual("results!");
     });
     it("uses different base URL", async () => {
@@ -63,7 +258,7 @@ describe("markupFetcher", () => {
             baseUrl: "http://ur-mom.com",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("respects production!!!", async () => {
@@ -82,7 +277,7 @@ describe("markupFetcher", () => {
             baseUrl: "http://ur-mom.com",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("falls back to root path", async () => {
@@ -100,7 +295,7 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2F", expect.anything());
         expect(result).toEqual("results!");
     });
     it("credentials are invalid", async () => {
@@ -135,9 +330,9 @@ describe("markupFetcher", () => {
     });
     describe("timezone validation", () => {
         it("throws error when invalid timezone is provided", async () => {
-            const fetchMock = vi.fn();
-            const fetcher = markupFetcher("test", fetchMock);
-            expect(fetchMock).not.toHaveBeenCalled();
+            const fetchImplMock = vi.fn();
+            const fetcher = markupFetcher("test", fetchImplMock);
+            expect(fetchImplMock).not.toHaveBeenCalled();
             expect(fetcher({
                 path: "/test",
                 domain: "test.com",
@@ -156,13 +351,13 @@ describe("markupFetcher", () => {
             });
             const fetcher = markupFetcher("test", fetchMock);
             const result = await fetcher({
-                path: null,
+                path: "/some/path",
                 domain: "test.com",
                 apiKey: "123abc",
                 tz: "America/New_York",
                 environment: "production",
             });
-            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com&tz=America%2FNew_York", expect.anything());
+            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Fsome%2Fpath&tz=America%2FNew_York", expect.anything());
             expect(result).toEqual("results!");
         });
         it("trims a valid timezone", async () => {
@@ -175,13 +370,13 @@ describe("markupFetcher", () => {
             });
             const fetcher = markupFetcher("test", fetchMock);
             const result = await fetcher({
-                path: null,
+                path: "/some/path",
                 domain: "test.com",
                 apiKey: "123abc",
                 tz: "   America/Chicago   ",
                 environment: "production",
             });
-            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com&tz=America%2FChicago", expect.anything());
+            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Fsome%2Fpath&tz=America%2FChicago", expect.anything());
             expect(result).toEqual("results!");
         });
     });
@@ -205,7 +400,7 @@ describe("passing schema", function () {
             environment: "production",
         });
         expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("does not stringify schema if given a string", async () => {
@@ -226,7 +421,7 @@ describe("passing schema", function () {
             environment: "production",
         });
         expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("returns markup if invalid json is provided", async () => {
@@ -247,7 +442,7 @@ describe("passing schema", function () {
             environment: "production",
         });
         expect(injectSchemaSpy).not.toHaveBeenCalled();
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
 });

package/dist/esm/utils.js

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, readFileSync, rmdirSync, writeFile } from "fs";
+import { TEMP_DIRECTORY } from ".";
 export function isValidTimezone(tz) {
     try {
         Intl.DateTimeFormat(undefined, { timeZone: tz });
@@ -30,21 +32,21 @@ export function parseJson(json) {
         return null;
     }
 }
-var htmlEntities = {
-    nbsp: " ",
-    cent: "¢",
-    pound: "£",
-    yen: "¥",
-    euro: "€",
-    copy: "©",
-    reg: "®",
-    lt: "<",
-    gt: ">",
-    quot: '"',
-    amp: "&",
-    apos: "'",
-};
 export function unescapeHTML(str) {
+    var htmlEntities = {
+        nbsp: " ",
+        cent: "¢",
+        pound: "£",
+        yen: "¥",
+        euro: "€",
+        copy: "©",
+        reg: "®",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        amp: "&",
+        apos: "'",
+    };
     return str.replace(/\&([^;]+);/g, function (entity, entityCode) {
         var match;
         if (entityCode in htmlEntities) {
@@ -61,3 +63,33 @@ export function unescapeHTML(str) {
         }
     });
 }
+export function deleteTempDirectory() {
+    if (existsSync(TEMP_DIRECTORY)) {
+        rmdirSync(TEMP_DIRECTORY, { recursive: true });
+    }
+}
+export function createTempDirectory(mkdirSyncImpl = mkdirSync, existsSyncImpl = existsSync) {
+    if (!existsSyncImpl(TEMP_DIRECTORY)) {
+        mkdirSyncImpl(TEMP_DIRECTORY);
+    }
+}
+export function toSavedFileName(name) {
+    return name.replace(/^\//, "").replace(/\//g, "::");
+}
+export function readFile(name, readFileSyncImpl = readFileSync) {
+    const fileName = toSavedFileName(name);
+    try {
+        return readFileSyncImpl(`${TEMP_DIRECTORY}/${fileName}`, "utf8");
+    }
+    catch (error) {
+        return null;
+    }
+}
+export function saveFile(name, data, writeFileImpl = writeFile) {
+    const fileName = toSavedFileName(name);
+    return new Promise((resolve) => {
+        writeFileImpl(`${TEMP_DIRECTORY}/${fileName}`, data, () => {
+            resolve();
+        });
+    });
+}

package/dist/esm/utils.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { getEnvironment } from "./utils";
+import { getEnvironment, createTempDirectory, toSavedFileName, readFile, saveFile, } from "./utils";
+import { TEMP_DIRECTORY } from ".";
 const env = process.env;
 beforeEach(() => {
     vi.resetModules();
@@ -42,3 +43,45 @@ describe("getEnvironment()", () => {
         });
     });
 });
+describe("createTempDirectory()", () => {
+    it("creates temp directory fresh", () => {
+        const mkdirSyncMock = vi.fn();
+        const existsSyncMock = vi.fn().mockReturnValue(false);
+        expect(() => createTempDirectory(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        expect(mkdirSyncMock).toHaveBeenCalledWith(TEMP_DIRECTORY);
+    });
+    it("does not throw error when it already exists", () => {
+        const mkdirSyncMock = vi.fn().mockImplementation(() => {
+            throw new Error("Directory already exists");
+        });
+        const existsSyncMock = vi.fn().mockReturnValue(true);
+        expect(() => createTempDirectory(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        expect(mkdirSyncMock).not.toHaveBeenCalledWith();
+    });
+});
+describe("toSavedFileName()", () => {
+    it("replaces slashes with double colons", () => {
+        expect(toSavedFileName("/hey/there")).toEqual("hey::there");
+    });
+});
+describe("readFile()", () => {
+    it("reads the file", () => {
+        const readFileSyncMock = vi.fn().mockReturnValue("file contents");
+        expect(readFile("hey/there", readFileSyncMock)).toEqual("file contents");
+        expect(readFileSyncMock).toHaveBeenCalledWith(`${TEMP_DIRECTORY}/hey::there`, "utf8");
+    });
+    it("returns null when file doesn't exist", () => {
+        const readFileSyncMock = vi.fn().mockImplementation(() => {
+            throw new Error("File not found");
+        });
+        expect(readFile("hey/there", readFileSyncMock)).toEqual(null);
+    });
+});
+describe("saveFile()", () => {
+    it("saves the file", async () => {
+        const writeFileMock = vi.fn();
+        const result = saveFile("hey/there", "file contents", writeFileMock);
+        expect(writeFileMock).toHaveBeenCalledWith(`${TEMP_DIRECTORY}/hey::there`, "file contents", expect.any(Function));
+        expect(result).toBeInstanceOf(Promise);
+    });
+});

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
-export { markupFetcher } from "./markupFetcher";
-export { reAppendMarkup } from "./utils";
+export declare const TEMP_DIRECTORY: string;
+export { markupFetcher, fetchAll } from "./markupFetcher";
+export { reAppendMarkup, deleteTempDirectory } from "./utils";
 export { log, logError } from "./log";