@webiny/app 6.6.0-alpha.0 → 6.6.0-alpha.2

package/exports/admin.d.ts

@@ -1,4 +1,5 @@
 export { MainGraphQLClient } from "../features/mainGraphQLClient/index.js";
+export { ApiStreamClient, readServerSentEvents } from "../features/apiStreamClient/index.js";
 export { useFeature } from "../shared/di/useFeature.js";
 export { NetworkErrorEventHandler } from "../errors/index.js";
 export { createProviderPlugin } from "../core/createProviderPlugin.js";

package/exports/admin.js

@@ -1,4 +1,5 @@
 export { MainGraphQLClient } from "../features/mainGraphQLClient/index.js";
+export { ApiStreamClient, readServerSentEvents } from "../features/apiStreamClient/index.js";
 export { useFeature } from "../shared/di/useFeature.js";
 export { NetworkErrorEventHandler } from "../errors/index.js";
 export { createProviderPlugin } from "../core/createProviderPlugin.js";

package/features/apiStreamClient/FetchApiStreamClient.d.ts

@@ -0,0 +1,9 @@
+import { ApiStreamClient } from "./abstractions.js";
+import { EnvConfig } from "../../features/envConfig/index.js";
+declare class ApiStreamClientImpl implements ApiStreamClient.Interface {
+    private readonly apiUrl;
+    constructor(envConfig: EnvConfig.Interface);
+    execute(params: ApiStreamClient.Request): Promise<ApiStreamClient.Response>;
+}
+export declare const FetchApiStreamClient: import("@webiny/di").Implementation<typeof ApiStreamClientImpl>;
+export {};

package/features/apiStreamClient/FetchApiStreamClient.js

@@ -0,0 +1,63 @@
+import { createImplementation } from "@webiny/di";
+import { ApiStreamClient, ApiStreamRequestError } from "./abstractions.js";
+import { EnvConfig } from "../envConfig/index.js";
+import { toPayloadHash } from "./toPayloadHash.js";
+function toFetchHeaders(headers = {}) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers))if (void 0 !== value) result[key] = String(value);
+    return result;
+}
+function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+async function toRequestError(response) {
+    let message = `Request failed with status ${response.status}.`;
+    let code;
+    try {
+        const json = await response.json();
+        if (json?.message) message = json.message;
+        if (json?.code) code = json.code;
+    } catch  {}
+    return new ApiStreamRequestError(message, response.status, code);
+}
+class ApiStreamClientImpl {
+    constructor(envConfig){
+        this.apiUrl = envConfig.get("apiUrl");
+    }
+    async execute(params) {
+        const hasBody = void 0 !== params.body;
+        const headers = {
+            accept: "text/event-stream"
+        };
+        if (hasBody) headers["content-type"] = "application/json";
+        Object.assign(headers, toFetchHeaders(params.headers));
+        const body = hasBody ? JSON.stringify(params.body) : void 0;
+        const url = joinUrl(this.apiUrl, params.path);
+        if (void 0 !== body) headers["x-amz-content-sha256"] = await toPayloadHash(body);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "POST",
+                headers,
+                body,
+                signal: params.signal
+            });
+        } catch (err) {
+            if (err instanceof DOMException && "AbortError" === err.name) throw err;
+            throw new Error(`Network error: ${err.message}`);
+        }
+        if (!response.ok) throw await toRequestError(response);
+        if (!response.body) throw new ApiStreamRequestError("The response carried no readable body.", response.status);
+        return response;
+    }
+}
+const FetchApiStreamClient = createImplementation({
+    abstraction: ApiStreamClient,
+    implementation: ApiStreamClientImpl,
+    dependencies: [
+        EnvConfig
+    ]
+});
+export { FetchApiStreamClient };
+
+//# sourceMappingURL=FetchApiStreamClient.js.map

