@cloudflare/pages-shared 0.0.0-ship-js

package/dist/__tests__/asset-server/handler.test.js

@@ -0,0 +1,430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const handler_1 = require("../../asset-server/handler");
+const createMetadataObject_1 = require("../../metadata-generator/createMetadataObject");
+describe("asset-server handler", () => {
+    test("Returns appropriate status codes", async () => {
+        const statuses = [301, 302, 303, 307, 308];
+        const metadata = createMetadataObjectWithRedirects(statuses
+            .map((status) => ({
+            status,
+            from: `/${status}`,
+            to: "/home",
+        }))
+            .concat({
+            status: 302,
+            from: "/500",
+            to: "/home",
+        }));
+        const tests = statuses.map(async (status) => {
+            const { response } = await getTestResponse({
+                request: "https://foo.com/" + status,
+                metadata,
+            });
+            expect(response.status).toBe(status);
+            expect(response.headers.get("Location")).toBe("/home");
+        });
+        await Promise.all(tests);
+        const { response } = await getTestResponse({
+            request: "https://foo.com/500",
+            metadata,
+        });
+        expect(response.status).toBe(302);
+        expect(response.headers.get("Location")).toBe("/home");
+    });
+    test("Won't redirect to protocol-less double-slashed URLs", async () => {
+        const metadata = createMetadataObjectWithRedirects([
+            { from: "/", to: "/home", status: 301 },
+            { from: "/page.html", to: "/elsewhere", status: 301 },
+        ]);
+        const findAssetEntryForPath = async (path) => {
+            if (path === "/index.html") {
+                return "index page";
+            }
+            if (path === "/page.html") {
+                return "some page";
+            }
+            return null;
+        };
+        {
+            const { response } = await getTestResponse({
+                request: "/%2Fwww.example.com/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/%5Cwww.example.com/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/%2Fwww.example.com/%2F/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com///");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/%5Cwww.example.com/%5C/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com/\\/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/%2fwww.example.com/%2f/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com///");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/%5cwww.example.com/%5c/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/www.example.com/\\/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/foo/index/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/foo/");
+        }
+    });
+    test("Match exact pathnames, before any HTML redirection", async () => {
+        const metadata = createMetadataObjectWithRedirects([
+            { from: "/", to: "/home", status: 301 },
+            { from: "/page.html", to: "/elsewhere", status: 301 },
+            { from: "/protocol-less-test", to: "/%2fwww.example.com/", status: 308 },
+        ]);
+        const findAssetEntryForPath = async (path) => {
+            if (path === "/index.html") {
+                return "index page";
+            }
+            if (path === "/page.html") {
+                return "some page";
+            }
+            return null;
+        };
+        {
+            const { response } = await getTestResponse({
+                request: "/index.html",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/index",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/home");
+        }
+        {
+            // The redirect rule takes precedence to the 308s
+            const { response } = await getTestResponse({
+                request: "/page.html",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/elsewhere");
+        }
+        {
+            // The redirect rule takes precedence to the 308s
+            const { response } = await getTestResponse({
+                request: "/protocol-less-test",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(308);
+            expect(response.headers.get("Location")).toEqual("/%2fwww.example.com/");
+        }
+        {
+            // This serves the HTML even though the redirect rule is present
+            const { response, spies } = await getTestResponse({
+                request: "/page",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(200);
+            expect(spies.fetchAsset).toBe(1);
+        }
+    });
+    test("cross-host static redirects still are executed with line number precedence", async () => {
+        const metadata = createMetadataObjectWithRedirects([
+            { from: "https://fakehost/home", to: "https://firsthost/", status: 302 },
+            { from: "/home", to: "https://secondhost/", status: 302 },
+        ]);
+        const findAssetEntryForPath = async (path) => {
+            if (path === "/index.html") {
+                return "index page";
+            }
+            return null;
+        };
+        {
+            const { response } = await getTestResponse({
+                request: "https://yetanotherhost/home",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(302);
+            expect(response.headers.get("Location")).toEqual("https://secondhost/");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "https://fakehost/home",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(302);
+            expect(response.headers.get("Location")).toEqual("https://firsthost/");
+        }
+    });
+    test("it should preserve querystrings unless to rule includes them", async () => {
+        const metadata = createMetadataObjectWithRedirects([
+            { from: "/", status: 301, to: "/home" },
+            { from: "/recent", status: 301, to: "/home?sort=updated_at" },
+        ]);
+        const findAssetEntryForPath = async (path) => {
+            if (path === "/home.html") {
+                return "home page";
+            }
+            return null;
+        };
+        {
+            const { response } = await getTestResponse({
+                request: "/?sort=price",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/home?sort=price");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/recent",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/home?sort=updated_at");
+        }
+        {
+            const { response } = await getTestResponse({
+                request: "/recent?other=query",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/home?sort=updated_at");
+        }
+    });
+    {
+        const metadata = createMetadataObjectWithRedirects([
+            { from: "/home", status: 301, to: "/" },
+            { from: "/blog/*", status: 301, to: "https://blog.example.com/:splat" },
+            {
+                from: "/products/:code/:name/*",
+                status: 301,
+                to: "/products?junk=:splat&name=:name&code=:code",
+            },
+            { from: "/foo", status: 301, to: "/bar" },
+        ]);
+        const findAssetEntryForPath = async (path) => {
+            if (path === "/home.html") {
+                return "home page";
+            }
+            return null;
+        };
+        test("it should perform splat replacements", async () => {
+            const { response } = await getTestResponse({
+                request: "/blog/a-blog-posting",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("https://blog.example.com/a-blog-posting");
+        });
+        test("it should perform placeholder replacements", async () => {
+            const { response } = await getTestResponse({
+                request: "/products/abba_562/tricycle/123abc@~!",
+                metadata,
+                findAssetEntryForPath,
+            });
+            expect(response.status).toBe(301);
+            expect(response.headers.get("Location")).toEqual("/products?junk=123abc@~!&name=tricycle&code=abba_562");
+        });
+        test("it should redirect both dynamic and static redirects", async () => {
+            {
+                const { response } = await getTestResponse({
+                    request: "/home",
+                    metadata,
+                    findAssetEntryForPath,
+                });
+                expect(response.status).toBe(301);
+                expect(response.headers.get("Location")).toEqual("/");
+            }
+            {
+                const { response } = await getTestResponse({
+                    request: "/blog/post",
+                    metadata,
+                    findAssetEntryForPath,
+                });
+                expect(response.status).toBe(301);
+                expect(response.headers.get("Location")).toEqual("https://blog.example.com/post");
+            }
+            {
+                const { response } = await getTestResponse({
+                    request: "/foo",
+                    metadata,
+                    findAssetEntryForPath,
+                });
+                expect(response.status).toBe(301);
+                expect(response.headers.get("Location")).toEqual("/bar");
+            }
+        });
+    }
+    // test("Returns a redirect without duplicating the hash component", async () => {
+    // 	const { response, spies } = await getTestResponse({
+    // 		request: "https://foo.com/bar",
+    // 		metadata: createMetadataObjectWithRedirects([
+    // 			{ from: "/bar", to: "https://foobar.com/##heading-7", status: 301 },
+    // 		]),
+    // 	});
+    // 	expect(spies.fetchAsset).toBe(0);
+    // 	expect(spies.findAssetEntryForPath).toBe(0);
+    // 	expect(spies.getAssetKey).toBe(0);
+    // 	expect(spies.negotiateContent).toBe(0);
+    // 	expect(response.status).toBe(301);
+    // 	expect(response.headers.get("Location")).toBe(
+    // 		"https://foobar.com/##heading-7"
+    // 	);
+    // });
+    test("it should redirect uri-encoded paths", async () => {
+        const { response, spies } = await getTestResponse({
+            request: "https://foo.com/some%20page",
+            metadata: createMetadataObjectWithRedirects([
+                { from: "/some%20page", to: "/home", status: 301 },
+            ]),
+        });
+        expect(spies.fetchAsset).toBe(0);
+        expect(spies.findAssetEntryForPath).toBe(0);
+        expect(spies.getAssetKey).toBe(0);
+        expect(spies.negotiateContent).toBe(0);
+        expect(response.status).toBe(301);
+        expect(response.headers.get("Location")).toBe("/home");
+    });
+    // 	test("getResponseFromMatch - same origin paths specified as root-relative", () => {
+    // 		const res = getResponseFromMatch(
+    // 			{
+    // 				to: "/bar",
+    // 				status: 301,
+    // 			},
+    // 			new URL("https://example.com/foo")
+    // 		);
+    // 		expect(res.status).toBe(301);
+    // 		expect(res.headers.get("Location")).toBe("/bar");
+    // 	});
+    // 	test("getResponseFromMatch - same origin paths specified as full URLs", () => {
+    // 		const res = getResponseFromMatch(
+    // 			{
+    // 				to: "https://example.com/bar",
+    // 				status: 301,
+    // 			},
+    // 			new URL("https://example.com/foo")
+    // 		);
+    // 		expect(res.status).toBe(301);
+    // 		expect(res.headers.get("Location")).toBe("/bar");
+    // 	});
+    // });
+    // test("getResponseFromMatch - different origins", () => {
+    // 	const res = getResponseFromMatch(
+    // 		{
+    // 			to: "https://bar.com/bar",
+    // 			status: 302,
+    // 		},
+    // 		new URL("https://example.com/foo")
+    // 	);
+    // 	expect(res.status).toBe(302);
+    // 	expect(res.headers.get("Location")).toBe("https://bar.com/bar");
+});
+async function getTestResponse({ request, metadata = (0, createMetadataObject_1.createMetadataObject)({
+    redirects: {
+        invalid: [],
+        rules: [],
+    },
+}), ...options }) {
+    const spies = {
+        fetchAsset: 0,
+        findAssetEntryForPath: 0,
+        getAssetKey: 0,
+        negotiateContent: 0,
+    };
+    const response = await (0, handler_1.generateHandler)({
+        request: request instanceof Request ? request : new Request(request),
+        metadata,
+        xServerEnvHeader: "dev",
+        logError: console.error,
+        findAssetEntryForPath: async (...args) => {
+            spies.findAssetEntryForPath++;
+            return options.findAssetEntryForPath?.(...args) ?? null;
+        },
+        getAssetKey: (assetEntry, content) => {
+            spies.getAssetKey++;
+            return options.getAssetKey?.(assetEntry, content) ?? assetEntry;
+        },
+        negotiateContent: (...args) => {
+            spies.negotiateContent++;
+            return options.negotiateContent?.(...args) ?? { encoding: null };
+        },
+        fetchAsset: async (...args) => {
+            spies.fetchAsset++;
+            return (options.fetchAsset?.(...args) ?? {
+                body: null,
+                contentType: "text/plain",
+            });
+        },
+    });
+    return { response, spies };
+}
+function createMetadataObjectWithRedirects(rules) {
+    return (0, createMetadataObject_1.createMetadataObject)({
+        redirects: {
+            invalid: [],
+            rules: rules.map((rule, i) => ({ ...rule, lineNumber: i + 1 })),
+        },
+    });
+}

package/dist/__tests__/asset-server/responses.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=responses.test.d.ts.map

package/dist/__tests__/asset-server/responses.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.test.d.ts","sourceRoot":"","sources":["../../../__tests__/asset-server/responses.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-server/responses.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const responses_1 = require("../../asset-server/responses");
+describe("stripLeadingDoubleSlashes", () => {
+    it("strips extra leading `/`, `%2F` and `%2f`s", () => {
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/")).toMatchInlineSnapshot(`"/"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%2Ffoo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%2ffoo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%2F%2f/foo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%5Cfoo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%5cfoo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%5C%5c/foo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/%2f%5c/foo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/\\/foo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("%2ffoo")).toMatchInlineSnapshot(`"/foo"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/foo/%2f")).toMatchInlineSnapshot(`"/foo/%2f"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/foo/%2F")).toMatchInlineSnapshot(`"/foo/%2F"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/foo//")).toMatchInlineSnapshot(`"/foo//"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/foo//bar")).toMatchInlineSnapshot(`"/foo//bar"`);
+        expect((0, responses_1.stripLeadingDoubleSlashes)("/foo/\\/bar")).toMatchInlineSnapshot(`"/foo/\\\\/bar"`);
+    });
+});

package/dist/__tests__/asset-server/rulesEngine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rulesEngine.test.d.ts.map

package/dist/__tests__/asset-server/rulesEngine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulesEngine.test.d.ts","sourceRoot":"","sources":["../../../__tests__/asset-server/rulesEngine.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/asset-server/rulesEngine.test.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rulesEngine_1 = require("../..//asset-server/rulesEngine");
+describe("rules engine", () => {
+    test("it should match simple pathname hosts", () => {
+        const matcher = (0, rulesEngine_1.generateRulesMatcher)({ "/test": 1, "/some%20page": 2 });
+        expect(matcher({ request: new Request("/test") })).toEqual([1]);
+        expect(matcher({ request: new Request("/some page") })).toEqual([2]);
+    });
+    test("it should match cross-host requests", () => {
+        const matcher = (0, rulesEngine_1.generateRulesMatcher)({
+            "/test": 1,
+            "/anotherpage": 2,
+            "https://custom.domain/test": 3,
+            "https://another.domain/test": 4,
+            "//fake.host/actually-a-path": 5,
+        });
+        expect(matcher({ request: new Request("https://custom.domain/test") })).toEqual([1, 3]);
+        expect(matcher({
+            request: new Request("https://example.com//fake.host/actually-a-path"),
+        })).toEqual([5]);
+    });
+    test("it should escape funky rules", () => {
+        const matcher = (0, rulesEngine_1.generateRulesMatcher)({
+            "/$~.%20/!+-/[bo|%7Bo%7D]...()": 1,
+        });
+        expect(matcher({ request: new Request("/$~. \\!+-/[bo|{o}]...()") })).toEqual([1]);
+    });
+    test("it should support splats and placeholders", () => {
+        const matcher = (0, rulesEngine_1.generateRulesMatcher)({
+            "/foo/test/*": "1/:splat",
+            "/foo/*": "2/:splat",
+            "/blog/:code/:name": "3/:name/:code",
+            "/blog/*": "4/:splat",
+            "https://:subdomain.pages.:tld/*": "5/:subdomain/:tld/:splat",
+            "https://next.:subdomain.pages.:tld/*": "6/:subdomain/",
+        }, (match, replacements) => (0, rulesEngine_1.replacer)(match, replacements));
+        expect(matcher({ request: new Request("/foo/test/yes") })).toEqual([
+            "1/yes",
+            "2/test/yes",
+        ]);
+        expect(matcher({ request: new Request("/foo/test/") })).toEqual([
+            "1/",
+            "2/test/",
+        ]);
+        expect(matcher({ request: new Request("/foo/test") })).toEqual(["2/test"]);
+        expect(matcher({ request: new Request("/foo/") })).toEqual(["2/"]);
+        expect(matcher({ request: new Request("/foo") })).toEqual([]);
+        expect(matcher({ request: new Request("/blog/123/tricycle") })).toEqual([
+            "3/tricycle/123",
+            "4/123/tricycle",
+        ]);
+        expect(matcher({ request: new Request("https://my.pages.dev/magic") })).toEqual(["5/my/dev/magic"]);
+        expect(matcher({ request: new Request("https://next.my.pages.dev/magic") })).toEqual(["6/my/"]);
+    });
+});
+describe("replacer", () => {
+    it("should replace splats", () => {
+        expect((0, rulesEngine_1.replacer)("/blog/:splat", { splat: "look/a/value" })).toEqual("/blog/look/a/value");
+    });
+    it("should replace placeholders", () => {
+        expect((0, rulesEngine_1.replacer)("/:code/:name.jpg", { name: "tricycle", code: "123" })).toEqual("/123/tricycle.jpg");
+    });
+    it("should replace splats and placeholders", () => {
+        expect((0, rulesEngine_1.replacer)("/:code/:splat", { splat: "tricycle/images", code: "123" })).toEqual("/123/tricycle/images");
+    });
+    it("should replace all instances of placeholders", () => {
+        expect((0, rulesEngine_1.replacer)("Link: </assets/:value/main.js>; rel=preload; as=script, </assets/:value/lang.js>; rel=preload; as=script", { value: "js" })).toEqual("Link: </assets/js/main.js>; rel=preload; as=script, </assets/js/lang.js>; rel=preload; as=script");
+    });
+});

package/dist/__tests__/jest.setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest.setup.d.ts.map

package/dist/__tests__/jest.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.setup.d.ts","sourceRoot":"","sources":["../../__tests__/jest.setup.ts"],"names":[],"mappings":""}

package/dist/__tests__/jest.setup.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_worker_mock_1 = __importDefault(require("service-worker-mock"));
+Object.assign(globalThis, (0, service_worker_mock_1.default)());

package/dist/__tests__/metadata-generator/createMetadataObject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createMetadataObject.test.d.ts.map

package/dist/__tests__/metadata-generator/createMetadataObject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMetadataObject.test.d.ts","sourceRoot":"","sources":["../../../__tests__/metadata-generator/createMetadataObject.test.ts"],"names":[],"mappings":""}