rwsdk 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/lib/getShortName.mjs

@@ -1,2 +1,7 @@
 import { relative } from "node:path";
-export const getShortName = (file, root) => file.startsWith(root) ? relative(root, file) : file;
+import path from "node:path";
+export const getShortName = (file, root) => file === root
+    ? ""
+    : file.startsWith(root + path.sep)
+        ? relative(root, file)
+        : file;

package/dist/lib/getShortName.test.mjs

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { getShortName } from "./getShortName.mjs";
+import path from "node:path";
+describe("getShortName", () => {
+    it("should return the relative path if the file is inside the root", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join(root, "src", "index.ts");
+        expect(getShortName(file, root)).toBe(path.join("src", "index.ts"));
+    });
+    it("should return the original path if the file is outside the root", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "another", "project", "src", "index.ts");
+        expect(getShortName(file, root)).toBe(file);
+    });
+    it("should return an empty string if the paths are identical", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "project");
+        expect(getShortName(file, root)).toBe("");
+    });
+    it("should handle paths that are substrings of each other correctly", () => {
+        const root = path.join("/Users", "test", "project");
+        const file = path.join("/Users", "test", "project-longer", "src", "index.ts");
+        expect(getShortName(file, root)).toBe(file);
+    });
+});

package/dist/lib/hasPkgScript.d.mts

@@ -1 +1,4 @@
-export declare const hasPkgScript: (projectRootDir: string, script: string) => Promise<any>;
+import { readFile as fsReadFile } from "fs/promises";
+export declare let _pkgCache: Record<string, any> | undefined;
+export declare const hasPkgScript: (projectRootDir: string, script: string, readFile?: typeof fsReadFile) => Promise<any>;
+export declare const _resetPkgCache: () => void;

package/dist/lib/hasPkgScript.mjs

@@ -1,9 +1,12 @@
-import { readFile } from "fs/promises";
+import { readFile as fsReadFile } from "fs/promises";
 import { resolve } from "path";
-let pkg;
-export const hasPkgScript = async (projectRootDir, script) => {
-    if (!pkg) {
-        pkg = JSON.parse(await readFile(resolve(projectRootDir, "package.json"), "utf-8"));
+export let _pkgCache;
+export const hasPkgScript = async (projectRootDir, script, readFile = fsReadFile) => {
+    if (!_pkgCache) {
+        _pkgCache = JSON.parse((await readFile(resolve(projectRootDir, "package.json"))).toString());
     }
-    return pkg.scripts?.[script];
+    return _pkgCache?.scripts?.[script];
+};
+export const _resetPkgCache = () => {
+    _pkgCache = undefined;
 };

package/dist/lib/hasPkgScript.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/lib/hasPkgScript.test.mjs

@@ -0,0 +1,33 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { hasPkgScript, _resetPkgCache } from "./hasPkgScript.mjs";
+// Manually reset the cache before each test
+beforeEach(() => {
+    _resetPkgCache();
+});
+describe("hasPkgScript", () => {
+    it("should return the script if it exists", async () => {
+        const fakeReadFile = async () => JSON.stringify({ scripts: { "dev:init": "command" } });
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBe("command");
+    });
+    it("should return undefined if the script does not exist", async () => {
+        const fakeReadFile = async () => JSON.stringify({ scripts: { test: "command" } });
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBeUndefined();
+    });
+    it("should return undefined if scripts block does not exist", async () => {
+        const fakeReadFile = async () => JSON.stringify({});
+        const result = await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(result).toBeUndefined();
+    });
+    it("should cache the package.json read", async () => {
+        let readCount = 0;
+        const fakeReadFile = async () => {
+            readCount++;
+            return JSON.stringify({ scripts: { "dev:init": "command" } });
+        };
+        await hasPkgScript("/test", "dev:init", fakeReadFile);
+        await hasPkgScript("/test", "dev:init", fakeReadFile);
+        expect(readCount).toBe(1);
+    });
+});

package/dist/lib/jsonUtils.mjs

@@ -158,6 +158,9 @@ export function parseJson(input, defaultValue, findUuid = false) {
                 }
             }
         }