package/features/apiStreamClient/FetchApiStreamClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/FetchApiStreamClient.js","sources":["../../../src/features/apiStreamClient/FetchApiStreamClient.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { ApiStreamClient, ApiStreamRequestError } from \"./abstractions.js\";\nimport { EnvConfig } from \"~/features/envConfig/index.js\";\nimport { toPayloadHash } from \"./toPayloadHash.js\";\n\nfunction toFetchHeaders(headers: ApiStreamClient.Headers = {}): Record<string, string> {\n    const result: Record<string, string> = {};\n    for (const [key, value] of Object.entries(headers)) {\n        if (value !== undefined) {\n            result[key] = String(value);\n        }\n    }\n    return result;\n}\n\nfunction joinUrl(base: string, path: string): string {\n    return `${base.replace(/\\/+$/, \"\")}/${path.replace(/^\\/+/, \"\")}`;\n}\n\n/**\n * Streaming routes answer with a normal JSON error for anything they detect BEFORE opening the\n * stream (unknown file, no permission, bad input), which is why those arrive here as a non-2xx\n * rather than as an in-stream event.\n */\nasync function toRequestError(response: Response): Promise<ApiStreamRequestError> {\n    let message = `Request failed with status ${response.status}.`;\n    let code: string | undefined;\n\n    try {\n        const json = await response.json();\n        if (json?.message) {\n            message = json.message;\n        }\n        if (json?.code) {\n            code = json.code;\n        }\n    } catch {\n        // Non-JSON error body — keep the status-based message.\n    }\n\n    return new ApiStreamRequestError(message, response.status, code);\n}\n\nclass ApiStreamClientImpl implements ApiStreamClient.Interface {\n    private readonly apiUrl: string;\n\n    constructor(envConfig: EnvConfig.Interface) {\n        // The API root, not `graphqlApiUrl` — streaming routes live beside /graphql, not under it.\n        this.apiUrl = envConfig.get(\"apiUrl\");\n    }\n\n    async execute(params: ApiStreamClient.Request): Promise<ApiStreamClient.Response> {\n        const hasBody = params.body !== undefined;\n\n        const headers: Record<string, string> = { accept: \"text/event-stream\" };\n        if (hasBody) {\n            headers[\"content-type\"] = \"application/json\";\n        }\n        Object.assign(headers, toFetchHeaders(params.headers));\n\n        const body = hasBody ? JSON.stringify(params.body) : undefined;\n        const url = joinUrl(this.apiUrl, params.path);\n\n        /*\n         * CloudFront's Origin Access Control signs this request but does not hash the body — it trusts\n         * this header for the payload hash, and the Function URL's authorizer checks it against the\n         * body it received. Without it a POST carrying a body is rejected with\n         * `InvalidSignatureException`, while a bodyless one succeeds. Harmless on transports that do\n         * not sign.\n         */\n        if (body !== undefined) {\n            headers[\"x-amz-content-sha256\"] = await toPayloadHash(body);\n        }\n\n        let response: Response;\n        try {\n            // Always POST. A streaming route is an action, and POST keeps the parameters in a body\n            // rather than a cacheable URL — CloudFront caches GET/HEAD.\n            response = await fetch(url, {\n                method: \"POST\",\n                headers,\n                body,\n                signal: params.signal\n            });\n        } catch (err) {\n            // Preserve an abort: it isn't a network failure and callers need to tell them apart.\n            if (err instanceof DOMException && err.name === \"AbortError\") {\n                throw err;\n            }\n            throw new Error(`Network error: ${(err as Error).message}`);\n        }\n\n        if (!response.ok) {\n            throw await toRequestError(response);\n        }\n\n        if (!response.body) {\n            throw new ApiStreamRequestError(\n                \"The response carried no readable body.\",\n                response.status\n            );\n        }\n\n        return response;\n    }\n}\n\nexport const FetchApiStreamClient = createImplementation({\n    abstraction: ApiStreamClient,\n    implementation: ApiStreamClientImpl,\n    dependencies: [EnvConfig]\n});\n"],"names":["toFetchHeaders","headers","result","key","value","Object","undefined","String","joinUrl","base","path","toRequestError","response","message","code","json","ApiStreamRequestError","ApiStreamClientImpl","envConfig","params","hasBody","body","JSON","url","toPayloadHash","fetch","err","DOMException","Error","FetchApiStreamClient","createImplementation","ApiStreamClient","EnvConfig"],"mappings":";;;;AAKA,SAASA,eAAeC,UAAmC,CAAC,CAAC;IACzD,MAAMC,SAAiC,CAAC;IACxC,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAO,OAAO,CAACJ,SACtC,IAAIG,AAAUE,WAAVF,OACAF,MAAM,CAACC,IAAI,GAAGI,OAAOH;IAG7B,OAAOF;AACX;AAEA,SAASM,QAAQC,IAAY,EAAEC,IAAY;IACvC,OAAO,GAAGD,KAAK,OAAO,CAAC,QAAQ,IAAI,CAAC,EAAEC,KAAK,OAAO,CAAC,QAAQ,KAAK;AACpE;AAOA,eAAeC,eAAeC,QAAkB;IAC5C,IAAIC,UAAU,CAAC,2BAA2B,EAAED,SAAS,MAAM,CAAC,CAAC,CAAC;IAC9D,IAAIE;IAEJ,IAAI;QACA,MAAMC,OAAO,MAAMH,SAAS,IAAI;QAChC,IAAIG,MAAM,SACNF,UAAUE,KAAK,OAAO;QAE1B,IAAIA,MAAM,MACND,OAAOC,KAAK,IAAI;IAExB,EAAE,OAAM,CAER;IAEA,OAAO,IAAIC,sBAAsBH,SAASD,SAAS,MAAM,EAAEE;AAC/D;AAEA,MAAMG;IAGF,YAAYC,SAA8B,CAAE;QAExC,IAAI,CAAC,MAAM,GAAGA,UAAU,GAAG,CAAC;IAChC;IAEA,MAAM,QAAQC,MAA+B,EAAqC;QAC9E,MAAMC,UAAUD,AAAgBb,WAAhBa,OAAO,IAAI;QAE3B,MAAMlB,UAAkC;YAAE,QAAQ;QAAoB;QACtE,IAAImB,SACAnB,OAAO,CAAC,eAAe,GAAG;QAE9BI,OAAO,MAAM,CAACJ,SAASD,eAAemB,OAAO,OAAO;QAEpD,MAAME,OAAOD,UAAUE,KAAK,SAAS,CAACH,OAAO,IAAI,IAAIb;QACrD,MAAMiB,MAAMf,QAAQ,IAAI,CAAC,MAAM,EAAEW,OAAO,IAAI;QAS5C,IAAIE,AAASf,WAATe,MACApB,OAAO,CAAC,uBAAuB,GAAG,MAAMuB,cAAcH;QAG1D,IAAIT;QACJ,IAAI;YAGAA,WAAW,MAAMa,MAAMF,KAAK;gBACxB,QAAQ;gBACRtB;gBACAoB;gBACA,QAAQF,OAAO,MAAM;YACzB;QACJ,EAAE,OAAOO,KAAK;YAEV,IAAIA,eAAeC,gBAAgBD,AAAa,iBAAbA,IAAI,IAAI,EACvC,MAAMA;YAEV,MAAM,IAAIE,MAAM,CAAC,eAAe,EAAGF,IAAc,OAAO,EAAE;QAC9D;QAEA,IAAI,CAACd,SAAS,EAAE,EACZ,MAAM,MAAMD,eAAeC;QAG/B,IAAI,CAACA,SAAS,IAAI,EACd,MAAM,IAAII,sBACN,0CACAJ,SAAS,MAAM;QAIvB,OAAOA;IACX;AACJ;AAEO,MAAMiB,uBAAuBC,qBAAqB;IACrD,aAAaC;IACb,gBAAgBd;IAChB,cAAc;QAACe;KAAU;AAC7B"}

package/features/apiStreamClient/__tests__/FetchApiStreamClient.test.d.ts

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

package/features/apiStreamClient/__tests__/FetchApiStreamClient.test.js

