@webiny/app 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

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/features/envConfig/EnvConfig.d.ts

@@ -0,0 +1,7 @@
+import { EnvConfig as Abstraction } from "./abstractions.js";
+export declare class DefaultEnvConfig implements Abstraction.Interface {
+    private readonly env;
+    constructor(env: Abstraction.Config);
+    get<K extends keyof Abstraction.Config>(key: K, defaultValue?: Abstraction.Config[K]): Abstraction.Config[K];
+    getAll(): Abstraction.Config;
+}

package/features/envConfig/EnvConfig.js

@@ -0,0 +1,16 @@
+class DefaultEnvConfig {
+    constructor(env){
+        this.env = env;
+    }
+    get(key, defaultValue) {
+        const rawValue = this.env[key];
+        if (null == rawValue && void 0 !== defaultValue) return defaultValue;
+        return rawValue;
+    }
+    getAll() {
+        return this.env;
+    }
+}
+export { DefaultEnvConfig };
+
+//# sourceMappingURL=EnvConfig.js.map

package/features/envConfig/EnvConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/envConfig/EnvConfig.js","sources":["../../../src/features/envConfig/EnvConfig.ts"],"sourcesContent":["import { EnvConfig as Abstraction } from \"./abstractions.js\";\n\nexport class DefaultEnvConfig implements Abstraction.Interface {\n    private readonly env: Abstraction.Config;\n\n    constructor(env: Abstraction.Config) {\n        this.env = env;\n    }\n\n    public get<K extends keyof Abstraction.Config>(\n        key: K,\n        defaultValue?: Abstraction.Config[K]\n    ): Abstraction.Config[K] {\n        const rawValue = this.env[key];\n\n        if ((rawValue === undefined || rawValue === null) && defaultValue !== undefined) {\n            return defaultValue;\n        }\n\n        return rawValue;\n    }\n\n    getAll(): Abstraction.Config {\n        return this.env;\n    }\n}\n"],"names":["DefaultEnvConfig","env","key","defaultValue","rawValue","undefined"],"mappings":"AAEO,MAAMA;IAGT,YAAYC,GAAuB,CAAE;QACjC,IAAI,CAAC,GAAG,GAAGA;IACf;IAEO,IACHC,GAAM,EACNC,YAAoC,EACf;QACrB,MAAMC,WAAW,IAAI,CAAC,GAAG,CAACF,IAAI;QAE9B,IAAKE,QAAAA,YAAgDD,AAAiBE,WAAjBF,cACjD,OAAOA;QAGX,OAAOC;IACX;IAEA,SAA6B;QACzB,OAAO,IAAI,CAAC,GAAG;IACnB;AACJ"}

package/features/envConfig/abstractions.d.ts

@@ -0,0 +1,28 @@
+import { Abstraction } from "@webiny/di";
+type Env = {
+    apiUrl: string;
+    debug: boolean;
+    deploymentId: string;
+    graphqlApiUrl: string;
+    telemetryEnabled: boolean;
+    telemetryUserId: string | undefined;
+    trashBinRetentionPeriodDays: number;
+    wcpProjectId: string | undefined;
+    websocketUrl: string;
+    graphqlClient?: {
+        retries: {
+            maxRetries: number;
+            delayInMillis: number;
+        };
+    };
+};
+export interface IEnvConfig {
+    get<K extends keyof Env>(key: K, defaultValue?: Env[K]): Env[K];
+    getAll(): Env;
+}
+export declare const EnvConfig: Abstraction<IEnvConfig>;
+export declare namespace EnvConfig {
+    type Interface = IEnvConfig;
+    type Config = Env;
+}
+export {};

package/features/envConfig/abstractions.js

@@ -0,0 +1,5 @@
+import { Abstraction } from "@webiny/di";
+const EnvConfig = new Abstraction("EnvConfig");
+export { EnvConfig };
+
+//# sourceMappingURL=abstractions.js.map