+        if (lastJson !== null) {
+            return lastJson;
+        }
         return defaultValue;
     }
     catch (error) {

package/dist/lib/jsonUtils.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/lib/jsonUtils.test.mjs

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { extractLastJson, extractAllJson, parseJson } from "./jsonUtils.mjs";
+describe("jsonUtils", () => {
+    describe("extractLastJson", () => {
+        it("should extract the last JSON object from a string", () => {
+            const output = 'some text {"a":1} some other text {"b":2, "c": {"d": 3}} end';
+            expect(extractLastJson(output)).toEqual({ b: 2, c: { d: 3 } });
+        });
+        it("should extract the last JSON array from a string", () => {
+            const output = "start [1, 2] middle [3, 4, [5]] end";
+            expect(extractLastJson(output)).toEqual([3, 4, [5]]);
+        });
+        it("should return the object if the string is just JSON", () => {
+            const output = '{"a":1}';
+            expect(extractLastJson(output)).toEqual({ a: 1 });
+        });
+        it("should handle nested structures correctly", () => {
+            const output = '{"a":{"b":{"c":"d"}}}';
+            expect(extractLastJson(output)).toEqual({ a: { b: { c: "d" } } });
+        });
+        it("should return null if no valid JSON is found", () => {
+            const output = "this is just some text without json";
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should return null for malformed JSON", () => {
+            const output = '{"a":1, "b":}';
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should handle undefined and empty string input", () => {
+            expect(extractLastJson(undefined)).toBeNull();
+            expect(extractLastJson("")).toBeNull();
+        });
+    });
+    describe("extractAllJson", () => {
+        it("should extract all JSON objects from a string", () => {
+            const output = '{"a":1} some text {"b":2} and then {"c":3, "d": [4]}';
+            expect(extractAllJson(output)).toEqual([
+                { a: 1 },
+                { b: 2 },
+                { c: 3, d: [4] },
+            ]);
+        });
+        it("should extract all JSON arrays from a string", () => {
+            const output = "[1,2] then [3,4]";
+            expect(extractAllJson(output)).toEqual([
+                [1, 2],
+                [3, 4],
+            ]);
+        });
+        it("should handle a mix of objects and arrays", () => {
+            const output = '{"a":1} [2,3] {"b":4}';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [2, 3], { b: 4 }]);
+        });
+        it("should return an empty array if no JSON is found", () => {
+            const output = "no json here";
+            expect(extractAllJson(output)).toEqual([]);
+        });
+        it("should ignore malformed JSON", () => {
+            const output = '{"a":1} {"b":2,} [3,4]';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [3, 4]]);
+        });
+    });
+    describe("parseJson", () => {
+        it("should parse the last JSON object by default", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {})).toEqual({ b: 2 });
+        });
+        it("should return the default value if no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true })).toEqual({ default: true });
+        });
+        it("should find an object with a uuid property when requested", () => {
+            const output = '{"a":1} {"uuid":"123-abc", "data": "yes"} {"c":3}';
+            expect(parseJson(output, {}, true)).toEqual({
+                uuid: "123-abc",
+                data: "yes",
+            });
+        });
+        it("should return the last object if findUuid is true but no object with uuid is found", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {}, true)).toEqual({ b: 2 });
+        });
+        it("should return the default value if findUuid is true and no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true }, true)).toEqual({
+                default: true,
+            });
+        });
+    });
+});

package/dist/lib/normalizeModulePath.d.mts

@@ -1,3 +1,8 @@
+/**
+ * Find the number of common ancestor segments between two absolute paths.
+ * Returns the count of shared directory segments from the root.
+ */
+export declare function findCommonAncestorDepth(path1: string, path2: string): number;
 /**
  * Normalize a module path to a consistent form.
  * Returns slash-prefixed paths for files within project root,

package/dist/lib/normalizeModulePath.mjs

@@ -4,7 +4,7 @@ import { normalizePath as normalizePathSeparators } from "vite";
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
  */