@@ -0,0 +1,170 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Container } from "@webiny/di";
+import { ApiStreamClient, ApiStreamRequestError } from "../abstractions.js";
+import { FetchApiStreamClient } from "../FetchApiStreamClient.js";
+import { EnvConfig } from "../../envConfig/index.js";
+import { __webpack_require__ } from "../../../rslib-runtime.js";
+function okResponse() {
+    return {
+        ok: true,
+        status: 200,
+        body: new ReadableStream({
+            start (controller) {
+                controller.close();
+            }
+        })
+    };
+}
+describe("FetchApiStreamClient", ()=>{
+    let container;
+    let client;
+    beforeEach(()=>{
+        container = new Container();
+        container.registerInstance(EnvConfig, {
+            get: vi.fn((key)=>"apiUrl" === key ? "https://api.example.com/" : void 0)
+        });
+        container.register(FetchApiStreamClient).inSingletonScope();
+        client = container.resolve(ApiStreamClient);
+    });
+    it("should POST to the API root joined with the path", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/fm/files/abc/enrich"
+        });
+        expect(__webpack_require__.g.fetch).toHaveBeenCalledWith("https://api.example.com/stream/fm/files/abc/enrich", expect.objectContaining({
+            method: "POST"
+        }));
+    });
+    it("should send the body's payload hash so OAC signing matches", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/ai/chat",
+            body: {
+                prompt: "hi"
+            }
+        });
+        const init = __webpack_require__.g.fetch.mock.calls[0][1];
+        expect(init.headers["x-amz-content-sha256"]).toBe("14479f4e87d340fe0ca0d522d87a5b3a028ebb1af24fbb8d3ef4553044fc6db6");
+    });
+    it("should omit the payload hash when there is no body", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/fm/files/abc/enrich"
+        });
+        const init = __webpack_require__.g.fetch.mock.calls[0][1];
+        expect(init.headers).not.toHaveProperty("x-amz-content-sha256");
+    });
+    it("should not produce a double slash when joining", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "stream/thing"
+        });
+        expect(__webpack_require__.g.fetch).toHaveBeenCalledWith("https://api.example.com/stream/thing", expect.anything());
+    });
+    it("should request an event stream and stringify the body", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/x",
+            body: {
+                hello: "world"
+            }
+        });
+        const init = __webpack_require__.g.fetch.mock.calls[0][1];
+        expect(init.headers.accept).toBe("text/event-stream");
+        expect(init.headers["content-type"]).toBe("application/json");
+        expect(init.body).toBe(JSON.stringify({
+            hello: "world"
+        }));
+    });
+    it("should pass through caller headers and drop undefined ones", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/x",
+            headers: {
+                Authorization: "Bearer t",
+                "x-tenant": "root",
+                "x-skip": void 0
+            }
+        });
+        const { headers } = __webpack_require__.g.fetch.mock.calls[0][1];
+        expect(headers.Authorization).toBe("Bearer t");
+        expect(headers["x-tenant"]).toBe("root");
+        expect("x-skip" in headers).toBe(false);
+    });
+    it("should omit the body and its content-type when there is no body", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        await client.execute({
+            path: "/stream/x"
+        });
+        const init = __webpack_require__.g.fetch.mock.calls[0][1];
+        expect(init.body).toBeUndefined();
+        expect(init.headers["content-type"]).toBeUndefined();
+    });
+    it("should surface a JSON error body as ApiStreamRequestError", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            json: async ()=>({
+                    message: "File not found: abc",
+                    code: "ENRICHMENT_FILE_NOT_FOUND"
+                })
+        });
+        const error = await client.execute({
+            path: "/stream/x"
+        }).catch((e)=>e);
+        expect(error).toBeInstanceOf(ApiStreamRequestError);
+        expect(error.message).toBe("File not found: abc");
+        expect(error.statusCode).toBe(404);
+        expect(error.code).toBe("ENRICHMENT_FILE_NOT_FOUND");
+    });
+    it("should fall back to a status message when the error body isn't JSON", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 502,
+            json: async ()=>{
+                throw new Error("not json");
+            }
+        });
+        const error = await client.execute({
+            path: "/stream/x"
+        }).catch((e)=>e);
+        expect(error).toBeInstanceOf(ApiStreamRequestError);
+        expect(error.message).toBe("Request failed with status 502.");
+        expect(error.statusCode).toBe(502);
+    });
+    it("should reject a 2xx response that carries no body", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: null
+        });
+        await expect(client.execute({
+            path: "/stream/x"
+        })).rejects.toThrow("The response carried no readable body.");
+    });
+    it("should wrap a network failure", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockRejectedValue(new Error("connection reset"));
+        await expect(client.execute({
+            path: "/stream/x"
+        })).rejects.toThrow("Network error: connection reset");
+    });
+    it("should rethrow an abort untouched", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockRejectedValue(new DOMException("aborted", "AbortError"));
+        const error = await client.execute({
+            path: "/stream/x"
+        }).catch((e)=>e);
+        expect(error).toBeInstanceOf(DOMException);
+        expect(error.name).toBe("AbortError");
+    });
+    it("should forward the abort signal to fetch", async ()=>{
+        __webpack_require__.g.fetch = vi.fn().mockResolvedValue(okResponse());
+        const controller = new AbortController();
+        await client.execute({
+            path: "/stream/x",
+            signal: controller.signal
+        });
+        expect(__webpack_require__.g.fetch.mock.calls[0][1].signal).toBe(controller.signal);
+    });
+});
+
+//# sourceMappingURL=FetchApiStreamClient.test.js.map

