@milaboratories/pl-drivers 1.9.0 → 1.10.0

package/dist/clients/progress.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var protocol_client = require('../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client.cjs');
+var duration = require('../proto/google/protobuf/duration.cjs');
+var plClient = require('@milaboratories/pl-client');
+var tsHelpers = require('@milaboratories/ts-helpers');
+
+// ClientProgress holds a grpc connection to the platform
+// but for Progress API service.
+// When blobs are transfered, one can got a status of transfering
+// using this API.
+class ClientProgress {
+    client;
+    logger;
+    grpcClient;
+    constructor(grpcClientProviderFactory, _, client, logger) {
+        this.client = client;
+        this.logger = logger;
+        this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new protocol_client.ProgressClient(transport));
+    }
+    close() { }
+    /** getStatus gets a progress status by given rId and rType. */
+    async getStatus({ id, type }, options) {
+        const status = await this.grpcClient.get().getStatus({ resourceId: id }, plClient.addRTypeToMetadata(type, options));
+        const report = tsHelpers.notEmpty(status.response.report);
+        return {
+            done: report.done,
+            progress: report.progress,
+            bytesProcessed: String(report.bytesProcessed),
+            bytesTotal: String(report.bytesTotal),
+        };
+    }
+    // realtimeStatus returns a async generator that takes statuses from
+    // GRPC stream every updateIntervalMs milliseconds.
+    async *realtimeStatus({ id, type }, updateIntervalMs = 100, options) {
+        options = plClient.addRTypeToMetadata(type, options);
+        const secs = Math.floor(updateIntervalMs / 1000);
+        const nanos = (updateIntervalMs - secs * 1000) * 1000000;
+        const updateInterval = duration.Duration.create({
+            seconds: BigInt(secs),
+            nanos: nanos,
+        });
+        try {
+            const { responses } = this.grpcClient.get().realtimeStatus({
+                resourceId: id,
+                updateInterval: updateInterval,
+            }, options);
+            yield* responses;
+        }
+        catch (e) {
+            this.logger.warn('Failed to get realtime status' + String(e));
+            throw e;
+        }
+    }
+}
+
+exports.ClientProgress = ClientProgress;
+//# sourceMappingURL=progress.cjs.map