package/features/envConfig/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/envConfig/abstractions.js","sources":["../../../src/features/envConfig/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\ntype Env = {\n    apiUrl: string;\n    debug: boolean;\n    deploymentId: string;\n    graphqlApiUrl: string;\n    telemetryEnabled: boolean;\n    telemetryUserId: string | undefined;\n    trashBinRetentionPeriodDays: number;\n    wcpProjectId: string | undefined;\n    websocketUrl: string;\n    graphqlClient?: {\n        retries: {\n            maxRetries: number;\n            delayInMillis: number;\n        };\n    };\n};\n\nexport interface IEnvConfig {\n    get<K extends keyof Env>(key: K, defaultValue?: Env[K]): Env[K];\n    getAll(): Env;\n}\n\nexport const EnvConfig = new Abstraction<IEnvConfig>(\"EnvConfig\");\n\nexport namespace EnvConfig {\n    export type Interface = IEnvConfig;\n    export type Config = Env;\n}\n"],"names":["EnvConfig","Abstraction"],"mappings":";AAyBO,MAAMA,YAAY,IAAIC,YAAwB"}

package/features/envConfig/feature.d.ts

@@ -0,0 +1,17 @@
+export declare const EnvConfigFeature: import("~/shared/di/createFeature.js").FeatureDefinition<import("./abstractions.js").IEnvConfig, [params: {
+    apiUrl: string;
+    debug: boolean;
+    deploymentId: string;
+    graphqlApiUrl: string;
+    telemetryEnabled: boolean;
+    telemetryUserId: string | undefined;
+    trashBinRetentionPeriodDays: number;
+    wcpProjectId: string | undefined;
+    websocketUrl: string;
+    graphqlClient?: {
+        retries: {
+            maxRetries: number;
+            delayInMillis: number;
+        };
+    };
+}]>;

package/features/envConfig/feature.js

@@ -0,0 +1,15 @@
+import { EnvConfig } from "./abstractions.js";
+import { DefaultEnvConfig } from "./EnvConfig.js";
+import { createFeature } from "../../shared/di/createFeature.js";
+const EnvConfigFeature = createFeature({
+    name: "EnvConfig",
+    register (container, params) {
+        container.registerInstance(EnvConfig, new DefaultEnvConfig(params));
+    },
+    resolve (container) {
+        return container.resolve(EnvConfig);
+    }
+});
+export { EnvConfigFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/envConfig/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/envConfig/feature.js","sources":["../../../src/features/envConfig/feature.ts"],"sourcesContent":["import { EnvConfig } from \"./abstractions.js\";\nimport { DefaultEnvConfig } from \"./EnvConfig.js\";\nimport { createFeature } from \"~/shared/di/createFeature.js\";\n\nexport const EnvConfigFeature = createFeature({\n    name: \"EnvConfig\",\n    register(container, params: EnvConfig.Config) {\n        container.registerInstance(EnvConfig, new DefaultEnvConfig(params));\n    },\n    resolve(container) {\n        return container.resolve(EnvConfig);\n    }\n});\n"],"names":["EnvConfigFeature","createFeature","container","params","EnvConfig","DefaultEnvConfig"],"mappings":";;;AAIO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS,EAAEC,MAAwB;QACxCD,UAAU,gBAAgB,CAACE,WAAW,IAAIC,iBAAiBF;IAC/D;IACA,SAAQD,SAAS;QACb,OAAOA,UAAU,OAAO,CAACE;IAC7B;AACJ"}

package/features/envConfig/index.d.ts

@@ -0,0 +1 @@
+export { EnvConfig } from "./abstractions.js";

package/features/envConfig/index.js

@@ -0,0 +1 @@
+export { EnvConfig } from "./abstractions.js";

package/features/eventPublisher/EventPublisher.d.ts

@@ -0,0 +1,8 @@
+import type { Container } from "@webiny/di";
+import { EventPublisher as Abstraction, BaseEvent } from "./abstractions.js";
+export declare class EventPublisher implements Abstraction.Interface {
+    private container;
+    constructor(container: Container);
+    publish<TEvent extends BaseEvent>(event: TEvent): Promise<void>;
+    private logEvent;
+}

package/features/eventPublisher/EventPublisher.js

@@ -0,0 +1,19 @@
+import { EnvConfig } from "../envConfig/index.js";
+class EventPublisher {
+    constructor(container){
+        this.container = container;
+    }
+    async publish(event) {
+        this.logEvent(event);
+        const handlerAbstraction = event.getHandlerAbstraction();
+        const handlers = this.container.resolveAll(handlerAbstraction);
+        for (const handler of handlers)await handler.handle(event);
+    }
+    logEvent(event) {
+        const envConfig = this.container.resolve(EnvConfig);
+        if (envConfig.get("debug")) console.log(`[EventPublisher] Publishing event "${event.eventType}".`, event.payload);
+    }
+}
+export { EventPublisher };
+
+//# sourceMappingURL=EventPublisher.js.map