package/features/apiStreamClient/__tests__/FetchApiStreamClient.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/__tests__/FetchApiStreamClient.test.js","sources":["../../../../src/features/apiStreamClient/__tests__/FetchApiStreamClient.test.ts"],"sourcesContent":["import { describe, it, expect, vi, beforeEach } from \"vitest\";\nimport { Container } from \"@webiny/di\";\nimport { ApiStreamClient, ApiStreamRequestError } from \"../abstractions.js\";\nimport { FetchApiStreamClient } from \"../FetchApiStreamClient.js\";\nimport { EnvConfig } from \"~/features/envConfig/index.js\";\n\nfunction okResponse() {\n    return {\n        ok: true,\n        status: 200,\n        body: new ReadableStream<Uint8Array>({\n            start(controller) {\n                controller.close();\n            }\n        })\n    };\n}\n\ndescribe(\"FetchApiStreamClient\", () => {\n    let container: Container;\n    let client: ApiStreamClient.Interface;\n\n    beforeEach(() => {\n        container = new Container();\n        container.registerInstance(EnvConfig, {\n            get: vi.fn((key: string) => (key === \"apiUrl\" ? \"https://api.example.com/\" : undefined))\n        } as any);\n        container.register(FetchApiStreamClient).inSingletonScope();\n        client = container.resolve(ApiStreamClient);\n    });\n\n    it(\"should POST to the API root joined with the path\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"/stream/fm/files/abc/enrich\" });\n\n        expect(global.fetch).toHaveBeenCalledWith(\n            \"https://api.example.com/stream/fm/files/abc/enrich\",\n            expect.objectContaining({ method: \"POST\" })\n        );\n    });\n\n    /*\n     * CloudFront OAC signs the request but does not hash the body, so it takes the payload hash from\n     * this header. Omit it and a POST carrying a body is rejected with InvalidSignatureException while\n     * a bodyless one succeeds — a failure no existing route hit, because none sent a body.\n     */\n    it(\"should send the body's payload hash so OAC signing matches\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"/stream/ai/chat\", body: { prompt: \"hi\" } });\n\n        const init = (global.fetch as any).mock.calls[0][1];\n        // sha256 of {\"prompt\":\"hi\"}\n        expect(init.headers[\"x-amz-content-sha256\"]).toBe(\n            \"14479f4e87d340fe0ca0d522d87a5b3a028ebb1af24fbb8d3ef4553044fc6db6\"\n        );\n    });\n\n    it(\"should omit the payload hash when there is no body\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"/stream/fm/files/abc/enrich\" });\n\n        const init = (global.fetch as any).mock.calls[0][1];\n        expect(init.headers).not.toHaveProperty(\"x-amz-content-sha256\");\n    });\n\n    it(\"should not produce a double slash when joining\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"stream/thing\" });\n\n        expect(global.fetch).toHaveBeenCalledWith(\n            \"https://api.example.com/stream/thing\",\n            expect.anything()\n        );\n    });\n\n    it(\"should request an event stream and stringify the body\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"/stream/x\", body: { hello: \"world\" } });\n\n        const init = (global.fetch as any).mock.calls[0][1];\n        expect(init.headers.accept).toBe(\"text/event-stream\");\n        expect(init.headers[\"content-type\"]).toBe(\"application/json\");\n        expect(init.body).toBe(JSON.stringify({ hello: \"world\" }));\n    });\n\n    it(\"should pass through caller headers and drop undefined ones\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({\n            path: \"/stream/x\",\n            headers: { Authorization: \"Bearer t\", \"x-tenant\": \"root\", \"x-skip\": undefined }\n        });\n\n        const { headers } = (global.fetch as any).mock.calls[0][1];\n        expect(headers.Authorization).toBe(\"Bearer t\");\n        expect(headers[\"x-tenant\"]).toBe(\"root\");\n        expect(\"x-skip\" in headers).toBe(false);\n    });\n\n    it(\"should omit the body and its content-type when there is no body\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n\n        await client.execute({ path: \"/stream/x\" });\n\n        const init = (global.fetch as any).mock.calls[0][1];\n        expect(init.body).toBeUndefined();\n        expect(init.headers[\"content-type\"]).toBeUndefined();\n    });\n\n    it(\"should surface a JSON error body as ApiStreamRequestError\", async () => {\n        global.fetch = vi.fn().mockResolvedValue({\n            ok: false,\n            status: 404,\n            json: async () => ({\n                message: \"File not found: abc\",\n                code: \"ENRICHMENT_FILE_NOT_FOUND\"\n            })\n        });\n\n        const error = await client.execute({ path: \"/stream/x\" }).catch(e => e);\n\n        expect(error).toBeInstanceOf(ApiStreamRequestError);\n        expect(error.message).toBe(\"File not found: abc\");\n        expect(error.statusCode).toBe(404);\n        expect(error.code).toBe(\"ENRICHMENT_FILE_NOT_FOUND\");\n    });\n\n    it(\"should fall back to a status message when the error body isn't JSON\", async () => {\n        global.fetch = vi.fn().mockResolvedValue({\n            ok: false,\n            status: 502,\n            json: async () => {\n                throw new Error(\"not json\");\n            }\n        });\n\n        const error = await client.execute({ path: \"/stream/x\" }).catch(e => e);\n\n        expect(error).toBeInstanceOf(ApiStreamRequestError);\n        expect(error.message).toBe(\"Request failed with status 502.\");\n        expect(error.statusCode).toBe(502);\n    });\n\n    it(\"should reject a 2xx response that carries no body\", async () => {\n        global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, body: null });\n\n        await expect(client.execute({ path: \"/stream/x\" })).rejects.toThrow(\n            \"The response carried no readable body.\"\n        );\n    });\n\n    it(\"should wrap a network failure\", async () => {\n        global.fetch = vi.fn().mockRejectedValue(new Error(\"connection reset\"));\n\n        await expect(client.execute({ path: \"/stream/x\" })).rejects.toThrow(\n            \"Network error: connection reset\"\n        );\n    });\n\n    it(\"should rethrow an abort untouched\", async () => {\n        // Callers distinguish \"user cancelled\" from \"request failed\"; wrapping an abort in a generic\n        // network error would erase that.\n        global.fetch = vi.fn().mockRejectedValue(new DOMException(\"aborted\", \"AbortError\"));\n\n        const error = await client.execute({ path: \"/stream/x\" }).catch(e => e);\n\n        expect(error).toBeInstanceOf(DOMException);\n        expect(error.name).toBe(\"AbortError\");\n    });\n\n    it(\"should forward the abort signal to fetch\", async () => {\n        global.fetch = vi.fn().mockResolvedValue(okResponse());\n        const controller = new AbortController();\n\n        await client.execute({ path: \"/stream/x\", signal: controller.signal });\n\n        expect((global.fetch as any).mock.calls[0][1].signal).toBe(controller.signal);\n    });\n});\n"],"names":["okResponse","ReadableStream","controller","describe","container","client","beforeEach","Container","EnvConfig","vi","key","undefined","FetchApiStreamClient","ApiStreamClient","it","global","expect","init","JSON","headers","error","e","ApiStreamRequestError","Error","DOMException","AbortController"],"mappings":"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"}

package/features/apiStreamClient/__tests__/readServerSentEvents.test.d.ts

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

