Add ZIP upload of sourcemaps.

tools/sourcemap-tools/package.json

@@ -37,13 +37,17 @@
     },
     "homepage": "https://github.com/backtrace-labs/backtrace-javascript#readme",
     "devDependencies": {
+        "@types/archiver": "^5.3.2",
+        "@types/decompress": "^4.2.4",
         "@types/jest": "^29.5.1",
+        "decompress": "^4.2.1",
         "jest": "^29.5.0",
         "nock": "^13.3.1",
         "ts-jest": "^29.1.0",
         "typescript": "^5.0.4"
     },
     "dependencies": {
+        "archiver": "^5.3.1",
         "source-map": "^0.7.4"
     }
 }

tools/sourcemap-tools/src/SymbolUploader.ts

@@ -0,0 +1,86 @@
+import http from 'http';
+import https from 'https';
+import { Readable } from 'stream';
+
+interface CoronerUploadResponse {
+    response: 'ok' | string;
+    _rxid: string;
+}
+
+export interface UploadResult {
+    rxid: string;
+}
+
+export interface SymbolUploaderOptions {
+    ignoreSsl?: boolean;
+    headers?: http.OutgoingHttpHeaders;
+}
+
+/**
+ * Class responsible for uploading symbols to Backtrace.
+ *
+ * Expects symbol upload responses.
+ */
+export class SymbolUploader {
+    private readonly _url: URL;
+
+    constructor(url: string | URL, private readonly _options?: SymbolUploaderOptions) {
+        this._url = new URL(url);
+    }
+
+    /**
+     * Uploads the symbol to Backtrace.
+     * @param content Symbol stream.
+     */
+    public async uploadSymbol(readable: Readable): Promise<UploadResult> {
+        const protocol = this._url.protocol === 'https:' ? https : http;
+
+        return new Promise<UploadResult>((resolve, reject) => {
+            const request = protocol.request(
+                this._url,
+                {
+                    method: 'POST',
+                    rejectUnauthorized: !this._options?.ignoreSsl,
+                    headers: this._options?.headers,
+                },
+                (response) => {
+                    if (!response.statusCode) {
+                        return reject(new Error('Failed to upload symbol: failed to make the request.'));
+                    }
+
+                    const data: Buffer[] = [];
+                    response.on('data', (chunk) => {
+                        data.push(chunk);
+                    });
+
+                    response.on('end', () => {
+                        const rawResponse = Buffer.concat(data).toString('utf-8');
+                        if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
+                            return reject(
+                                new Error(
+                                    `Failed to upload symbol: ${response.statusCode}. Response data: ${rawResponse}`,
+                                ),
+                            );
+                        }
+
+                        try {
+                            const responseData = JSON.parse(rawResponse) as CoronerUploadResponse;
+                            if (responseData.response === 'ok') {
+                                return resolve({
+                                    rxid: responseData._rxid,
+                                });
+                            } else {
+                                return reject(new Error(`Non-OK response received from Coroner: ${rawResponse}`));
+                            }
+                        } catch (err) {
+                            return reject(new Error(`Cannot parse response from Coroner: ${rawResponse}`));
+                        }
+                    });
+                },
+            );
+
+            request.on('error', reject);
+            readable.pipe(request);
+        });
+    }
+}

tools/sourcemap-tools/src/ZipArchive.ts

@@ -0,0 +1,32 @@
+import archiver from 'archiver';
+import { Readable, Transform, TransformCallback, TransformOptions } from 'stream';
+
+export class ZipArchive extends Transform {
+    private readonly _archive: archiver.Archiver;
+
+    constructor(opts?: TransformOptions) {
+        super(opts);
+        this._archive = archiver('zip');
+    }
+
+    public append(name: string, sourceMap: string | Readable | Buffer) {
+        this._archive.append(sourceMap, { name });
+        return this;
+    }
+
+    public finalize() {
+        return this._archive.finalize();
+    }
+
+    public override pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean }): T {
+        return this._archive.pipe(destination, options);
+    }
+
+    public override _transform(chunk: unknown, encoding: BufferEncoding, callback: TransformCallback): void {
+        return this._archive._transform(chunk, encoding, callback);
+    }
+
+    public override _flush(callback: TransformCallback): void {
+        return this._archive._flush(callback);
+    }
+}

tools/sourcemap-tools/src/index.ts

@@ -1,4 +1,5 @@
 export * from './ContentAppender';
 export * from './DebugIdGenerator';
-export * from './SourceMapUploader';
 export * from './SourceProcessor';
+export * from './SymbolUploader';
+export * from './ZipArchive';

tools/sourcemap-tools/tests/.gitignore

@@ -0,0 +1 @@
+testOutput/