package/dist/clients/progress.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.cjs","sources":["../../src/clients/progress.ts"],"sourcesContent":["import { ProgressClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client';\nimport type { RpcOptions } from '@protobuf-ts/runtime-rpc';\nimport { Duration } from '../proto/google/protobuf/duration';\nimport type { GrpcClientProvider, GrpcClientProviderFactory, PlClient } from '@milaboratories/pl-client';\nimport { addRTypeToMetadata } from '@milaboratories/pl-client';\nimport type { MiLogger } from '@milaboratories/ts-helpers';\nimport { notEmpty } from '@milaboratories/ts-helpers';\nimport type { Dispatcher } from 'undici';\nimport type { ResourceInfo } from '@milaboratories/pl-tree';\n\nexport type ProgressStatus = {\n  done: boolean;\n  progress: number;\n  bytesProcessed?: string;\n  bytesTotal?: string;\n};\n\n// ClientProgress holds a grpc connection to the platform\n// but for Progress API service.\n// When blobs are transfered, one can got a status of transfering\n// using this API.\nexport class ClientProgress {\n  public readonly grpcClient: GrpcClientProvider<ProgressClient>;\n\n  constructor(\n    grpcClientProviderFactory: GrpcClientProviderFactory,\n    _: Dispatcher,\n    public readonly client: PlClient,\n    public readonly logger: MiLogger,\n  ) {\n    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new ProgressClient(transport));\n  }\n\n  close() {}\n\n  /** getStatus gets a progress status by given rId and rType. */\n  async getStatus({ id, type }: ResourceInfo, options?: RpcOptions): Promise<ProgressStatus> {\n    const status = await this.grpcClient.get().getStatus(\n      { resourceId: id },\n      addRTypeToMetadata(type, options),\n    );\n\n    const report = notEmpty(status.response.report);\n\n    return {\n      done: report.done,\n      progress: report.progress,\n      bytesProcessed: String(report.bytesProcessed),\n      bytesTotal: String(report.bytesTotal),\n    };\n  }\n\n  // realtimeStatus returns a async generator that takes statuses from\n  // GRPC stream every updateIntervalMs milliseconds.\n  async *realtimeStatus(\n    { id, type }: ResourceInfo,\n    updateIntervalMs: number = 100,\n    options?: RpcOptions,\n  ) {\n    options = addRTypeToMetadata(type, options);\n\n    const secs = Math.floor(updateIntervalMs / 1000);\n    const nanos = (updateIntervalMs - secs * 1000) * 1000000;\n    const updateInterval = Duration.create({\n      seconds: BigInt(secs),\n      nanos: nanos,\n    });\n\n    try {\n      const { responses } = this.grpcClient.get().realtimeStatus(\n        {\n          resourceId: id,\n          updateInterval: updateInterval,\n        },\n        options,\n      );\n\n      yield * responses;\n    } catch (e) {\n      this.logger.warn('Failed to get realtime status' + String(e));\n      throw e;\n    }\n  }\n}\n"],"names":["ProgressClient","addRTypeToMetadata","notEmpty","Duration"],"mappings":";;;;;;;AAiBA;AACA;AACA;AACA;MACa,cAAc,CAAA;AAMP,IAAA,MAAA;AACA,IAAA,MAAA;AANF,IAAA,UAAU;AAE1B,IAAA,WAAA,CACE,yBAAoD,EACpD,CAAa,EACG,MAAgB,EAChB,MAAgB,EAAA;QADhB,IAAA,CAAA,MAAM,GAAN,MAAM;QACN,IAAA,CAAA,MAAM,GAAN,MAAM;AAEtB,QAAA,IAAI,CAAC,UAAU,GAAG,yBAAyB,CAAC,wBAAwB,CAAC,CAAC,SAAS,KAAK,IAAIA,8BAAc,CAAC,SAAS,CAAC,CAAC;IACpH;AAEA,IAAA,KAAK,KAAI;;IAGT,MAAM,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,EAAgB,EAAE,OAAoB,EAAA;QAC9D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,CAClD,EAAE,UAAU,EAAE,EAAE,EAAE,EAClBC,2BAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,CAClC;QAED,MAAM,MAAM,GAAGC,kBAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;QAE/C,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AACzB,YAAA,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC;AAC7C,YAAA,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;SACtC;IACH;;;AAIA,IAAA,OAAO,cAAc,CACnB,EAAE,EAAE,EAAE,IAAI,EAAgB,EAC1B,gBAAA,GAA2B,GAAG,EAC9B,OAAoB,EAAA;AAEpB,QAAA,OAAO,GAAGD,2BAAkB,CAAC,IAAI,EAAE,OAAO,CAAC;QAE3C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAChD,MAAM,KAAK,GAAG,CAAC,gBAAgB,GAAG,IAAI,GAAG,IAAI,IAAI,OAAO;AACxD,QAAA,MAAM,cAAc,GAAGE,iBAAQ,CAAC,MAAM,CAAC;AACrC,YAAA,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC;AACrB,YAAA,KAAK,EAAE,KAAK;AACb,SAAA,CAAC;AAEF,QAAA,IAAI;AACF,YAAA,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,cAAc,CACxD;AACE,gBAAA,UAAU,EAAE,EAAE;AACd,gBAAA,cAAc,EAAE,cAAc;aAC/B,EACD,OAAO,CACR;YAED,OAAQ,SAAS;QACnB;QAAE,OAAO,CAAC,EAAE;AACV,YAAA,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAC7D,YAAA,MAAM,CAAC;QACT;IACF;AACD;;;;"}

package/dist/clients/progress.d.ts

@@ -4,7 +4,6 @@ import { GrpcClientProvider, GrpcClientProviderFactory, PlClient } from '@milabo
 import { MiLogger } from '@milaboratories/ts-helpers';
 import { Dispatcher } from 'undici';
 import { ResourceInfo } from '@milaboratories/pl-tree';
-import { ProgressAPI_RealtimeStatus_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol';
 export type ProgressStatus = {
     done: boolean;
     progress: number;
@@ -19,6 +18,5 @@ export declare class ClientProgress {
     close(): void;
     /** getStatus gets a progress status by given rId and rType. */
     getStatus({ id, type }: ResourceInfo, options?: RpcOptions): Promise<ProgressStatus>;
-    realtimeStatus({ id, type }: ResourceInfo, updateIntervalMs?: number, options?: RpcOptions): AsyncGenerator< ProgressAPI_RealtimeStatus_Response, void, any>;
+    realtimeStatus({ id, type }: ResourceInfo, updateIntervalMs?: number, options?: RpcOptions): AsyncGenerator<import('../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol').ProgressAPI_RealtimeStatus_Response, void, any>;
 }
-//# sourceMappingURL=progress.d.ts.map

package/dist/clients/progress.js

@@ -0,0 +1,56 @@
+import { ProgressClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client.js';
+import { Duration } from '../proto/google/protobuf/duration.js';
+import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import { notEmpty } from '@milaboratories/ts-helpers';
+
+// ClientProgress holds a grpc connection to the platform
+// but for Progress API service.
+// When blobs are transfered, one can got a status of transfering
+// using this API.
+class ClientProgress {
+    client;
+    logger;
+    grpcClient;
+    constructor(grpcClientProviderFactory, _, client, logger) {
+        this.client = client;
+        this.logger = logger;
+        this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new ProgressClient(transport));
+    }
+    close() { }
+    /** getStatus gets a progress status by given rId and rType. */
+    async getStatus({ id, type }, options) {
+        const status = await this.grpcClient.get().getStatus({ resourceId: id }, addRTypeToMetadata(type, options));
+        const report = notEmpty(status.response.report);
+        return {
+            done: report.done,
+            progress: report.progress,
+            bytesProcessed: String(report.bytesProcessed),
+            bytesTotal: String(report.bytesTotal),
+        };
+    }
+    // realtimeStatus returns a async generator that takes statuses from
+    // GRPC stream every updateIntervalMs milliseconds.
+    async *realtimeStatus({ id, type }, updateIntervalMs = 100, options) {
+        options = addRTypeToMetadata(type, options);
+        const secs = Math.floor(updateIntervalMs / 1000);
+        const nanos = (updateIntervalMs - secs * 1000) * 1000000;
+        const updateInterval = Duration.create({
+            seconds: BigInt(secs),
+            nanos: nanos,
+        });
+        try {
+            const { responses } = this.grpcClient.get().realtimeStatus({
+                resourceId: id,
+                updateInterval: updateInterval,
+            }, options);
+            yield* responses;
+        }
+        catch (e) {
+            this.logger.warn('Failed to get realtime status' + String(e));
+            throw e;
+        }
+    }
+}
+
+export { ClientProgress };
+//# sourceMappingURL=progress.js.map

package/dist/clients/progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.js","sources":["../../src/clients/progress.ts"],"sourcesContent":["import { ProgressClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client';\nimport type { RpcOptions } from '@protobuf-ts/runtime-rpc';\nimport { Duration } from '../proto/google/protobuf/duration';\nimport type { GrpcClientProvider, GrpcClientProviderFactory, PlClient } from '@milaboratories/pl-client';\nimport { addRTypeToMetadata } from '@milaboratories/pl-client';\nimport type { MiLogger } from '@milaboratories/ts-helpers';\nimport { notEmpty } from '@milaboratories/ts-helpers';\nimport type { Dispatcher } from 'undici';\nimport type { ResourceInfo } from '@milaboratories/pl-tree';\n\nexport type ProgressStatus = {\n  done: boolean;\n  progress: number;\n  bytesProcessed?: string;\n  bytesTotal?: string;\n};\n\n// ClientProgress holds a grpc connection to the platform\n// but for Progress API service.\n// When blobs are transfered, one can got a status of transfering\n// using this API.\nexport class ClientProgress {\n  public readonly grpcClient: GrpcClientProvider<ProgressClient>;\n\n  constructor(\n    grpcClientProviderFactory: GrpcClientProviderFactory,\n    _: Dispatcher,\n    public readonly client: PlClient,\n    public readonly logger: MiLogger,\n  ) {\n    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new ProgressClient(transport));\n  }\n\n  close() {}\n\n  /** getStatus gets a progress status by given rId and rType. */\n  async getStatus({ id, type }: ResourceInfo, options?: RpcOptions): Promise<ProgressStatus> {\n    const status = await this.grpcClient.get().getStatus(\n      { resourceId: id },\n      addRTypeToMetadata(type, options),\n    );\n\n    const report = notEmpty(status.response.report);\n\n    return {\n      done: report.done,\n      progress: report.progress,\n      bytesProcessed: String(report.bytesProcessed),\n      bytesTotal: String(report.bytesTotal),\n    };\n  }\n\n  // realtimeStatus returns a async generator that takes statuses from\n  // GRPC stream every updateIntervalMs milliseconds.\n  async *realtimeStatus(\n    { id, type }: ResourceInfo,\n    updateIntervalMs: number = 100,\n    options?: RpcOptions,\n  ) {\n    options = addRTypeToMetadata(type, options);\n\n    const secs = Math.floor(updateIntervalMs / 1000);\n    const nanos = (updateIntervalMs - secs * 1000) * 1000000;\n    const updateInterval = Duration.create({\n      seconds: BigInt(secs),\n      nanos: nanos,\n    });\n\n    try {\n      const { responses } = this.grpcClient.get().realtimeStatus(\n        {\n          resourceId: id,\n          updateInterval: updateInterval,\n        },\n        options,\n      );\n\n      yield * responses;\n    } catch (e) {\n      this.logger.warn('Failed to get realtime status' + String(e));\n      throw e;\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;AAiBA;AACA;AACA;AACA;MACa,cAAc,CAAA;AAMP,IAAA,MAAA;AACA,IAAA,MAAA;AANF,IAAA,UAAU;AAE1B,IAAA,WAAA,CACE,yBAAoD,EACpD,CAAa,EACG,MAAgB,EAChB,MAAgB,EAAA;QADhB,IAAA,CAAA,MAAM,GAAN,MAAM;QACN,IAAA,CAAA,MAAM,GAAN,MAAM;AAEtB,QAAA,IAAI,CAAC,UAAU,GAAG,yBAAyB,CAAC,wBAAwB,CAAC,CAAC,SAAS,KAAK,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;IACpH;AAEA,IAAA,KAAK,KAAI;;IAGT,MAAM,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,EAAgB,EAAE,OAAoB,EAAA;QAC9D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,CAClD,EAAE,UAAU,EAAE,EAAE,EAAE,EAClB,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,CAClC;QAED,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;QAE/C,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ;AACzB,YAAA,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC;AAC7C,YAAA,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;SACtC;IACH;;;AAIA,IAAA,OAAO,cAAc,CACnB,EAAE,EAAE,EAAE,IAAI,EAAgB,EAC1B,gBAAA,GAA2B,GAAG,EAC9B,OAAoB,EAAA;AAEpB,QAAA,OAAO,GAAG,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC;QAE3C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAChD,MAAM,KAAK,GAAG,CAAC,gBAAgB,GAAG,IAAI,GAAG,IAAI,IAAI,OAAO;AACxD,QAAA,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC;AACrC,YAAA,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC;AACrB,YAAA,KAAK,EAAE,KAAK;AACb,SAAA,CAAC;AAEF,QAAA,IAAI;AACF,YAAA,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,cAAc,CACxD;AACE,gBAAA,UAAU,EAAE,EAAE;AACd,gBAAA,cAAc,EAAE,cAAc;aAC/B,EACD,OAAO,CACR;YAED,OAAQ,SAAS;QACnB;QAAE,OAAO,CAAC,EAAE;AACV,YAAA,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,+BAA+B,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAC7D,YAAA,MAAM,CAAC;QACT;IACF;AACD;;;;"}

package/dist/clients/upload.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+var plClient = require('@milaboratories/pl-client');
+var fsp = require('node:fs/promises');
+var undici = require('undici');
+var crc32 = require('@node-rs/crc32');
+var protocol = require('../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.cjs');
+var protocol_client = require('../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fsp__namespace = /*#__PURE__*/_interopNamespaceDefault(fsp);
+
+class MTimeError extends Error {
+    name = 'MTimeError';
+}
+class UnexpectedEOF extends Error {
+    name = 'UnexpectedEOF';
+}
+class NetworkError extends Error {
+    name = 'NetworkError';
+}
+/** Happens when the file doesn't exist */
+class NoFileForUploading extends Error {
+    name = 'NoFileForUploading';
+}
+class BadRequestError extends Error {
+    name = 'BadRequestError';
+}
+/** Low-level client for grpc uploadapi.
+ * The user should pass here a concrete BlobUpload/<storageId> resource,
+ * it can be got from handle field of BlobUpload. */
+class ClientUpload {
+    httpClient;
+    logger;
+    grpcClient;
+    constructor(grpcClientProviderFactory, httpClient, _, logger) {
+        this.httpClient = httpClient;
+        this.logger = logger;
+        this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new protocol_client.UploadClient(transport));
+    }
+    close() { }
+    async initUpload({ id, type }, options) {
+        const init = await this.grpcInit(id, type, options);
+        return {
+            overall: init.partsCount,
+            toUpload: this.partsToUpload(init.partsCount, init.uploadedParts),
+            checksumAlgorithm: init.checksumAlgorithm,
+            checksumHeader: init.checksumHeader,
+        };
+    }
+    async partUpload({ id, type }, path, expectedMTimeUnix, partNumber, checksumAlgorithm, checksumHeader, options) {
+        const info = await this.grpcGetPartUrl({ id, type }, partNumber, 0n, // we update progress as a separate call later.
+        options);
+        const chunk = await readFileChunk(path, info.chunkStart, info.chunkEnd);
+        await checkExpectedMTime(path, expectedMTimeUnix);
+        const crc32cChecksum = calculateCrc32cChecksum(chunk);
+        if (checksumAlgorithm === protocol.uploadapi_ChecksumAlgorithm.CRC32C) {
+            info.headers.push({ name: checksumHeader, value: crc32cChecksum });
+        }
+        const contentLength = Number(info.chunkEnd - info.chunkStart);
+        if (chunk.length !== contentLength) {
+            throw new Error(`Chunk size mismatch: expected ${contentLength} bytes, but read ${chunk.length} bytes from file`);
+        }
+        const headers = Object.fromEntries(info.headers.map(({ name, value }) => [name, value]));
+        try {
+            const { body: rawBody, statusCode, headers: responseHeaders, } = await undici.request(info.uploadUrl, {
+                dispatcher: this.httpClient,
+                body: chunk,
+                // We got headers only after we send
+                // the whole body (in case of S3 PUT requests it's 5 MB).
+                // It might be slow with a slow connection (or with SSH),
+                // that's why we got big timeout here.
+                headersTimeout: 60000,
+                bodyTimeout: 60000,
+                // Prevent connection reuse by setting "Connection: close" header.
+                // This works around an issue with the backend's built-in S3 implementation
+                // that caused HTTP/1.1 protocol lines to be included in the uploaded file content.
+                reset: true,
+                headers,
+                method: info.method.toUpperCase(),
+            });
+            // always read the body for resources to be garbage collected.
+            const body = await rawBody.text();
+            checkStatusCodeOk(statusCode, body, responseHeaders, info);
+        }
+        catch (e) {
+            if (e instanceof NetworkError)
+                throw e;
+            if (e instanceof BadRequestError)
+                throw e;
+            throw new Error(`partUpload: error ${JSON.stringify(e)} happened while trying to do part upload to the url ${info.uploadUrl}, headers: ${JSON.stringify(info.headers)}`);
+        }
+        await this.grpcUpdateProgress({ id, type }, BigInt(info.chunkEnd - info.chunkStart), options);
+    }
+    async finalize(info, options) {
+        return await this.grpcFinalize(info, options);
+    }
+    /** Calculates parts that need to be uploaded from the parts that were
+     * already uploaded. */
+    partsToUpload(partsCount, uploadedParts) {
+        const toUpload = [];
+        const uploaded = new Set(uploadedParts);
+        for (let i = 1n; i <= partsCount; i++) {
+            if (!uploaded.has(i))
+                toUpload.push(i);
+        }
+        return toUpload;
+    }
+    async grpcInit(id, type, options) {
+        return await this.grpcClient.get().init({ resourceId: id }, plClient.addRTypeToMetadata(type, options))
+            .response;
+    }
+    async grpcGetPartUrl({ id, type }, partNumber, uploadedPartSize, options) {
+        // partChecksum isn't used for now but protoc requires it to be set
+        return await this.grpcClient.get().getPartURL({ resourceId: id, partNumber, uploadedPartSize, isInternalUse: false, partChecksum: '' }, plClient.addRTypeToMetadata(type, options)).response;
+    }
+    async grpcUpdateProgress({ id, type }, bytesProcessed, options) {
+        await this.grpcClient.get().updateProgress({
+            resourceId: id,
+            bytesProcessed,
+        }, plClient.addRTypeToMetadata(type, options)).response;
+    }
+    async grpcFinalize({ id, type }, options) {
+        return await this.grpcClient.get().finalize({ resourceId: id }, plClient.addRTypeToMetadata(type, options))
+            .response;
+    }
+}
+async function readFileChunk(path, chunkStart, chunkEnd) {
+    let f;
+    try {
+        f = await fsp__namespace.open(path);
+        const len = Number(chunkEnd - chunkStart);
+        const pos = Number(chunkStart);
+        const b = Buffer.alloc(len);
+        const bytesRead = await readBytesFromPosition(f, b, len, pos);
+        return b.subarray(0, bytesRead);
+    }
+    catch (e) {
+        if (e && typeof e === 'object' && ('code' in e) && e.code == 'ENOENT')
+            throw new NoFileForUploading(`there is no file ${path} for uploading`);
+        throw e;
+    }
+    finally {
+        await f?.close();
+    }
+}
+/** Read len bytes from a given position.
+ * Without this, `FileHandle.read` can read less bytes than needed. */
+async function readBytesFromPosition(f, b, len, position) {
+    let bytesReadTotal = 0;
+    while (bytesReadTotal < len) {
+        const { bytesRead } = await f.read(b, bytesReadTotal, len - bytesReadTotal, position + bytesReadTotal);
+        if (bytesRead === 0) {
+            throw new UnexpectedEOF('file ended earlier than expected.');
+        }
+        bytesReadTotal += bytesRead;
+    }
+    return bytesReadTotal;
+}
+async function checkExpectedMTime(path, expectedMTimeUnix) {
+    const mTime = BigInt(Math.floor((await fsp__namespace.stat(path)).mtimeMs / 1000));
+    if (mTime > expectedMTimeUnix) {
+        throw new MTimeError(`file was modified, expected mtime: ${expectedMTimeUnix}, got: ${mTime}.`);
+    }
+}
+function checkStatusCodeOk(statusCode, body, headers, info) {
+    if (statusCode == 400) {
+        throw new BadRequestError(`response is not ok, status code: ${statusCode},`
+            + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`);
+    }
+    if (statusCode != 200) {
+        throw new NetworkError(`response is not ok, status code: ${statusCode},`
+            + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`);
+    }
+}
+/** Calculate CRC32C checksum of a buffer and return as base64 string */
+function calculateCrc32cChecksum(data) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+    const checksum = crc32.crc32c(data);
+    // Convert to unsigned 32-bit integer and then to base64
+    const buffer = Buffer.alloc(4);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    buffer.writeUInt32BE(checksum, 0);
+    return buffer.toString('base64');
+}
+
+exports.BadRequestError = BadRequestError;
+exports.ClientUpload = ClientUpload;
+exports.MTimeError = MTimeError;
+exports.NetworkError = NetworkError;
+exports.NoFileForUploading = NoFileForUploading;
+exports.UnexpectedEOF = UnexpectedEOF;
+//# sourceMappingURL=upload.cjs.map

package/dist/clients/upload.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.cjs","sources":["../../src/clients/upload.ts"],"sourcesContent":["import type { GrpcClientProvider, GrpcClientProviderFactory, PlClient, ResourceId, ResourceType } from '@milaboratories/pl-client';\nimport { addRTypeToMetadata } from '@milaboratories/pl-client';\nimport type { ResourceInfo } from '@milaboratories/pl-tree';\nimport type { MiLogger } from '@milaboratories/ts-helpers';\nimport type { RpcOptions } from '@protobuf-ts/runtime-rpc';\nimport * as fs from 'node:fs/promises';\nimport type { Dispatcher } from 'undici';\nimport { request } from 'undici';\nimport { crc32c } from '@node-rs/crc32';\nimport { uploadapi_ChecksumAlgorithm, type uploadapi_GetPartURL_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';\nimport { UploadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client';\n\nimport type { IncomingHttpHeaders } from 'undici/types/header';\n\nexport class MTimeError extends Error {\n  name = 'MTimeError';\n}\n\nexport class UnexpectedEOF extends Error {\n  name = 'UnexpectedEOF';\n}\n\nexport class NetworkError extends Error {\n  name = 'NetworkError';\n}\n\n/** Happens when the file doesn't exist */\nexport class NoFileForUploading extends Error {\n  name = 'NoFileForUploading';\n}\n\nexport class BadRequestError extends Error {\n  name = 'BadRequestError';\n}\n\n/** Low-level client for grpc uploadapi.\n * The user should pass here a concrete BlobUpload/<storageId> resource,\n * it can be got from handle field of BlobUpload. */\nexport class ClientUpload {\n  private readonly grpcClient: GrpcClientProvider<UploadClient>;\n\n  constructor(\n    grpcClientProviderFactory: GrpcClientProviderFactory,\n    public readonly httpClient: Dispatcher,\n    _: PlClient,\n    public readonly logger: MiLogger,\n  ) {\n    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new UploadClient(transport));\n  }\n\n  close() {}\n\n  public async initUpload(\n    { id, type }: ResourceInfo,\n    options?: RpcOptions,\n  ): Promise<{\n      overall: bigint;\n      toUpload: bigint[];\n      checksumAlgorithm: uploadapi_ChecksumAlgorithm;\n      checksumHeader: string;\n    }> {\n    const init = await this.grpcInit(id, type, options);\n    return {\n      overall: init.partsCount,\n      toUpload: this.partsToUpload(init.partsCount, init.uploadedParts),\n      checksumAlgorithm: init.checksumAlgorithm,\n      checksumHeader: init.checksumHeader,\n    };\n  }\n\n  public async partUpload(\n    { id, type }: ResourceInfo,\n    path: string,\n    expectedMTimeUnix: bigint,\n    partNumber: bigint,\n    checksumAlgorithm: uploadapi_ChecksumAlgorithm,\n    checksumHeader: string,\n    options?: RpcOptions,\n  ) {\n    const info = await this.grpcGetPartUrl(\n      { id, type },\n      partNumber,\n      0n, // we update progress as a separate call later.\n      options,\n    );\n\n    const chunk = await readFileChunk(path, info.chunkStart, info.chunkEnd);\n    await checkExpectedMTime(path, expectedMTimeUnix);\n\n    const crc32cChecksum = calculateCrc32cChecksum(chunk);\n    if (checksumAlgorithm === uploadapi_ChecksumAlgorithm.CRC32C) {\n      info.headers.push({ name: checksumHeader, value: crc32cChecksum });\n    }\n\n    const contentLength = Number(info.chunkEnd - info.chunkStart);\n    if (chunk.length !== contentLength) {\n      throw new Error(\n        `Chunk size mismatch: expected ${contentLength} bytes, but read ${chunk.length} bytes from file`,\n      );\n    }\n\n    const headers = Object.fromEntries(info.headers.map(({ name, value }) => [name, value]));\n\n    try {\n      const {\n        body: rawBody,\n        statusCode,\n        headers: responseHeaders,\n      } = await request(info.uploadUrl, {\n        dispatcher: this.httpClient,\n        body: chunk,\n        // We got headers only after we send\n        // the whole body (in case of S3 PUT requests it's 5 MB).\n        // It might be slow with a slow connection (or with SSH),\n        // that's why we got big timeout here.\n        headersTimeout: 60000,\n        bodyTimeout: 60000,\n        // Prevent connection reuse by setting \"Connection: close\" header.\n        // This works around an issue with the backend's built-in S3 implementation\n        // that caused HTTP/1.1 protocol lines to be included in the uploaded file content.\n        reset: true,\n        headers,\n        method: info.method.toUpperCase() as Dispatcher.HttpMethod,\n      });\n\n      // always read the body for resources to be garbage collected.\n      const body = await rawBody.text();\n      checkStatusCodeOk(statusCode, body, responseHeaders, info);\n    } catch (e: unknown) {\n      if (e instanceof NetworkError)\n        throw e;\n\n      if (e instanceof BadRequestError)\n        throw e;\n\n      throw new Error(`partUpload: error ${JSON.stringify(e)} happened while trying to do part upload to the url ${info.uploadUrl}, headers: ${JSON.stringify(info.headers)}`);\n    }\n\n    await this.grpcUpdateProgress({ id, type }, BigInt(info.chunkEnd - info.chunkStart), options);\n  }\n\n  public async finalize(info: ResourceInfo, options?: RpcOptions) {\n    return await this.grpcFinalize(info, options);\n  }\n\n  /** Calculates parts that need to be uploaded from the parts that were\n   * already uploaded. */\n  private partsToUpload(partsCount: bigint, uploadedParts: bigint[]): bigint[] {\n    const toUpload: bigint[] = [];\n    const uploaded = new Set(uploadedParts);\n\n    for (let i = 1n; i <= partsCount; i++) {\n      if (!uploaded.has(i)) toUpload.push(i);\n    }\n\n    return toUpload;\n  }\n\n  private async grpcInit(id: ResourceId, type: ResourceType, options?: RpcOptions) {\n    return await this.grpcClient.get().init({ resourceId: id }, addRTypeToMetadata(type, options))\n      .response;\n  }\n\n  private async grpcGetPartUrl(\n    { id, type }: ResourceInfo,\n    partNumber: bigint,\n    uploadedPartSize: bigint,\n    options?: RpcOptions,\n  ) {\n    // partChecksum isn't used for now but protoc requires it to be set\n    return await this.grpcClient.get().getPartURL(\n      { resourceId: id, partNumber, uploadedPartSize, isInternalUse: false, partChecksum: '' },\n      addRTypeToMetadata(type, options),\n    ).response;\n  }\n\n  private async grpcUpdateProgress(\n    { id, type }: ResourceInfo,\n    bytesProcessed: bigint,\n    options?: RpcOptions,\n  ) {\n    await this.grpcClient.get().updateProgress(\n      {\n        resourceId: id,\n        bytesProcessed,\n      },\n      addRTypeToMetadata(type, options),\n    ).response;\n  }\n\n  private async grpcFinalize({ id, type }: ResourceInfo, options?: RpcOptions) {\n    return await this.grpcClient.get().finalize({ resourceId: id }, addRTypeToMetadata(type, options))\n      .response;\n  }\n}\n\nasync function readFileChunk(path: string, chunkStart: bigint, chunkEnd: bigint): Promise<Buffer> {\n  let f: fs.FileHandle | undefined;\n  try {\n    f = await fs.open(path);\n    const len = Number(chunkEnd - chunkStart);\n    const pos = Number(chunkStart);\n    const b = Buffer.alloc(len);\n    const bytesRead = await readBytesFromPosition(f, b, len, pos);\n\n    return b.subarray(0, bytesRead);\n  } catch (e: unknown) {\n    if (e && typeof e === 'object' && ('code' in e) && e.code == 'ENOENT') throw new NoFileForUploading(`there is no file ${path} for uploading`);\n    throw e;\n  } finally {\n    await f?.close();\n  }\n}\n\n/** Read len bytes from a given position.\n * Without this, `FileHandle.read` can read less bytes than needed. */\nasync function readBytesFromPosition(f: fs.FileHandle, b: Buffer, len: number, position: number) {\n  let bytesReadTotal = 0;\n  while (bytesReadTotal < len) {\n    const { bytesRead } = await f.read(\n      b,\n      bytesReadTotal,\n      len - bytesReadTotal,\n      position + bytesReadTotal,\n    );\n    if (bytesRead === 0) {\n      throw new UnexpectedEOF('file ended earlier than expected.');\n    }\n    bytesReadTotal += bytesRead;\n  }\n\n  return bytesReadTotal;\n}\n\nasync function checkExpectedMTime(path: string, expectedMTimeUnix: bigint) {\n  const mTime = BigInt(Math.floor((await fs.stat(path)).mtimeMs / 1000));\n  if (mTime > expectedMTimeUnix) {\n    throw new MTimeError(`file was modified, expected mtime: ${expectedMTimeUnix}, got: ${mTime}.`);\n  }\n}\n\nfunction checkStatusCodeOk(\n  statusCode: number,\n  body: string,\n  headers: IncomingHttpHeaders,\n  info: uploadapi_GetPartURL_Response,\n) {\n  if (statusCode == 400) {\n    throw new BadRequestError(`response is not ok, status code: ${statusCode},`\n      + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`);\n  }\n\n  if (statusCode != 200) {\n    throw new NetworkError(\n      `response is not ok, status code: ${statusCode},`\n      + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`,\n    );\n  }\n}\n\n/** Calculate CRC32C checksum of a buffer and return as base64 string */\nfunction calculateCrc32cChecksum(data: Buffer): string {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call\n  const checksum = crc32c(data);\n  // Convert to unsigned 32-bit integer and then to base64\n  const buffer = Buffer.alloc(4);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n  buffer.writeUInt32BE(checksum, 0);\n  return buffer.toString('base64');\n}\n"],"names":["UploadClient","uploadapi_ChecksumAlgorithm","request","addRTypeToMetadata","fs","crc32c"],"mappings":"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"}

package/dist/clients/upload.d.ts

@@ -3,7 +3,7 @@ import { ResourceInfo } from '@milaboratories/pl-tree';
 import { MiLogger } from '@milaboratories/ts-helpers';
 import { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import { Dispatcher } from 'undici';
-import { uploadapi_Finalize_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';
+import { uploadapi_ChecksumAlgorithm } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';
 export declare class MTimeError extends Error {
     name: string;
 }
@@ -17,6 +17,9 @@ export declare class NetworkError extends Error {
 export declare class NoFileForUploading extends Error {
     name: string;
 }
+export declare class BadRequestError extends Error {
+    name: string;
+}
 /** Low-level client for grpc uploadapi.
  * The user should pass here a concrete BlobUpload/<storageId> resource,
  * it can be got from handle field of BlobUpload. */
@@ -29,9 +32,11 @@ export declare class ClientUpload {
     initUpload({ id, type }: ResourceInfo, options?: RpcOptions): Promise<{
         overall: bigint;
         toUpload: bigint[];
+        checksumAlgorithm: uploadapi_ChecksumAlgorithm;
+        checksumHeader: string;
     }>;
-    partUpload({ id, type }: ResourceInfo, path: string, expectedMTimeUnix: bigint, partNumber: bigint, options?: RpcOptions): Promise<void>;
-    finalize(info: ResourceInfo, options?: RpcOptions): Promise< uploadapi_Finalize_Response>;
+    partUpload({ id, type }: ResourceInfo, path: string, expectedMTimeUnix: bigint, partNumber: bigint, checksumAlgorithm: uploadapi_ChecksumAlgorithm, checksumHeader: string, options?: RpcOptions): Promise<void>;
+    finalize(info: ResourceInfo, options?: RpcOptions): Promise<import('../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol').uploadapi_Finalize_Response>;
     /** Calculates parts that need to be uploaded from the parts that were
      * already uploaded. */
     private partsToUpload;
@@ -40,4 +45,3 @@ export declare class ClientUpload {
     private grpcUpdateProgress;
     private grpcFinalize;
 }
-//# sourceMappingURL=upload.d.ts.map

package/dist/clients/upload.js

@@ -0,0 +1,183 @@
+import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import * as fsp from 'node:fs/promises';
+import { request } from 'undici';
+import { crc32c } from '@node-rs/crc32';
+import { uploadapi_ChecksumAlgorithm } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.js';
+import { UploadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client.js';
+
+class MTimeError extends Error {
+    name = 'MTimeError';
+}
+class UnexpectedEOF extends Error {
+    name = 'UnexpectedEOF';
+}
+class NetworkError extends Error {
+    name = 'NetworkError';
+}
+/** Happens when the file doesn't exist */
+class NoFileForUploading extends Error {
+    name = 'NoFileForUploading';
+}
+class BadRequestError extends Error {
+    name = 'BadRequestError';
+}
+/** Low-level client for grpc uploadapi.
+ * The user should pass here a concrete BlobUpload/<storageId> resource,
+ * it can be got from handle field of BlobUpload. */
+class ClientUpload {
+    httpClient;
+    logger;
+    grpcClient;
+    constructor(grpcClientProviderFactory, httpClient, _, logger) {
+        this.httpClient = httpClient;
+        this.logger = logger;
+        this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new UploadClient(transport));
+    }
+    close() { }
+    async initUpload({ id, type }, options) {
+        const init = await this.grpcInit(id, type, options);
+        return {
+            overall: init.partsCount,
+            toUpload: this.partsToUpload(init.partsCount, init.uploadedParts),
+            checksumAlgorithm: init.checksumAlgorithm,
+            checksumHeader: init.checksumHeader,
+        };
+    }
+    async partUpload({ id, type }, path, expectedMTimeUnix, partNumber, checksumAlgorithm, checksumHeader, options) {
+        const info = await this.grpcGetPartUrl({ id, type }, partNumber, 0n, // we update progress as a separate call later.
+        options);
+        const chunk = await readFileChunk(path, info.chunkStart, info.chunkEnd);
+        await checkExpectedMTime(path, expectedMTimeUnix);
+        const crc32cChecksum = calculateCrc32cChecksum(chunk);
+        if (checksumAlgorithm === uploadapi_ChecksumAlgorithm.CRC32C) {
+            info.headers.push({ name: checksumHeader, value: crc32cChecksum });
+        }
+        const contentLength = Number(info.chunkEnd - info.chunkStart);
+        if (chunk.length !== contentLength) {
+            throw new Error(`Chunk size mismatch: expected ${contentLength} bytes, but read ${chunk.length} bytes from file`);
+        }
+        const headers = Object.fromEntries(info.headers.map(({ name, value }) => [name, value]));
+        try {
+            const { body: rawBody, statusCode, headers: responseHeaders, } = await request(info.uploadUrl, {
+                dispatcher: this.httpClient,
+                body: chunk,
+                // We got headers only after we send
+                // the whole body (in case of S3 PUT requests it's 5 MB).
+                // It might be slow with a slow connection (or with SSH),
+                // that's why we got big timeout here.
+                headersTimeout: 60000,
+                bodyTimeout: 60000,
+                // Prevent connection reuse by setting "Connection: close" header.
+                // This works around an issue with the backend's built-in S3 implementation
+                // that caused HTTP/1.1 protocol lines to be included in the uploaded file content.
+                reset: true,
+                headers,
+                method: info.method.toUpperCase(),
+            });
+            // always read the body for resources to be garbage collected.
+            const body = await rawBody.text();
+            checkStatusCodeOk(statusCode, body, responseHeaders, info);
+        }
+        catch (e) {
+            if (e instanceof NetworkError)
+                throw e;
+            if (e instanceof BadRequestError)
+                throw e;
+            throw new Error(`partUpload: error ${JSON.stringify(e)} happened while trying to do part upload to the url ${info.uploadUrl}, headers: ${JSON.stringify(info.headers)}`);
+        }
+        await this.grpcUpdateProgress({ id, type }, BigInt(info.chunkEnd - info.chunkStart), options);
+    }
+    async finalize(info, options) {
+        return await this.grpcFinalize(info, options);
+    }
+    /** Calculates parts that need to be uploaded from the parts that were
+     * already uploaded. */
+    partsToUpload(partsCount, uploadedParts) {
+        const toUpload = [];
+        const uploaded = new Set(uploadedParts);
+        for (let i = 1n; i <= partsCount; i++) {
+            if (!uploaded.has(i))
+                toUpload.push(i);
+        }
+        return toUpload;
+    }
+    async grpcInit(id, type, options) {
+        return await this.grpcClient.get().init({ resourceId: id }, addRTypeToMetadata(type, options))
+            .response;
+    }
+    async grpcGetPartUrl({ id, type }, partNumber, uploadedPartSize, options) {
+        // partChecksum isn't used for now but protoc requires it to be set
+        return await this.grpcClient.get().getPartURL({ resourceId: id, partNumber, uploadedPartSize, isInternalUse: false, partChecksum: '' }, addRTypeToMetadata(type, options)).response;
+    }
+    async grpcUpdateProgress({ id, type }, bytesProcessed, options) {
+        await this.grpcClient.get().updateProgress({
+            resourceId: id,
+            bytesProcessed,
+        }, addRTypeToMetadata(type, options)).response;
+    }
+    async grpcFinalize({ id, type }, options) {
+        return await this.grpcClient.get().finalize({ resourceId: id }, addRTypeToMetadata(type, options))
+            .response;
+    }
+}
+async function readFileChunk(path, chunkStart, chunkEnd) {
+    let f;
+    try {
+        f = await fsp.open(path);
+        const len = Number(chunkEnd - chunkStart);
+        const pos = Number(chunkStart);
+        const b = Buffer.alloc(len);
+        const bytesRead = await readBytesFromPosition(f, b, len, pos);
+        return b.subarray(0, bytesRead);
+    }
+    catch (e) {
+        if (e && typeof e === 'object' && ('code' in e) && e.code == 'ENOENT')
+            throw new NoFileForUploading(`there is no file ${path} for uploading`);
+        throw e;
+    }
+    finally {
+        await f?.close();
+    }
+}
+/** Read len bytes from a given position.
+ * Without this, `FileHandle.read` can read less bytes than needed. */
+async function readBytesFromPosition(f, b, len, position) {
+    let bytesReadTotal = 0;
+    while (bytesReadTotal < len) {
+        const { bytesRead } = await f.read(b, bytesReadTotal, len - bytesReadTotal, position + bytesReadTotal);
+        if (bytesRead === 0) {
+            throw new UnexpectedEOF('file ended earlier than expected.');
+        }
+        bytesReadTotal += bytesRead;
+    }
+    return bytesReadTotal;
+}
+async function checkExpectedMTime(path, expectedMTimeUnix) {
+    const mTime = BigInt(Math.floor((await fsp.stat(path)).mtimeMs / 1000));
+    if (mTime > expectedMTimeUnix) {
+        throw new MTimeError(`file was modified, expected mtime: ${expectedMTimeUnix}, got: ${mTime}.`);
+    }
+}
+function checkStatusCodeOk(statusCode, body, headers, info) {
+    if (statusCode == 400) {
+        throw new BadRequestError(`response is not ok, status code: ${statusCode},`
+            + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`);
+    }
+    if (statusCode != 200) {
+        throw new NetworkError(`response is not ok, status code: ${statusCode},`
+            + ` body: ${body}, headers: ${JSON.stringify(headers)}, url: ${info.uploadUrl}`);
+    }
+}
+/** Calculate CRC32C checksum of a buffer and return as base64 string */
+function calculateCrc32cChecksum(data) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+    const checksum = crc32c(data);
+    // Convert to unsigned 32-bit integer and then to base64
+    const buffer = Buffer.alloc(4);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    buffer.writeUInt32BE(checksum, 0);
+    return buffer.toString('base64');
+}
+
+export { BadRequestError, ClientUpload, MTimeError, NetworkError, NoFileForUploading, UnexpectedEOF };
+//# sourceMappingURL=upload.js.map