package/features/apiStreamClient/__tests__/readServerSentEvents.test.js

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import { readServerSentEvents } from "../readServerSentEvents.js";
+const encoder = new TextEncoder();
+function responseFrom(chunks) {
+    const stream = new ReadableStream({
+        start (controller) {
+            for (const chunk of chunks)controller.enqueue("string" == typeof chunk ? encoder.encode(chunk) : chunk);
+            controller.close();
+        }
+    });
+    return {
+        body: stream
+    };
+}
+async function collect(response) {
+    const events = [];
+    for await (const event of readServerSentEvents(response))events.push(event);
+    return events;
+}
+describe("readServerSentEvents", ()=>{
+    it("should parse one event per record", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"type":"start"}\n\n',
+            'data: {"type":"done"}\n\n'
+        ]));
+        expect(events).toEqual([
+            {
+                type: "start"
+            },
+            {
+                type: "done"
+            }
+        ]);
+    });
+    it("should parse multiple records arriving in a single chunk", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"n":1}\n\ndata: {"n":2}\n\ndata: {"n":3}\n\n'
+        ]));
+        expect(events).toEqual([
+            {
+                n: 1
+            },
+            {
+                n: 2
+            },
+            {
+                n: 3
+            }
+        ]);
+    });
+    it("should parse a record split across chunks", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"ty',
+            'pe":"partial"}',
+            "\n\n"
+        ]));
+        expect(events).toEqual([
+            {
+                type: "partial"
+            }
+        ]);
+    });
+    it("should handle CRLF line endings", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"ok":true}\r\n\r\n'
+        ]));
+        expect(events).toEqual([
+            {
+                ok: true
+            }
+        ]);
+    });
+    it("should ignore comments and non-data fields", async ()=>{
+        const events = await collect(responseFrom([
+            ": heartbeat\n\n",
+            'event: message\nid: 7\nretry: 500\ndata: {"kept":true}\n\n'
+        ]));
+        expect(events).toEqual([
+            {
+                kept: true
+            }
+        ]);
+    });
+    it("should join multi-line data fields", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"a":1,\ndata: "b":2}\n\n'
+        ]));
+        expect(events).toEqual([
+            {
+                a: 1,
+                b: 2
+            }
+        ]);
+    });
+    it("should preserve multi-byte characters split across chunks", async ()=>{
+        const payload = encoder.encode('data: {"text":"café"}\n\n');
+        const split = 18;
+        const events = await collect(responseFrom([
+            payload.slice(0, split),
+            payload.slice(split)
+        ]));
+        expect(events).toEqual([
+            {
+                text: "café"
+            }
+        ]);
+    });
+    it("should drop a trailing record that never terminated", async ()=>{
+        const events = await collect(responseFrom([
+            'data: {"complete":true}\n\ndata: {"trunc'
+        ]));
+        expect(events).toEqual([
+            {
+                complete: true
+            }
+        ]);
+    });
+    it("should yield events as they arrive rather than after the stream closes", async ()=>{
+        let released;
+        const gate = new Promise((resolve)=>{
+            released = resolve;
+        });
+        const stream = new ReadableStream({
+            async start (controller) {
+                controller.enqueue(encoder.encode('data: {"n":1}\n\n'));
+                await gate;
+                controller.enqueue(encoder.encode('data: {"n":2}\n\n'));
+                controller.close();
+            }
+        });
+        const iterator = readServerSentEvents({
+            body: stream
+        });
+        expect((await iterator.next()).value).toEqual({
+            n: 1
+        });
+        released();
+        expect((await iterator.next()).value).toEqual({
+            n: 2
+        });
+        expect((await iterator.next()).done).toBe(true);
+    });
+    it("should throw when the response has no body", async ()=>{
+        await expect(collect({
+            body: null
+        })).rejects.toThrow("The response carried no readable body.");
+    });
+    it("should propagate a stream error", async ()=>{
+        const stream = new ReadableStream({
+            start (controller) {
+                controller.error(new Error("stream broke"));
+            }
+        });
+        await expect(collect({
+            body: stream
+        })).rejects.toThrow("stream broke");
+    });
+});
+
+//# sourceMappingURL=readServerSentEvents.test.js.map

package/features/apiStreamClient/__tests__/readServerSentEvents.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/__tests__/readServerSentEvents.test.js","sources":["../../../../src/features/apiStreamClient/__tests__/readServerSentEvents.test.ts"],"sourcesContent":["import { describe, it, expect } from \"vitest\";\nimport { readServerSentEvents } from \"../readServerSentEvents.js\";\n\nconst encoder = new TextEncoder();\n\nfunction responseFrom(chunks: (string | Uint8Array)[]): Response {\n    const stream = new ReadableStream<Uint8Array>({\n        start(controller) {\n            for (const chunk of chunks) {\n                controller.enqueue(typeof chunk === \"string\" ? encoder.encode(chunk) : chunk);\n            }\n            controller.close();\n        }\n    });\n\n    return { body: stream } as Response;\n}\n\nasync function collect<T>(response: Response): Promise<T[]> {\n    const events: T[] = [];\n    for await (const event of readServerSentEvents<T>(response)) {\n        events.push(event);\n    }\n    return events;\n}\n\ndescribe(\"readServerSentEvents\", () => {\n    it(\"should parse one event per record\", async () => {\n        const events = await collect(\n            responseFrom(['data: {\"type\":\"start\"}\\n\\n', 'data: {\"type\":\"done\"}\\n\\n'])\n        );\n\n        expect(events).toEqual([{ type: \"start\" }, { type: \"done\" }]);\n    });\n\n    it(\"should parse multiple records arriving in a single chunk\", async () => {\n        const events = await collect(\n            responseFrom(['data: {\"n\":1}\\n\\ndata: {\"n\":2}\\n\\ndata: {\"n\":3}\\n\\n'])\n        );\n\n        expect(events).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);\n    });\n\n    it(\"should parse a record split across chunks\", async () => {\n        const events = await collect(responseFrom(['data: {\"ty', 'pe\":\"partial\"}', \"\\n\\n\"]));\n\n        expect(events).toEqual([{ type: \"partial\" }]);\n    });\n\n    it(\"should handle CRLF line endings\", async () => {\n        const events = await collect(responseFrom(['data: {\"ok\":true}\\r\\n\\r\\n']));\n\n        expect(events).toEqual([{ ok: true }]);\n    });\n\n    it(\"should ignore comments and non-data fields\", async () => {\n        const events = await collect(\n            responseFrom([\n                \": heartbeat\\n\\n\",\n                'event: message\\nid: 7\\nretry: 500\\ndata: {\"kept\":true}\\n\\n'\n            ])\n        );\n\n        expect(events).toEqual([{ kept: true }]);\n    });\n\n    it(\"should join multi-line data fields\", async () => {\n        const events = await collect(responseFrom(['data: {\"a\":1,\\ndata: \"b\":2}\\n\\n']));\n\n        expect(events).toEqual([{ a: 1, b: 2 }]);\n    });\n\n    it(\"should preserve multi-byte characters split across chunks\", async () => {\n        const payload = encoder.encode('data: {\"text\":\"café\"}\\n\\n');\n        const split = 18;\n\n        const events = await collect(responseFrom([payload.slice(0, split), payload.slice(split)]));\n\n        expect(events).toEqual([{ text: \"café\" }]);\n    });\n\n    it(\"should drop a trailing record that never terminated\", async () => {\n        // A truncated stream (server died mid-record) must not yield a half-parsed event.\n        const events = await collect(responseFrom(['data: {\"complete\":true}\\n\\ndata: {\"trunc']));\n\n        expect(events).toEqual([{ complete: true }]);\n    });\n\n    it(\"should yield events as they arrive rather than after the stream closes\", async () => {\n        let released!: () => void;\n        const gate = new Promise<void>(resolve => {\n            released = resolve;\n        });\n\n        const stream = new ReadableStream<Uint8Array>({\n            async start(controller) {\n                controller.enqueue(encoder.encode('data: {\"n\":1}\\n\\n'));\n                await gate;\n                controller.enqueue(encoder.encode('data: {\"n\":2}\\n\\n'));\n                controller.close();\n            }\n        });\n\n        const iterator = readServerSentEvents<{ n: number }>({ body: stream } as Response);\n\n        // Resolving before the gate opens proves events aren't buffered until close.\n        expect((await iterator.next()).value).toEqual({ n: 1 });\n        released();\n        expect((await iterator.next()).value).toEqual({ n: 2 });\n        expect((await iterator.next()).done).toBe(true);\n    });\n\n    it(\"should throw when the response has no body\", async () => {\n        await expect(collect({ body: null } as Response)).rejects.toThrow(\n            \"The response carried no readable body.\"\n        );\n    });\n\n    it(\"should propagate a stream error\", async () => {\n        const stream = new ReadableStream<Uint8Array>({\n            start(controller) {\n                controller.error(new Error(\"stream broke\"));\n            }\n        });\n\n        await expect(collect({ body: stream } as Response)).rejects.toThrow(\"stream broke\");\n    });\n});\n"],"names":["encoder","TextEncoder","responseFrom","chunks","stream","ReadableStream","controller","chunk","collect","response","events","event","readServerSentEvents","describe","it","expect","payload","split","released","gate","Promise","resolve","iterator","Error"],"mappings":"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"}