package/features/eventPublisher/EventPublisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/eventPublisher/EventPublisher.js","sources":["../../../src/features/eventPublisher/EventPublisher.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventPublisher as Abstraction, BaseEvent } from \"./abstractions.js\";\nimport { EnvConfig } from \"~/features/envConfig/index.js\";\n\nexport class EventPublisher implements Abstraction.Interface {\n    constructor(private container: Container) {}\n\n    async publish<TEvent extends BaseEvent>(event: TEvent): Promise<void> {\n        this.logEvent(event);\n        // Get handler abstraction from the event itself\n        const handlerAbstraction = event.getHandlerAbstraction();\n\n        // Resolve ALL implementations of that abstraction\n        const handlers = this.container.resolveAll(handlerAbstraction);\n\n        // Execute all handlers\n        for (const handler of handlers) {\n            await handler.handle(event);\n        }\n    }\n\n    private logEvent(event: BaseEvent) {\n        const envConfig = this.container.resolve(EnvConfig);\n        if (envConfig.get(\"debug\")) {\n            console.log(`[EventPublisher] Publishing event \"${event.eventType}\".`, event.payload);\n        }\n    }\n}\n"],"names":["EventPublisher","container","event","handlerAbstraction","handlers","handler","envConfig","EnvConfig","console"],"mappings":";AAIO,MAAMA;IACT,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;IAAuB;IAE3C,MAAM,QAAkCC,KAAa,EAAiB;QAClE,IAAI,CAAC,QAAQ,CAACA;QAEd,MAAMC,qBAAqBD,MAAM,qBAAqB;QAGtD,MAAME,WAAW,IAAI,CAAC,SAAS,CAAC,UAAU,CAACD;QAG3C,KAAK,MAAME,WAAWD,SAClB,MAAMC,QAAQ,MAAM,CAACH;IAE7B;IAEQ,SAASA,KAAgB,EAAE;QAC/B,MAAMI,YAAY,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC;QACzC,IAAID,UAAU,GAAG,CAAC,UACdE,QAAQ,GAAG,CAAC,CAAC,mCAAmC,EAAEN,MAAM,SAAS,CAAC,EAAE,CAAC,EAAEA,MAAM,OAAO;IAE5F;AACJ"}

package/features/eventPublisher/abstractions.d.ts

@@ -0,0 +1,18 @@
+import type { Abstraction } from "@webiny/di";
+export declare abstract class BaseEvent<TPayload = void> {
+    abstract readonly eventType: string;
+    readonly occurredAt: Date;
+    readonly payload: TPayload extends void ? undefined : TPayload;
+    constructor(payload: TPayload);
+    abstract getHandlerAbstraction(): Abstraction<IEventHandler<any>>;
+}
+export interface IEventHandler<TEvent extends BaseEvent<any> = BaseEvent<any>> {
+    handle(event: TEvent): Promise<void>;
+}
+export interface IEventPublisher {
+    publish<TEvent extends BaseEvent<any>>(event: TEvent): Promise<void>;
+}
+export declare const EventPublisher: Abstraction<IEventPublisher>;
+export declare namespace EventPublisher {
+    type Interface = IEventPublisher;
+}

package/features/eventPublisher/abstractions.js

@@ -0,0 +1,12 @@
+import { createAbstraction } from "@webiny/feature/admin";
+class BaseEvent {
+    constructor(payload){
+        this.occurredAt = new Date();
+        if (void 0 === payload) this.payload = void 0;
+        else this.payload = payload;
+    }
+}
+const EventPublisher = createAbstraction("EventPublisher");
+export { BaseEvent, EventPublisher };
+
+//# sourceMappingURL=abstractions.js.map

