@cloudflare/pages-shared 0.0.0-ship-js

package/dist/__tests__/metadata-generator/createMetadataObject.test.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createMetadataObject_1 = require("../..//metadata-generator/createMetadataObject");
+const homeRedirectRule = {
+    from: "/home",
+    to: "/",
+    status: 302,
+    lineNumber: 1,
+};
+const splatRedirectRule = {
+    from: "/blog/*",
+    to: "/blog/:splat",
+    status: 302,
+    lineNumber: 2,
+};
+const placeholderRedirectRule = {
+    from: "/blog/:year/:month/:date/:slug",
+    to: "/news/:year/:month/:date/:slug",
+    status: 302,
+    lineNumber: 3,
+};
+const fooBarRedirectRule = {
+    from: "/foo",
+    to: "/bar",
+    status: 302,
+    lineNumber: 4,
+};
+const homeHeadersRule = {
+    path: "/home",
+    headers: {
+        "Access-Control-Allow-Origin": "*",
+    },
+    unsetHeaders: [],
+};
+test("createMetadataObject should return no redirects or headers entry for no valid rules", () => {
+    {
+        const metadata = (0, createMetadataObject_1.createMetadataObject)({
+            redirects: {
+                rules: [],
+                invalid: [],
+            },
+            headers: {
+                rules: [],
+                invalid: [],
+            },
+        });
+        expect(metadata.redirects).toEqual(undefined);
+        expect(metadata.headers).toEqual(undefined);
+    }
+    {
+        const metadata = (0, createMetadataObject_1.createMetadataObject)({});
+        expect(metadata.redirects).toEqual(undefined);
+        expect(metadata.headers).toEqual(undefined);
+    }
+});
+test("createMetadataObject should add Version", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        redirects: {
+            rules: [homeRedirectRule],
+            invalid: [],
+        },
+        headers: {
+            rules: [homeHeadersRule],
+            invalid: [],
+        },
+    });
+    expect(metadata.redirects?.version).toEqual(1);
+    expect(metadata.headers?.version).toEqual(2);
+});
+test("createMetadataObject should construct mapping of from to to/status", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        redirects: {
+            rules: [
+                homeRedirectRule,
+                splatRedirectRule,
+                placeholderRedirectRule,
+                fooBarRedirectRule,
+            ],
+            invalid: [],
+        },
+    });
+    expect(metadata.redirects).toEqual({
+        version: 1,
+        staticRules: {
+            "/home": { status: 302, to: "/", lineNumber: 1 },
+        },
+        rules: {
+            "/blog/*": {
+                to: "/blog/:splat",
+                status: 302,
+            },
+            "/blog/:year/:month/:date/:slug": {
+                status: 302,
+                to: "/news/:year/:month/:date/:slug",
+            },
+            "/foo": {
+                status: 302,
+                to: "/bar",
+            },
+        },
+    });
+});
+test("createMetadataObject should construct mapping of path to headers", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        headers: {
+            rules: [homeHeadersRule],
+            invalid: [],
+        },
+    });
+    expect(metadata.headers).toEqual({
+        version: 2,
+        rules: {
+            "/home": {
+                set: { "Access-Control-Allow-Origin": "*" },
+            },
+        },
+    });
+});
+test("createMetadataObject should return no analytics entry for null", () => {
+    {
+        const metadata = (0, createMetadataObject_1.createMetadataObject)({});
+        expect(metadata.analytics).toEqual(undefined);
+    }
+});
+test("createMetadataObject should pass through the token", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        webAnalyticsToken: "secret_token_1234",
+    });
+    expect(metadata.analytics).toEqual({
+        version: 1,
+        token: "secret_token_1234",
+    });
+});
+test("createMetadataObject should parse a realistic result", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        redirects: {
+            invalid: [
+                {
+                    line: `/some page /somewhere else`,
+                    message: "Expected exactly 2 or 3 whitespace-separated tokens. Got 4.",
+                },
+                {
+                    line: `https://yeah.com https://nah.com`,
+                    message: "Only relative URLs are allowed. Skipping absolute URL https://yeah.com.",
+                },
+            ],
+            rules: [
+                {
+                    from: "/some%20page",
+                    status: 302,
+                    to: "/somewhere%20else",
+                    lineNumber: 1,
+                },
+                {
+                    from: "/://so;%60me",
+                    status: 302,
+                    to: "/nons:/&@%+~%7B%7Dense",
+                    lineNumber: 2,
+                },
+                { from: "/nah", status: 302, to: "https://yeah.com/", lineNumber: 3 },
+                {
+                    from: "/yeah.com",
+                    status: 302,
+                    to: "https://nah.com/",
+                    lineNumber: 4,
+                },
+            ],
+        },
+        headers: {
+            invalid: [
+                {
+                    line: "HEADERSTODO",
+                    message: "HEADERSTODO",
+                },
+            ],
+            rules: [
+                {
+                    path: "/static/*",
+                    headers: { "Access-Control-Allow-Origin": "*" },
+                    unsetHeaders: [],
+                },
+                {
+                    path: "/logout",
+                    headers: {
+                        "Set-Cookie": "session=; Expires=Thu, 01 Jan 1970 00:00:00 GMT",
+                        "x-content-type-options": "nosniff",
+                        "x-frame-options": "DENY",
+                    },
+                    unsetHeaders: [],
+                },
+                {
+                    path: "https://my.pages.dev/*",
+                    headers: { "X-Robots-Tag": "none" },
+                    unsetHeaders: [],
+                },
+            ],
+        },
+        webAnalyticsToken: "secret_token_1234",
+        deploymentId: "some-deployment-123",
+    });
+    expect(metadata).toEqual({
+        redirects: {
+            version: 1,
+            rules: {},
+            staticRules: {
+                "/some%20page": { status: 302, to: "/somewhere%20else", lineNumber: 1 },
+                "/://so;%60me": {
+                    status: 302,
+                    to: "/nons:/&@%+~%7B%7Dense",
+                    lineNumber: 2,
+                },
+                "/nah": { status: 302, to: "https://yeah.com/", lineNumber: 3 },
+                "/yeah.com": { status: 302, to: "https://nah.com/", lineNumber: 4 },
+            },
+        },
+        headers: {
+            version: 2,
+            rules: {
+                "/static/*": {
+                    set: {
+                        "Access-Control-Allow-Origin": "*",
+                    },
+                },
+                "/logout": {
+                    set: {
+                        "Set-Cookie": "session=; Expires=Thu, 01 Jan 1970 00:00:00 GMT",
+                        "x-content-type-options": "nosniff",
+                        "x-frame-options": "DENY",
+                    },
+                },
+                "https://my.pages.dev/*": {
+                    set: { "X-Robots-Tag": "none" },
+                },
+            },
+        },
+        analytics: {
+            version: 1,
+            token: "secret_token_1234",
+        },
+        deploymentId: "some-deployment-123",
+    });
+});
+test("createMetadataObject should include unset", () => {
+    const metadata = (0, createMetadataObject_1.createMetadataObject)({
+        headers: {
+            invalid: [],
+            rules: [
+                {
+                    path: "/*",
+                    headers: { "x-custom-header": "value" },
+                    unsetHeaders: [],
+                },
+                {
+                    path: "/foo/*",
+                    headers: {},
+                    unsetHeaders: ["x-custom-header"],
+                },
+                {
+                    path: "/foo/bar/*",
+                    headers: { "x-custom-header": "newvalue" },
+                    unsetHeaders: [],
+                },
+            ],
+        },
+        webAnalyticsToken: "secret_token_1234",
+        deploymentId: "some-deployment-id",
+    });
+    expect(metadata).toEqual({
+        analytics: {
+            token: "secret_token_1234",
+            version: 1,
+        },
+        headers: {
+            version: 2,
+            rules: {
+                "/*": {
+                    set: {
+                        "x-custom-header": "value",
+                    },
+                },
+                "/foo/*": {
+                    unset: ["x-custom-header"],
+                },
+                "/foo/bar/*": {
+                    set: {
+                        "x-custom-header": "newvalue",
+                    },
+                },
+            },
+        },
+        deploymentId: "some-deployment-id",
+    });
+});