package/features/apiStreamClient/abstractions.d.ts

@@ -0,0 +1,44 @@
+type IHeaders = Record<string, string | number | undefined>;
+/**
+ * The raw `fetch` response, handed to the caller unread so it owns the read loop. Aliased through
+ * the abstraction so consumers name the contract rather than the DOM type it currently happens to
+ * be — and so `ApiStreamClient.Response` reads as the counterpart to `ApiStreamClient.Request`.
+ */
+type IApiStreamResponse = globalThis.Response;
+export interface IApiStreamRequest {
+    /** Path relative to the API root, e.g. `/stream/fm/files/abc/enrich`. */
+    path: string;
+    /** Serialized as JSON when present. */
+    body?: unknown;
+    headers?: IHeaders;
+    /**
+     * Aborts the request AND the caller's read loop. Streaming responses stay open for as long as the
+     * producer runs, so without this a caller that navigates away or closes its UI would leave the
+     * connection open and keep consuming events into a component that no longer exists.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Client for API endpoints that stream their response.
+ *
+ * Deliberately separate from `GraphQLClient`: that abstraction returns `Promise<TResult>` — a
+ * buffered contract by type — and Webiny's GraphQL layer (graphql-js 16) has no incremental
+ * delivery, so a streaming response can't travel through it. This returns the raw `Response` so the
+ * caller owns the read loop and can hand `response.body` to any stream consumer.
+ */
+export interface IApiStreamClient {
+    execute(params: IApiStreamRequest): Promise<IApiStreamResponse>;
+}
+export declare const ApiStreamClient: import("@webiny/di").Abstraction<IApiStreamClient>;
+export declare namespace ApiStreamClient {
+    type Headers = IHeaders;
+    type Interface = IApiStreamClient;
+    type Request = IApiStreamRequest;
+    type Response = IApiStreamResponse;
+}
+export declare class ApiStreamRequestError extends Error {
+    readonly statusCode: number;
+    readonly code?: string | undefined;
+    constructor(message: string, statusCode: number, code?: string | undefined);
+}
+export {};

package/features/apiStreamClient/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ApiStreamClient = createAbstraction("ApiStreamClient");
+class ApiStreamRequestError extends Error {
+    constructor(message, statusCode, code){
+        super(message), this.statusCode = statusCode, this.code = code;
+    }
+}
+export { ApiStreamClient, ApiStreamRequestError };
+
+//# sourceMappingURL=abstractions.js.map

package/features/apiStreamClient/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/abstractions.js","sources":["../../../src/features/apiStreamClient/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\ntype IHeaders = Record<string, string | number | undefined>;\n\n/**\n * The raw `fetch` response, handed to the caller unread so it owns the read loop. Aliased through\n * the abstraction so consumers name the contract rather than the DOM type it currently happens to\n * be — and so `ApiStreamClient.Response` reads as the counterpart to `ApiStreamClient.Request`.\n */\ntype IApiStreamResponse = globalThis.Response;\n\nexport interface IApiStreamRequest {\n    /** Path relative to the API root, e.g. `/stream/fm/files/abc/enrich`. */\n    path: string;\n    /** Serialized as JSON when present. */\n    body?: unknown;\n    headers?: IHeaders;\n    /**\n     * Aborts the request AND the caller's read loop. Streaming responses stay open for as long as the\n     * producer runs, so without this a caller that navigates away or closes its UI would leave the\n     * connection open and keep consuming events into a component that no longer exists.\n     */\n    signal?: AbortSignal;\n}\n\n/**\n * Client for API endpoints that stream their response.\n *\n * Deliberately separate from `GraphQLClient`: that abstraction returns `Promise<TResult>` — a\n * buffered contract by type — and Webiny's GraphQL layer (graphql-js 16) has no incremental\n * delivery, so a streaming response can't travel through it. This returns the raw `Response` so the\n * caller owns the read loop and can hand `response.body` to any stream consumer.\n */\nexport interface IApiStreamClient {\n    execute(params: IApiStreamRequest): Promise<IApiStreamResponse>;\n}\n\nexport const ApiStreamClient = createAbstraction<IApiStreamClient>(\"ApiStreamClient\");\n\nexport namespace ApiStreamClient {\n    export type Headers = IHeaders;\n    export type Interface = IApiStreamClient;\n    export type Request = IApiStreamRequest;\n    export type Response = IApiStreamResponse;\n}\n\nexport class ApiStreamRequestError extends Error {\n    constructor(\n        message: string,\n        readonly statusCode: number,\n        readonly code?: string\n    ) {\n        super(message);\n    }\n}\n"],"names":["ApiStreamClient","createAbstraction","ApiStreamRequestError","Error","message","statusCode","code"],"mappings":";AAqCO,MAAMA,kBAAkBC,kBAAoC;AAS5D,MAAMC,8BAA8BC;IACvC,YACIC,OAAe,EACNC,UAAkB,EAClBC,IAAa,CACxB;QACE,KAAK,CAACF,UAAAA,IAAAA,CAHGC,UAAU,GAAVA,YAAAA,IAAAA,CACAC,IAAI,GAAJA;IAGb;AACJ"}