-function findCommonAncestorDepth(path1, path2) {
+export function findCommonAncestorDepth(path1, path2) {
     const segments1 = path1.split("/").filter(Boolean);
     const segments2 = path2.split("/").filter(Boolean);
     let commonLength = 0;

package/dist/lib/normalizeModulePath.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/lib/{normalizeModulePath.test.js → normalizeModulePath.test.mjs}

@@ -1,5 +1,24 @@
 import { describe, it, expect } from "vitest";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { normalizeModulePath, findCommonAncestorDepth, } from "./normalizeModulePath.mjs";
+describe("findCommonAncestorDepth", () => {
+    it("should return the correct depth for common paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/d")).toBe(2);
+    });
+    it("should return 0 for completely different paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/d/e/f")).toBe(0);
+    });
+    it("should handle identical paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c")).toBe(3);
+    });
+    it("should handle paths of different lengths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c/d/e")).toBe(3);
+    });
+    it("should handle the root path", () => {
+        expect(findCommonAncestorDepth("/", "/a/b")).toBe(0);
+        expect(findCommonAncestorDepth("/a", "/")).toBe(0);
+        expect(findCommonAncestorDepth("/", "/")).toBe(0);
+    });
+});
 describe("normalizeModulePath", () => {
     describe("1. Project-local paths", () => {
         it("Relative file", () => {

package/dist/runtime/lib/memoizeOnId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/memoizeOnId.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from "vitest";
+import { memoizeOnId } from "./memoizeOnId";
+describe("memoizeOnId", () => {
+    it("should call the function only once for the same id", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("a");
+        const result2 = memoizedFn("a");
+        expect(result1).toBe("result-a");
+        expect(result2).toBe("result-a");
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith("a");
+    });
+    it("should call the function again for a different id", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("a");
+        const result2 = memoizedFn("b");
+        expect(result1).toBe("result-a");
+        expect(result2).toBe("result-b");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(fn).toHaveBeenCalledWith("a");
+        expect(fn).toHaveBeenCalledWith("b");
+    });
+    it("should return the correct cached value for multiple calls", () => {
+        const fn = vi.fn((id) => ({ id }));
+        const memoizedFn = memoizeOnId(fn);
+        const resultA1 = memoizedFn("a");
+        const resultB1 = memoizedFn("b");
+        const resultA2 = memoizedFn("a");
+        expect(resultA1).toEqual({ id: "a" });
+        expect(resultB1).toEqual({ id: "b" });
+        expect(resultA2).toBe(resultA1); // Should be the same object reference
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    it("should handle object properties that exist on Object.prototype", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("constructor");
+        const result2 = memoizedFn("toString");
+        const result3 = memoizedFn("constructor");
+        expect(result1).toBe("result-constructor");
+        expect(result2).toBe("result-toString");
+        expect(result3).toBe("result-constructor");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(fn).toHaveBeenCalledWith("constructor");
+        expect(fn).toHaveBeenCalledWith("toString");
+    });
+});

package/dist/runtime/lib/realtime/protocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/realtime/protocol.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect } from "vitest";
+import { packMessage, unpackMessage } from "./protocol";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Protocol pack/unpack", () => {
+    const textEncoder = new TextEncoder();
+    // Helper to generate a UUID string of the correct length
+    const generateId = () => "a".repeat(36);
+    const testMessages = [
+        {
+            type: MESSAGE_TYPE.ACTION_REQUEST,
+            id: "my-action",
+            args: { foo: "bar" },
+            requestId: generateId(),
+            clientUrl: "http://localhost:3000/",
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("chunk data"),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_END,
+            id: generateId(),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_ERROR,
+            id: generateId(),
+            error: "Something went wrong",
+        },
+        {
+            type: MESSAGE_TYPE.RSC_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.RSC_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("rsc chunk"),
+        },
+        {
+            type: MESSAGE_TYPE.RSC_END,
+            id: generateId(),
+        },
+    ];
+    testMessages.forEach((message) => {
+        it(`should correctly pack and unpack a ${Object.keys(MESSAGE_TYPE).find((key) => MESSAGE_TYPE[key] === message.type) || "UNKNOWN"} message`, () => {
+            const packed = packMessage(message);
+            const unpacked = unpackMessage(packed);
+            expect(unpacked).toEqual(message);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should throw an error for an unknown message type on pack", () => {
+            const invalidMessage = { type: 999 };
+            expect(() => packMessage(invalidMessage)).toThrow("Unknown message type for packing");
+        });
+        it("should throw an error for an unknown message type on unpack", () => {
+            const invalidData = new Uint8Array([99, 1, 2, 3]);
+            expect(() => unpackMessage(invalidData)).toThrow("Unknown message type for unpacking: 99");
+        });
+        it("should throw an error for an empty message on unpack", () => {
+            const emptyData = new Uint8Array([]);
+            expect(() => unpackMessage(emptyData)).toThrow("Cannot unpack empty message");
+        });
+        const invalidLengthTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidLengthTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ${name} message length on unpack`, () => {
+                const invalidData = new Uint8Array([type, 1, 2, 3]); // Too short
+                expect(() => unpackMessage(invalidData)).toThrow(`Invalid ${name} message length`);
+            });
+        });
+        const invalidIdTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidIdTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ID length on ${name} message pack`, () => {
+                const message = {
+                    type,
+                    id: "short-id",
+                    status: 200, // For START types
+                    payload: new Uint8Array(), // For CHUNK types
+                    error: "", // For ERROR type
+                };
+                expect(() => packMessage(message)).toThrow(`Invalid message ID length for ${name} message`);
+            });
+        });
+    });
+});