package/dist/__tests__/metadata-generator/parseHeaders.invalid.test.d.ts

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

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

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

package/dist/__tests__/metadata-generator/parseHeaders.invalid.test.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseHeaders_1 = require("../..//metadata-generator/parseHeaders");
+test("parseHeaders should reject malformed initial lines", () => {
+    const input = `
+    # A single token before a path
+    c
+    # A header before a path
+    Access-Control-Allow-Origin: *
+  `;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [],
+        invalid: [
+            {
+                line: "c",
+                lineNumber: 3,
+                message: "Expected a path beginning with at least one forward-slash",
+            },
+            {
+                line: "Access-Control-Allow-Origin: *",
+                lineNumber: 5,
+                message: "Path should come before header (access-control-allow-origin: *)",
+            },
+        ],
+    });
+});
+test("parseHeaders should reject invalid headers", () => {
+    const input = `
+    # Valid header sails through
+    /a
+      Name:       Value
+    #
+    /b
+      I'm invalid!
+      !x-content-type
+      But: I'm okay!
+      ! Content-Type: application/json
+  `;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [
+            { path: "/a", headers: { name: "Value" }, unsetHeaders: [] },
+            { path: "/b", headers: { but: "I'm okay!" }, unsetHeaders: [] },
+        ],
+        invalid: [
+            {
+                line: `I'm invalid!`,
+                lineNumber: 7,
+                message: "Expected a colon-separated header pair (e.g. name: value)",
+            },
+            {
+                line: "!x-content-type",
+                lineNumber: 8,
+                message: "Expected a colon-separated header pair (e.g. name: value)",
+            },
+            {
+                line: `! Content-Type: application/json`,
+                lineNumber: 10,
+                message: "Header name cannot include spaces",
+            },
+        ],
+    });
+});
+test("parseHeaders should reject lines longer than 2000 chars", () => {
+    const huge_line = `${Array(1001).fill("a").join("")}: ${Array(1001)
+        .fill("b")
+        .join("")}`;
+    const input = `
+    # Valid entry
+    /a
+      Name: Value
+    # Jumbo comment line OK, ignored as normal
+    ${Array(1001).fill("#").join("")}
+    # Huge path names rejected
+    /b
+      Name: Value
+      ${huge_line}
+  `;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [
+            { path: "/a", headers: { name: "Value" }, unsetHeaders: [] },
+            { path: "/b", headers: { name: "Value" }, unsetHeaders: [] },
+        ],
+        invalid: [
+            {
+                message: `Ignoring line 10 as it exceeds the maximum allowed length of 2000.`,
+            },
+        ],
+    });
+});
+test("parseHeaders should reject any rules after the first 100", () => {
+    const input = `
+    # COMMENTS DON'T COUNT TOWARDS TOTAL VALID RULES
+    ${Array(150)
+        .fill(undefined)
+        .map((_, i) => `/a/${i}\nx-index: ${i}`)
+        .join("\n")}
+    # BUT DO GET COUNTED AS TOTAL LINES SKIPPED
+  `;
+    expect((0, parseHeaders_1.parseHeaders)(input)).toEqual({
+        rules: Array(101)
+            .fill(undefined)
+            .map((_, i) => ({
+            path: "/a/" + i,
+            headers: { "x-index": `${i}` },
+            unsetHeaders: [],
+        })),
+        invalid: [
+            {
+                message: `Maximum number of rules supported is 100. Skipping remaining 100 lines of file.`,
+            },
+        ],
+    });
+});
+test("parseHeaders should reject malformed URLs", () => {
+    const input = `
+  # Spaces should be URI encoded
+  /some page with spaces
+    valid: yup
+  # OK with URL escaped encoding
+  /some%20page
+    valid: yup
+  # Unescaped URLs are handled OK by Deno, so escape & pass them through
+  /://so;\`me
+    valid: yup
+  /nons:/&@%+~{}ense
+    valid: yup
+  # Absolute URLs with a non-https protocol should be rejected
+  https://yeah.com
+    valid: yup
+  http://nah.com/blog
+    invalid: things
+  //yeah.com/blog
+    valid: things
+  /yeah
+    valid: yup
+  /yeah.com
+    valid: yup
+  # Anything standalone is interpreted as a invalid header pair
+  nah.com
+  :
+  test:
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        invalid: [
+            {
+                line: "http://nah.com/blog",
+                lineNumber: 16,
+                message: 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").',
+            },
+            {
+                line: "invalid: things",
+                lineNumber: 17,
+                message: "Path should come before header (invalid: things)",
+            },
+            {
+                line: "nah.com",
+                lineNumber: 25,
+                message: "Expected a colon-separated header pair (e.g. name: value)",
+            },
+            { line: ":", lineNumber: 26, message: "No header name specified" },
+            { line: "test:", lineNumber: 27, message: "No header value specified" },
+        ],
+        rules: [
+            {
+                path: "/some%20page%20with%20spaces",
+                headers: { valid: "yup" },
+                unsetHeaders: [],
+            },
+            { path: "/some%20page", headers: { valid: "yup" }, unsetHeaders: [] },
+            { path: "/://so;%60me", headers: { valid: "yup" }, unsetHeaders: [] },
+            {
+                path: "/nons:/&@%+~%7B%7Dense",
+                headers: { valid: "yup" },
+                unsetHeaders: [],
+            },
+            {
+                path: "https://yeah.com/",
+                headers: { valid: "yup" },
+                unsetHeaders: [],
+            },
+            {
+                path: "//yeah.com/blog",
+                headers: { valid: "things" },
+                unsetHeaders: [],
+            },
+            { path: "/yeah", headers: { valid: "yup" }, unsetHeaders: [] },
+            { path: "/yeah.com", headers: { valid: "yup" }, unsetHeaders: [] },
+        ],
+    });
+});

package/dist/__tests__/metadata-generator/parseHeaders.valid.test.d.ts

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

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

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

package/dist/__tests__/metadata-generator/parseHeaders.valid.test.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseHeaders_1 = require("../..//metadata-generator/parseHeaders");
+test("parseHeaders should handle a single rule", () => {
+    const input = `/a
+  Name: Value`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [{ path: "/a", headers: { name: "Value" }, unsetHeaders: [] }],
+        invalid: [],
+    });
+});
+test("parseHeaders should handle headers with exclamation marks", () => {
+    const input = `/a
+  !Name: Value`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [{ path: "/a", headers: { "!name": "Value" }, unsetHeaders: [] }],
+        invalid: [],
+    });
+});
+test("parseHeaders should ignore blank lines", () => {
+    const input = `
+/a
+
+Name: Value
+
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [{ path: "/a", headers: { name: "Value" }, unsetHeaders: [] }],
+        invalid: [],
+    });
+});
+test("parseHeaders should trim whitespace", () => {
+    const input = `
+                /a
+    Name         :           Value
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [{ path: "/a", headers: { name: "Value" }, unsetHeaders: [] }],
+        invalid: [],
+    });
+});
+test("parseHeaders should ignore comments", () => {
+    const input = `
+  # This is a comment
+  /a
+  # And one here too.
+  Name: Value
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [{ path: "/a", headers: { name: "Value" }, unsetHeaders: [] }],
+        invalid: [],
+    });
+});
+test("parseHeaders should combine headers together", () => {
+    const input = `
+  /a
+    Set-Cookie: test=cookie; expires=never
+    Set-Cookie: another=cookie; magic!
+
+  /b
+    A: ABBA
+    B: BABA
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [
+            {
+                path: "/a",
+                headers: {
+                    "set-cookie": "test=cookie; expires=never, another=cookie; magic!",
+                },
+                unsetHeaders: [],
+            },
+            {
+                path: "/b",
+                headers: { a: "ABBA", b: "BABA" },
+                unsetHeaders: [],
+            },
+        ],
+        invalid: [],
+    });
+});
+test("parseHeaders should support setting hosts", () => {
+    const input = `
+  https://example.com
+    a: a
+  https://example.com/
+    b: b
+  https://example.com/blog
+    c: c
+  /blog
+    d:d
+  https://:subdomain.example.*/path
+    e:e
+`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [
+            { path: "https://example.com/", headers: { a: "a" }, unsetHeaders: [] },
+            { path: "https://example.com/", headers: { b: "b" }, unsetHeaders: [] },
+            {
+                path: "https://example.com/blog",
+                headers: { c: "c" },
+                unsetHeaders: [],
+            },
+            { path: "/blog", headers: { d: "d" }, unsetHeaders: [] },
+            {
+                path: "https://:subdomain.example.*/path",
+                headers: { e: "e" },
+                unsetHeaders: [],
+            },
+        ],
+        invalid: [],
+    });
+});
+test("parseHeaders should add unset headers", () => {
+    const input = `/a
+  Name: Value
+  ! Place`;
+    const result = (0, parseHeaders_1.parseHeaders)(input);
+    expect(result).toEqual({
+        rules: [
+            { path: "/a", headers: { name: "Value" }, unsetHeaders: ["Place"] },
+        ],
+        invalid: [],
+    });
+});

package/dist/__tests__/metadata-generator/parseRedirects.invalid.test.d.ts

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

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

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