package/features/apiStreamClient/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const ApiStreamClientFeature: import("~/shared/di/createFeature.js").FeatureDefinition<{
+    client: import("./abstractions.js").IApiStreamClient;
+}, []>;

package/features/apiStreamClient/feature.js

@@ -0,0 +1,17 @@
+import { ApiStreamClient } from "./abstractions.js";
+import { FetchApiStreamClient } from "./FetchApiStreamClient.js";
+import { createFeature } from "../../shared/di/createFeature.js";
+const ApiStreamClientFeature = createFeature({
+    name: "ApiStreamClient",
+    register (container) {
+        container.register(FetchApiStreamClient).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            client: container.resolve(ApiStreamClient)
+        };
+    }
+});
+export { ApiStreamClientFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/apiStreamClient/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/feature.js","sources":["../../../src/features/apiStreamClient/feature.ts"],"sourcesContent":["import { ApiStreamClient } from \"./abstractions.js\";\nimport { FetchApiStreamClient } from \"./FetchApiStreamClient.js\";\nimport { createFeature } from \"~/shared/di/createFeature.js\";\n\nexport const ApiStreamClientFeature = createFeature({\n    name: \"ApiStreamClient\",\n    register(container) {\n        container.register(FetchApiStreamClient).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            client: container.resolve(ApiStreamClient)\n        };\n    }\n});\n"],"names":["ApiStreamClientFeature","createFeature","container","FetchApiStreamClient","ApiStreamClient"],"mappings":";;;AAIO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;IAC7D;IACA,SAAQD,SAAS;QACb,OAAO;YACH,QAAQA,UAAU,OAAO,CAACE;QAC9B;IACJ;AACJ"}

package/features/apiStreamClient/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./abstractions.js";
+export * from "./FetchApiStreamClient.js";
+export * from "./readServerSentEvents.js";
+export * from "./toPayloadHash.js";
+export * from "./feature.js";

package/features/apiStreamClient/index.js

@@ -0,0 +1,5 @@
+export * from "./abstractions.js";
+export * from "./FetchApiStreamClient.js";
+export * from "./readServerSentEvents.js";
+export * from "./toPayloadHash.js";
+export * from "./feature.js";

package/features/apiStreamClient/readServerSentEvents.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read a `text/event-stream` response as a sequence of parsed JSON events.
+ *
+ * Written against `Response.body` rather than `EventSource` on purpose: `EventSource` can only issue
+ * GET requests and cannot set an `Authorization` header, both of which the API requires.
+ *
+ * Only the `data:` field is interpreted — enough for Webiny's streaming routes, which frame one JSON
+ * object per record. Comment lines (`:` heartbeats), `event:`, `id:` and `retry:` are ignored.
+ */
+export declare function readServerSentEvents<TEvent>(response: Response): AsyncGenerator<TEvent>;

package/features/apiStreamClient/readServerSentEvents.js

@@ -0,0 +1,29 @@
+async function* readServerSentEvents(response) {
+    const body = response.body;
+    if (!body) throw new Error("The response carried no readable body.");
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, {
+                stream: true
+            }).replace(/\r\n/g, "\n");
+            let separator = buffer.indexOf("\n\n");
+            while(-1 !== separator){
+                const record = buffer.slice(0, separator);
+                buffer = buffer.slice(separator + 2);
+                const data = record.split("\n").filter((line)=>line.startsWith("data:")).map((line)=>line.slice(5).trim()).join("\n");
+                if (data) yield JSON.parse(data);
+                separator = buffer.indexOf("\n\n");
+            }
+        }
+    } finally{
+        reader.releaseLock();
+    }
+}
+export { readServerSentEvents };
+
+//# sourceMappingURL=readServerSentEvents.js.map

