@reproapp/react-sdk 0.0.1 → 0.0.3

package/dist/ingest-worker.d.ts

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

package/dist/ingest-worker.js

@@ -0,0 +1,222 @@
+import { gzip } from 'pako';
+const jsonBytes = (obj) => {
+    try {
+        return new TextEncoder().encode(JSON.stringify(obj)).length;
+    }
+    catch {
+        return Infinity;
+    }
+};
+const splitEventsBySize = (events, maxBytes, mkEnvelope) => {
+    const out = [];
+    const stack = [events.slice(0)];
+    while (stack.length) {
+        const cur = stack.pop();
+        const env = mkEnvelope(cur);
+        if (jsonBytes(env) <= maxBytes || cur.length <= 1) {
+            out.push(cur);
+            continue;
+        }
+        const mid = Math.floor(cur.length / 2);
+        stack.push(cur.slice(0, mid));
+        stack.push(cur.slice(mid));
+    }
+    return out;
+};
+const addTenantHeader = (headers, req) => ({
+    ...headers,
+    [req.headers.ngrokSkipHeader]: req.headers.ngrokSkipValue,
+});
+const postCanonicalEvents = async (req, events) => {
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-App-Id': req.appId,
+            [req.headers.internalHeader]: '1',
+        };
+        if (req.appSecret)
+            headers['X-App-Secret'] = req.appSecret;
+        if (req.appName)
+            headers['X-App-Name'] = req.appName;
+        const resp = await fetch(req.ingestUrl, {
+            method: 'POST',
+            headers: addTenantHeader(headers, req),
+            body: JSON.stringify({ events }),
+        });
+        if (resp.status === 413)
+            return 'too_large';
+        if (!resp.ok)
+            return 'fail';
+        return 'ok';
+    }
+    catch {
+        return 'fail';
+    }
+};
+const sendChunkToLogCollector = async (req, envelope, seq) => {
+    const tFirst = Number(envelope?.tFirst);
+    const tLast = Number(envelope?.tLast);
+    const safeTFirst = Number.isFinite(tFirst) ? tFirst : Date.now();
+    const safeTLast = Number.isFinite(tLast) ? tLast : safeTFirst;
+    const canonical = {
+        schema_version: req.schemaVersion,
+        tenant_id: req.tenantId,
+        app_id: req.appId,
+        session_id: req.sid,
+        event_type: 'rrweb_chunk',
+        event_ts: new Date(safeTLast).toISOString(),
+        actor_id: req.actorId,
+        actor_type: req.actorType,
+        payload: {
+            action_id: req.actionId,
+            seq,
+            tFirst: safeTFirst,
+            tLast: safeTLast,
+            events: Array.isArray(envelope?.events) ? envelope.events : [],
+        },
+    };
+    if (req.actorLabels) {
+        canonical.actor_labels = req.actorLabels;
+    }
+    return postCanonicalEvents(req, [canonical]);
+};
+const sendChunk = async (req, envelope, seq) => {
+    try {
+        const resp = await fetch(`${req.baseUrl}/v1/sessions/${req.sid}/events`, {
+            method: 'POST',
+            headers: addTenantHeader({
+                'Content-Type': 'application/json',
+                'x-sdk-token': req.token,
+                ...(req.userToken ? { Authorization: `Bearer ${req.userToken}` } : {}),
+                [req.headers.internalHeader]: '1',
+            }, req),
+            body: JSON.stringify({ ...envelope, seq }),
+        });
+        if (resp.status === 401)
+            return { status: 'fail', unauthorized: true };
+        if (resp.status === 413)
+            return { status: 'too_large', unauthorized: false };
+        if (!resp.ok)
+            return { status: 'fail', unauthorized: false };
+        return { status: 'ok', unauthorized: false };
+    }
+    catch {
+        return { status: 'fail', unauthorized: false };
+    }
+};
+const sendChunkGzip = async (req, envelope, seq) => {
+    try {
+        const gz = gzip(JSON.stringify({ ...envelope, seq }));
+        const resp = await fetch(`${req.baseUrl}/v1/sessions/${req.sid}/events`, {
+            method: 'POST',
+            headers: addTenantHeader({
+                'Content-Type': 'application/json',
+                'Content-Encoding': 'gzip',
+                'x-sdk-token': req.token,
+                ...(req.userToken ? { Authorization: `Bearer ${req.userToken}` } : {}),
+                [req.headers.internalHeader]: '1',
+            }, req),
+            body: gz,
+        });
+        if (resp.status === 401)
+            return { status: 'fail', unauthorized: true };
+        if (resp.status === 413)
+            return { status: 'too_large', unauthorized: false };
+        if (!resp.ok)
+            return { status: 'fail', unauthorized: false };
+        return { status: 'ok', unauthorized: false };
+    }
+    catch {
+        return { status: 'fail', unauthorized: false };
+    }
+};
+const flushRrweb = async (req) => {
+    const mkEnvelope = (slice) => {
+        const tFirst = slice[0]?.timestamp ?? Date.now();
+        const tLast = slice[slice.length - 1]?.timestamp ?? tFirst;
+        return { type: 'rrweb', seq: req.seqStart, tFirst, tLast, events: slice };
+    };
+    const pieces = splitEventsBySize(req.events, req.maxBytes, mkEnvelope);
+    let sentCount = 0;
+    let nextSeq = req.seqStart;
+    let status = 'ok';
+    let unauthorized = false;
+    for (let i = 0; i < pieces.length; i += 1) {
+        const piece = pieces[i];
+        const pieceSeq = req.seqStart + i;
+        const env = mkEnvelope(piece);
+        let result;
+        if (req.useIngestPipeline) {
+            result = {
+                status: await sendChunkToLogCollector(req, env, pieceSeq),
+                unauthorized: false,
+            };
+        }
+        else if (jsonBytes(env) > 64 * 1024) {
+            result = await sendChunkGzip(req, env, pieceSeq);
+        }
+        else {
+            result = await sendChunk(req, env, pieceSeq);
+        }
+        if (result.status === 'ok') {
+            sentCount += piece.length;
+            nextSeq = pieceSeq + 1;
+            continue;
+        }
+        if (result.status === 'too_large' && piece.length > 1) {
+            pieces.splice(i, 1, ...splitEventsBySize(piece, req.maxBytes, mkEnvelope));
+            i -= 1;
+            continue;
+        }
+        status = result.status;
+        unauthorized = result.unauthorized;
+        break;
+    }
+    return {
+        id: req.id,
+        type: 'flush_rrweb_result',
+        sentCount,
+        nextSeq,
+        status,
+        unauthorized,
+    };
+};
+self.addEventListener('message', (event) => {
+    const message = event.data;
+    if (!message)
+        return;
+    if (message.type === 'post_canonical') {
+        void postCanonicalEvents(message, message.events)
+            .then((status) => {
+            self.postMessage({
+                id: message.id,
+                type: 'post_canonical_result',
+                status,
+            });
+        })
+            .catch(() => {
+            self.postMessage({
+                id: message.id,
+                type: 'post_canonical_result',
+                status: 'fail',
+            });
+        });
+        return;
+    }
+    if (message.type !== 'flush_rrweb')
+        return;
+    void flushRrweb(message)
+        .then((result) => {
+        self.postMessage(result);
+    })
+        .catch(() => {
+        self.postMessage({
+            id: message.id,
+            type: 'flush_rrweb_result',
+            sentCount: 0,
+            nextSeq: message.seqStart,
+            status: 'fail',
+            unauthorized: false,
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/react-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Repro React SDK (MVP)",
   "license": "MIT",
 
@@ -40,6 +40,7 @@
 
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build"
   },