package/features/eventPublisher/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/eventPublisher/abstractions.js","sources":["../../../src/features/eventPublisher/abstractions.ts"],"sourcesContent":["import type { Abstraction } from \"@webiny/di\";\nimport { createAbstraction } from \"@webiny/feature/admin\";\n\nexport abstract class BaseEvent<TPayload = void> {\n    public abstract readonly eventType: string;\n    public readonly occurredAt: Date;\n    public readonly payload: TPayload extends void ? undefined : TPayload;\n\n    constructor(payload: TPayload);\n    constructor(payload?: never) {\n        this.occurredAt = new Date();\n\n        if (payload === undefined) {\n            this.payload = undefined as any;\n        } else {\n            this.payload = payload;\n        }\n    }\n\n    abstract getHandlerAbstraction(): Abstraction<IEventHandler<any>>;\n}\n\nexport interface IEventHandler<TEvent extends BaseEvent<any> = BaseEvent<any>> {\n    handle(event: TEvent): Promise<void>;\n}\n\nexport interface IEventPublisher {\n    publish<TEvent extends BaseEvent<any>>(event: TEvent): Promise<void>;\n}\n\nexport const EventPublisher = createAbstraction<IEventPublisher>(\"EventPublisher\");\n\nexport namespace EventPublisher {\n    export type Interface = IEventPublisher;\n}\n"],"names":["BaseEvent","payload","Date","undefined","EventPublisher","createAbstraction"],"mappings":";AAGO,MAAeA;IAMlB,YAAYC,OAAe,CAAE;QACzB,IAAI,CAAC,UAAU,GAAG,IAAIC;QAEtB,IAAID,AAAYE,WAAZF,SACA,IAAI,CAAC,OAAO,GAAGE;aAEf,IAAI,CAAC,OAAO,GAAGF;IAEvB;AAGJ;AAUO,MAAMG,iBAAiBC,kBAAmC"}

package/features/eventPublisher/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const EventPublisherFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    eventPublisher: import("./abstractions.js").IEventPublisher;
+}, []>;

package/features/eventPublisher/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/admin";
+import { EventPublisher } from "./abstractions.js";
+import { EventPublisher as external_EventPublisher_js_EventPublisher } from "./EventPublisher.js";
+const EventPublisherFeature = createFeature({
+    name: "EventPublisher",
+    register (container) {
+        container.registerInstance(EventPublisher, new external_EventPublisher_js_EventPublisher(container));
+    },
+    resolve (container) {
+        return {
+            eventPublisher: container.resolve(EventPublisher)
+        };
+    }
+});
+export { EventPublisherFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/eventPublisher/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/eventPublisher/feature.js","sources":["../../../src/features/eventPublisher/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisher as EventPublisherAbstraction } from \"./abstractions.js\";\nimport { EventPublisher } from \"./EventPublisher.js\";\n\nexport const EventPublisherFeature = createFeature({\n    name: \"EventPublisher\",\n    register(container: Container) {\n        container.registerInstance(EventPublisherAbstraction, new EventPublisher(container));\n    },\n    resolve(container: Container) {\n        return {\n            eventPublisher: container.resolve(EventPublisherAbstraction)\n        };\n    }\n});\n"],"names":["EventPublisherFeature","createFeature","container","EventPublisherAbstraction","EventPublisher"],"mappings":";;;AAKO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,gBAAgB,CAACC,gBAA2B,IAAIC,0CAAeF;IAC7E;IACA,SAAQA,SAAoB;QACxB,OAAO;YACH,gBAAgBA,UAAU,OAAO,CAACC;QACtC;IACJ;AACJ"}

package/features/eventPublisher/index.d.ts

@@ -0,0 +1,3 @@
+export { EventPublisher, BaseEvent } from "./abstractions.js";
+export type { IEventHandler, IEventPublisher } from "./abstractions.js";
+export { EventPublisherFeature } from "./feature.js";

package/features/eventPublisher/index.js

@@ -0,0 +1,2 @@
+export { BaseEvent, EventPublisher } from "./abstractions.js";
+export { EventPublisherFeature } from "./feature.js";

package/features/graphqlClient/AuthenticationErrorPublishing.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLClient } from "./abstractions.js";
+import { EventPublisher } from "../../features/eventPublisher/index.js";
+declare class AuthenticationErrorPublishingDecorator implements GraphQLClient.Interface {
+    private eventPublisher;
+    private decoratee;
+    constructor(eventPublisher: EventPublisher.Interface, decoratee: GraphQLClient.Interface);
+    execute<TResult = any, TVariables = any>(params: GraphQLClient.Request<TVariables>): Promise<TResult>;
+    private isAuthenticationError;
+}
+export declare const AuthenticationErrorPublishing: typeof AuthenticationErrorPublishingDecorator & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGraphQLClient>;
+};
+export {};