package/features/apiStreamClient/readServerSentEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/readServerSentEvents.js","sources":["../../../src/features/apiStreamClient/readServerSentEvents.ts"],"sourcesContent":["/**\n * Read a `text/event-stream` response as a sequence of parsed JSON events.\n *\n * Written against `Response.body` rather than `EventSource` on purpose: `EventSource` can only issue\n * GET requests and cannot set an `Authorization` header, both of which the API requires.\n *\n * Only the `data:` field is interpreted — enough for Webiny's streaming routes, which frame one JSON\n * object per record. Comment lines (`:` heartbeats), `event:`, `id:` and `retry:` are ignored.\n */\nexport async function* readServerSentEvents<TEvent>(response: Response): AsyncGenerator<TEvent> {\n    const body = response.body;\n    if (!body) {\n        throw new Error(\"The response carried no readable body.\");\n    }\n\n    const reader = body.getReader();\n    const decoder = new TextDecoder();\n    let buffer = \"\";\n\n    try {\n        while (true) {\n            const { done, value } = await reader.read();\n\n            if (done) {\n                break;\n            }\n\n            // `stream: true` keeps a multi-byte character split across chunks intact.\n            buffer += decoder.decode(value, { stream: true }).replace(/\\r\\n/g, \"\\n\");\n\n            let separator = buffer.indexOf(\"\\n\\n\");\n            while (separator !== -1) {\n                const record = buffer.slice(0, separator);\n                buffer = buffer.slice(separator + 2);\n\n                const data = record\n                    .split(\"\\n\")\n                    .filter(line => line.startsWith(\"data:\"))\n                    .map(line => line.slice(\"data:\".length).trim())\n                    .join(\"\\n\");\n\n                if (data) {\n                    yield JSON.parse(data) as TEvent;\n                }\n\n                separator = buffer.indexOf(\"\\n\\n\");\n            }\n        }\n    } finally {\n        reader.releaseLock();\n    }\n}\n"],"names":["readServerSentEvents","response","body","Error","reader","decoder","TextDecoder","buffer","done","value","separator","record","data","line","JSON"],"mappings":"AASO,gBAAgBA,qBAA6BC,QAAkB;IAClE,MAAMC,OAAOD,SAAS,IAAI;IAC1B,IAAI,CAACC,MACD,MAAM,IAAIC,MAAM;IAGpB,MAAMC,SAASF,KAAK,SAAS;IAC7B,MAAMG,UAAU,IAAIC;IACpB,IAAIC,SAAS;IAEb,IAAI;QACA,MAAO,KAAM;YACT,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAML,OAAO,IAAI;YAEzC,IAAII,MACA;YAIJD,UAAUF,QAAQ,MAAM,CAACI,OAAO;gBAAE,QAAQ;YAAK,GAAG,OAAO,CAAC,SAAS;YAEnE,IAAIC,YAAYH,OAAO,OAAO,CAAC;YAC/B,MAAOG,AAAc,OAAdA,UAAkB;gBACrB,MAAMC,SAASJ,OAAO,KAAK,CAAC,GAAGG;gBAC/BH,SAASA,OAAO,KAAK,CAACG,YAAY;gBAElC,MAAME,OAAOD,OACR,KAAK,CAAC,MACN,MAAM,CAACE,CAAAA,OAAQA,KAAK,UAAU,CAAC,UAC/B,GAAG,CAACA,CAAAA,OAAQA,KAAK,KAAK,CAAC,GAAgB,IAAI,IAC3C,IAAI,CAAC;gBAEV,IAAID,MACA,MAAME,KAAK,KAAK,CAACF;gBAGrBF,YAAYH,OAAO,OAAO,CAAC;YAC/B;QACJ;IACJ,SAAU;QACNH,OAAO,WAAW;IACtB;AACJ"}

package/features/apiStreamClient/toPayloadHash.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hex SHA-256 of a request body, for the `x-amz-content-sha256` header.
+ *
+ * Required whenever a streaming route is reached through CloudFront with Origin Access Control. OAC
+ * signs the request with SigV4 but does NOT hash the body itself — it folds whatever this header says
+ * into the signature, and the Lambda Function URL's IAM authorizer then recomputes the hash from the
+ * body it received. Omit the header and the two disagree, so a POST WITH a body is rejected with
+ * `InvalidSignatureException` while a bodyless POST succeeds, because an empty payload hashes
+ * predictably.
+ *
+ * `crypto.subtle` needs a secure context, which the streaming behavior already requires
+ * (`viewerProtocolPolicy: "https-only"`).
+ */
+export declare function toPayloadHash(body: string): Promise<string>;

package/features/apiStreamClient/toPayloadHash.js

@@ -0,0 +1,7 @@
+async function toPayloadHash(body) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+    return Array.from(new Uint8Array(digest)).map((byte)=>byte.toString(16).padStart(2, "0")).join("");
+}
+export { toPayloadHash };
+
+//# sourceMappingURL=toPayloadHash.js.map

package/features/apiStreamClient/toPayloadHash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/apiStreamClient/toPayloadHash.js","sources":["../../../src/features/apiStreamClient/toPayloadHash.ts"],"sourcesContent":["/**\n * Hex SHA-256 of a request body, for the `x-amz-content-sha256` header.\n *\n * Required whenever a streaming route is reached through CloudFront with Origin Access Control. OAC\n * signs the request with SigV4 but does NOT hash the body itself — it folds whatever this header says\n * into the signature, and the Lambda Function URL's IAM authorizer then recomputes the hash from the\n * body it received. Omit the header and the two disagree, so a POST WITH a body is rejected with\n * `InvalidSignatureException` while a bodyless POST succeeds, because an empty payload hashes\n * predictably.\n *\n * `crypto.subtle` needs a secure context, which the streaming behavior already requires\n * (`viewerProtocolPolicy: \"https-only\"`).\n */\nexport async function toPayloadHash(body: string): Promise<string> {\n    const digest = await crypto.subtle.digest(\"SHA-256\", new TextEncoder().encode(body));\n\n    return Array.from(new Uint8Array(digest))\n        .map(byte => byte.toString(16).padStart(2, \"0\"))\n        .join(\"\");\n}\n"],"names":["toPayloadHash","body","digest","crypto","TextEncoder","Array","Uint8Array","byte"],"mappings":"AAaO,eAAeA,cAAcC,IAAY;IAC5C,MAAMC,SAAS,MAAMC,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,IAAIC,cAAc,MAAM,CAACH;IAE9E,OAAOI,MAAM,IAAI,CAAC,IAAIC,WAAWJ,SAC5B,GAAG,CAACK,CAAAA,OAAQA,KAAK,QAAQ,CAAC,IAAI,QAAQ,CAAC,GAAG,MAC1C,IAAI,CAAC;AACd"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/app",
-	"version": "6.6.0-alpha.0",
+	"version": "6.6.0-alpha.2",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -19,31 +19,31 @@
 	"license": "MIT",
 	"dependencies": {
 		"@types/react": "18.3.31",
-		"@webiny/di": "1.0.2",
-		"@webiny/feature": "6.6.0-alpha.0",
-		"@webiny/i18n": "6.6.0-alpha.0",
-		"@webiny/i18n-react": "6.6.0-alpha.0",
-		"@webiny/plugins": "6.6.0-alpha.0",
-		"@webiny/react-composition": "6.6.0-alpha.0",
-		"@webiny/react-properties": "6.6.0-alpha.0",
+		"@webiny/di": "1.1.0",
+		"@webiny/feature": "6.6.0-alpha.2",
+		"@webiny/i18n": "6.6.0-alpha.2",
+		"@webiny/i18n-react": "6.6.0-alpha.2",
+		"@webiny/plugins": "6.6.0-alpha.2",
+		"@webiny/react-composition": "6.6.0-alpha.2",
+		"@webiny/react-properties": "6.6.0-alpha.2",
 		"graphql": "16.14.2",
 		"history": "5.3.0",
 		"invariant": "2.2.4",
 		"lodash": "4.18.1",
-		"mobx": "6.16.1",
+		"mobx": "7.0.3",
 		"react": "18.3.1",
 		"react-dom": "18.3.1",
 		"warning": "4.0.3",
 		"zod": "4.4.3"
 	},
 	"devDependencies": {
-		"@types/lodash": "4.17.24",
+		"@types/lodash": "4.17.25",
 		"@types/warning": "3.0.4",
-		"@webiny/build-tools": "6.6.0-alpha.0",
+		"@webiny/build-tools": "6.6.0-alpha.2",
 		"rimraf": "6.1.3",
 		"type-fest": "5.8.0",
 		"typescript": "7.0.2",
-		"vitest": "4.1.10"
+		"vitest": "4.1.11"
 	},
 	"publishConfig": {
 		"access": "public"