package/dist/runtime/lib/realtime/shared.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/realtime/shared.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Shared Constants", () => {
+    it("MESSAGE_TYPE should match snapshot", () => {
+        expect(MESSAGE_TYPE).toMatchInlineSnapshot(`
+      {
+        "ACTION_CHUNK": 5,
+        "ACTION_END": 6,
+        "ACTION_ERROR": 7,
+        "ACTION_REQUEST": 3,
+        "ACTION_START": 4,
+        "RSC_CHUNK": 1,
+        "RSC_END": 2,
+        "RSC_START": 0,
+      }
+    `);
+    });
+});

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
+describe("validateUpgradeRequest", () => {
+    it("should return valid for a correct WebSocket upgrade request", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(true);
+    });
+    it("should return invalid if Upgrade header is not 'websocket'", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "not-websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+            await expect(result.response?.text()).resolves.toBe("Expected WebSocket");
+        }
+    });
+    it("should return invalid if Upgrade header is missing", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+        }
+    });
+    it("should return invalid if Origin header is missing", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+            await expect(result.response?.text()).resolves.toBe("Invalid origin");
+        }
+    });
+    it("should return invalid if Origin does not match request URL", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://another-domain.com",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+        }
+    });
+});

package/dist/runtime/lib/router.test.js

@@ -22,7 +22,7 @@ describe("matchPath", () => {
         expect(matchPath("/files/*/", "/files/document.pdf/")).toEqual({
             $0: "document.pdf",
         });
-        expect(matchPath("/data/*\/content/", "/data/archive/content/")).toEqual({
+        expect(matchPath("/data/*/content/", "/data/archive/content/")).toEqual({
             $0: "archive",
         });
         expect(matchPath("/assets/*/*/", "/assets/images/pic.png/")).toEqual({

package/dist/runtime/lib/turnstile/verifyTurnstileToken.d.ts

@@ -1,4 +1,5 @@
-export declare const verifyTurnstileToken: ({ token, secretKey, }: {
+export declare const verifyTurnstileToken: ({ token, secretKey, fetchFn, }: {
     token: string;
     secretKey: string;
+    fetchFn?: typeof fetch;
 }) => Promise<boolean>;

package/dist/runtime/lib/turnstile/verifyTurnstileToken.js

@@ -1,10 +1,10 @@
-export const verifyTurnstileToken = async ({ token, secretKey, }) => {
-    const response = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({ secret: secretKey, response: token }),
-    });
+export const verifyTurnstileToken = async ({ token, secretKey, fetchFn = fetch, }) => {
     try {
+        const response = await fetchFn("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ secret: secretKey, response: token }),
+        });
         const data = (await response.json());
         return data?.success === true;
     }

package/dist/runtime/lib/turnstile/verifyTurnstileToken.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/turnstile/verifyTurnstileToken.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from "vitest";
+import { verifyTurnstileToken } from "./verifyTurnstileToken";
+describe("verifyTurnstileToken", () => {
+    it("should return true for a successful verification", async () => {
+        const mockFetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ success: true }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        }));
+        const result = await verifyTurnstileToken({
+            token: "valid-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(true);
+        expect(mockFetch).toHaveBeenCalledWith("https://challenges.cloudflare.com/turnstile/v0/siteverify", expect.any(Object));
+    });
+    it("should return false for a failed verification", async () => {
+        const mockFetch = vi.fn().mockResolvedValue(new Response(JSON.stringify({ success: false }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        }));
+        const result = await verifyTurnstileToken({
+            token: "invalid-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false if the fetch call fails", async () => {
+        const mockFetch = vi.fn().mockRejectedValue(new Error("Network error"));
+        const result = await verifyTurnstileToken({
+            token: "any-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+    it("should return false for a non-JSON response", async () => {
+        const mockFetch = vi
+            .fn()
+            .mockResolvedValue(new Response("not json", { status: 200 }));
+        const result = await verifyTurnstileToken({
+            token: "any-token",
+            secretKey: "secret",
+            fetchFn: mockFetch,
+        });
+        expect(result).toBe(false);
+    });
+});

package/dist/vite/checkIsUsingPrisma.d.mts

@@ -1,6 +1,10 @@
 export type PrismaCheckResult = {
     isUsingPrisma: boolean;
 };
+export declare const isUsingPrisma: ({ projectRootDir, resolver, }: {
+    projectRootDir: string;
+    resolver?: (path: string, request: string) => string | false;
+}) => boolean;
 export declare const checkPrismaStatus: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => PrismaCheckResult;

package/dist/vite/checkIsUsingPrisma.mjs

@@ -1,7 +1,7 @@
 import enhancedResolve from "enhanced-resolve";
-const isUsingPrisma = ({ projectRootDir }) => {
+export const isUsingPrisma = ({ projectRootDir, resolver = enhancedResolve.sync, }) => {
     try {
-        const prismaClientPath = enhancedResolve.sync(projectRootDir, "@prisma/client");
+        const prismaClientPath = resolver(projectRootDir, "@prisma/client");
         if (!prismaClientPath) {
             return false;
         }

package/dist/vite/checkIsUsingPrisma.test.d.mts

@@ -0,0 +1 @@
+export {};