@bytescale/sdk 1.1.0 → 1.2.0

package/dist/types/generated/runtime.d.ts

@@ -33,21 +33,6 @@ export declare class BytescaleApiError extends Error {
     readonly details: any | undefined;
     constructor(response: ErrorResponse);
 }
-export declare class ResponseError extends Error {
-    response: Response;
-    name: "ResponseError";
-    constructor(response: Response, msg?: string);
-}
-export declare class FetchError extends Error {
-    cause: Error;
-    name: "FetchError";
-    constructor(cause: Error, msg?: string);
-}
-export declare class RequiredError extends Error {
-    field: string;
-    name: "RequiredError";
-    constructor(field: string, msg?: string);
-}
 export declare type FetchAPI = WindowOrWorkerGlobalScope["fetch"];
 export declare type Json = any;
 export declare type HTTPMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";

package/dist/types/index.browser.d.ts

@@ -0,0 +1,3 @@
+export * from "./generated";
+export * from "./uploads/public/shared";
+export * from "./uploads/public/browser";

package/dist/types/index.node.d.ts

@@ -0,0 +1,3 @@
+export * from "./generated";
+export * from "./uploads/public/shared";
+export * from "./uploads/public/node";

package/dist/types/uploads/{ChunkedStream.d.ts → private/NodeChunkedStream.d.ts}

@@ -1,5 +1,14 @@
 /// <reference types="node" />
-export declare class ChunkedStream {
+/**
+ * For Node.js streams only:
+ *
+ * Converts a stream into a stream of streams, where the next stream is requested via '.take(sizeInBytes: number): Stream'
+ *
+ * This allows the source stream to be sequentially read (in serial) as a sequence of sub-streams, for the purpose of
+ * issuing PutObject requests for a multipart upload, whereby each request requires its own stream, but where that stream
+ * needs to be a slice of the source stream.
+ */
+export declare class NodeChunkedStream {
     private readonly source;
     private buffer;
     private consumer;
@@ -21,9 +30,7 @@ export declare class ChunkedStream {
     /**
      * Only call 'take' after the previously returned stream has been fully consumed.
      */
-    take(bytes: number): Promise<NodeJS.ReadableStream>;
+    take(bytes: number): NodeJS.ReadableStream;
     private consumeFromBuffer;
     private splitBuffer;
-    private emptyStream;
-    private finishStream;
 }

package/dist/types/uploads/private/StreamUtils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import type * as stream from "stream";
+export declare class StreamUtils {
+    static create(): stream.Readable;
+    static empty(): NodeJS.ReadableStream;
+    static fromBuffer(buffer: Buffer): NodeJS.ReadableStream;
+    static endStream(readable: stream.Readable): void;
+}

package/dist/types/uploads/private/TypeUtils.d.ts

@@ -0,0 +1 @@
+export declare function assertUnreachable(x: never): never;

package/dist/types/uploads/private/UploadManagerBase.d.ts

@@ -0,0 +1,43 @@
+import { BytescaleApiClientConfig, FileDetails, UploadPart } from "../../generated";
+import { UploadManagerParams, UploadSource } from "../public/shared";
+import { UploadManagerInterface } from "./model/UploadManagerInterface";
+import { PreUploadInfo } from "./model/PreUploadInfo";
+import { UploadSourceBlob } from "./model/UploadSourceProcessed";
+import { PutUploadPartResult } from "./model/PutUploadPartResult";
+import { AddCancellationHandler } from "./model/AddCancellationHandler";
+/**
+ * Methods common to UploadManagerNode and UploadManagerBrowser.
+ */
+export declare abstract class UploadManagerBase<TSource, TInit> implements UploadManagerInterface {
+    protected readonly config: BytescaleApiClientConfig;
+    protected readonly stringMimeType = "text/plain";
+    private readonly defaultMaxConcurrentUploadParts;
+    private readonly intervalMs;
+    private readonly uploadApi;
+    constructor(config: BytescaleApiClientConfig);
+    upload(request: UploadManagerParams): Promise<FileDetails>;
+    protected getBlobInfo({ value: { name, size, type } }: UploadSourceBlob): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected abstract processUploadSource(data: UploadSource): TSource;
+    protected abstract getPreUploadInfoPartial(request: UploadManagerParams, source: TSource): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected abstract preUpload(source: TSource): TInit;
+    protected abstract postUpload(init: TInit): Promise<void>;
+    protected abstract doPutUploadPart(part: UploadPart, contentLength: number, source: TSource, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+    private onIntervalTick;
+    private makeCancellationMethods;
+    private makeProgressCallback;
+    private assertNotCancelled;
+    private isCancelled;
+    private beginUpload;
+    private uploadPart;
+    /**
+     * Returns etag for the part.
+     */
+    private putUploadPart;
+    private getUploadPart;
+    private getPreUploadInfo;
+    private mapAsync;
+}

package/dist/types/uploads/private/model/AddCancellationHandler.d.ts

@@ -0,0 +1 @@
+export declare type AddCancellationHandler = (cancellationHandler: () => void) => void;

package/dist/types/uploads/private/model/OnPartProgress.d.ts

@@ -0,0 +1 @@
+export declare type OnPartProgress = (bytesSentDelta: number) => void;

package/dist/types/uploads/private/model/PreUploadInfo.d.ts

@@ -0,0 +1,6 @@
+export interface PreUploadInfo {
+    maxConcurrentUploadParts: number;
+    mime: string | undefined;
+    originalFileName: string | undefined;
+    size: number;
+}

package/dist/types/uploads/private/model/PutUploadPartResult.d.ts

@@ -0,0 +1,4 @@
+export interface PutUploadPartResult {
+    etag: string | undefined;
+    status: number;
+}

package/dist/types/uploads/private/model/UploadManagerInterface.d.ts

@@ -0,0 +1,5 @@
+import { UploadManagerParams } from "../../public/shared/Model";
+import { FileDetails } from "../../../generated";
+export interface UploadManagerInterface {
+    upload: (request: UploadManagerParams) => Promise<FileDetails>;
+}

package/dist/types/uploads/private/model/UploadSourceProcessed.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { BlobLike } from "../../public/shared/Model";
+import { NodeChunkedStream } from "../NodeChunkedStream";
+export interface UploadSourceBlob {
+    type: "Blob";
+    value: BlobLike;
+}
+export interface UploadSourceBuffer {
+    type: "Buffer";
+    value: Buffer;
+}
+export interface UploadSourceStream {
+    type: "Stream";
+    value: NodeChunkedStream;
+}
+export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob;
+export declare type UploadSourceProcessedBrowser = UploadSourceProcessedIsomorphic;
+export declare type UploadSourceProcessedNode = UploadSourceStream | UploadSourceBuffer | UploadSourceProcessedIsomorphic;

package/dist/types/uploads/public/browser/UploadManagerBrowser.d.ts

@@ -0,0 +1,17 @@
+import { UploadManagerBase } from "../../private/UploadManagerBase";
+import { UploadSourceProcessedBrowser } from "../../private/model/UploadSourceProcessed";
+import { UploadManagerParams, UploadSource } from "../shared";
+import { PreUploadInfo } from "../../private/model/PreUploadInfo";
+import { UploadPart } from "../../../generated";
+import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedBrowser, undefined> {
+    protected processUploadSource(data: UploadSource): UploadSourceProcessedBrowser;
+    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: UploadSourceProcessedBrowser): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(_source: UploadSourceProcessedBrowser): undefined;
+    protected postUpload(_init: undefined): Promise<void>;
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+    private getRequestBody;
+}

package/dist/types/uploads/public/browser/index.d.ts

@@ -0,0 +1 @@
+export * from "./UploadManagerBrowser";

package/dist/types/uploads/public/node/UploadManagerNode.d.ts

@@ -0,0 +1,26 @@
+import { UploadManagerBase } from "../../private/UploadManagerBase";
+import { UploadSourceProcessedNode } from "../../private/model/UploadSourceProcessed";
+import { NodeChunkedStream } from "../../private/NodeChunkedStream";
+import { UploadManagerParams, UploadSource } from "../shared";
+import { PreUploadInfo } from "../../private/model/PreUploadInfo";
+import { UploadPart } from "../../../generated";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+declare type UploadManagerNodeInit = undefined | {
+    chunkedStream: NodeChunkedStream;
+    chunkedStreamPromise: Promise<void>;
+};
+export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedNode, UploadManagerNodeInit> {
+    protected processUploadSource(data: UploadSource): UploadSourceProcessedNode;
+    protected getPreUploadInfoPartial(request: UploadManagerParams, data: UploadSourceProcessedNode): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(source: UploadSourceProcessedNode): UploadManagerNodeInit;
+    protected postUpload(init: UploadManagerNodeInit): Promise<void>;
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedNode, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<{
+        etag: string | undefined;
+        status: number;
+    }>;
+    private coerceRequestBody;
+    private sliceDataForRequest;
+}
+export {};

package/dist/types/uploads/public/node/index.d.ts

@@ -0,0 +1 @@
+export * from "./UploadManagerNode";

package/dist/types/uploads/{UploadModel.d.ts → public/shared/Model.d.ts}

@@ -5,8 +5,7 @@
  * - Browser 'Blob', e.g. 'new Blob([JSON.stringify({someValue: 42})], {type: "application/json"})'
  * - Browser 'File', e.g. from a <input type="file" onchange="...">
  */
-import { BeginMultipartUploadRequest } from "../generated";
-import { ChunkedStream } from "./ChunkedStream";
+import { BeginMultipartUploadRequest } from "../../../generated";
 export interface BlobLike {
     readonly name?: string;
     readonly size: number;
@@ -16,10 +15,14 @@ export interface BlobLike {
 export interface CancellationToken {
     isCancelled: boolean;
 }
+export interface UploadProgress {
+    bytesSent: number;
+    bytesTotal: number;
+    progress: number;
+}
 export declare class CancelledError extends Error {
-    msg?: string | undefined;
     name: "CancelledError";
-    constructor(msg?: string | undefined);
+    constructor();
 }
 export declare type UploadSource = NodeJS.ReadableStream | BlobLike | Buffer | string;
 export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "size" | "protocol"> {
@@ -27,9 +30,9 @@ export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "
     cancellationToken?: CancellationToken;
     data: UploadSource;
     maxConcurrentUploadParts?: number;
+    onProgress?: (status: UploadProgress) => void;
     /**
      * Only required if 'data' is a 'ReadableStream'.
      */
     size?: number;
 }
-export declare type UploadSourceProcessed = ChunkedStream | BlobLike | Buffer;

package/dist/types/uploads/public/shared/index.d.ts

@@ -0,0 +1 @@
+export * from "./Model";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytescale/sdk",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Bytescale JavaScript SDK",
   "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
   "license": "MIT",

package/tests/ChunkedStream.test.ts

@@ -1,4 +1,4 @@
-import { ChunkedStream } from "../src/uploads";
+import { NodeChunkedStream } from "../src/uploads/private/NodeChunkedStream";
 import { createRandomStreamFactory } from "./utils/RandomStream";
 import { streamToBuffer } from "./utils/StreamToBuffer";
 
@@ -9,7 +9,7 @@ describe("ChunkedStream", () => {
       const expectedSize = Math.pow(1024, 2) * 100; // 100MB
       const maxPartSize = Math.pow(1024, 2) * 2; // 2MB
       const expectedData = await createRandomStreamFactory(expectedSize);
-      const chunkedStream = new ChunkedStream(expectedData());
+      const chunkedStream = new NodeChunkedStream(expectedData());
       const worker = chunkedStream.runChunkPipeline();
       let remaining = expectedSize;
       const buffersFromParts = Array<Buffer>();
@@ -23,7 +23,7 @@ describe("ChunkedStream", () => {
 
         const partSize = nextPartSize();
 
-        const subStream = await chunkedStream.take(partSize);
+        const subStream = chunkedStream.take(partSize);
         const subStreamBuffer = await streamToBuffer(subStream);
 
         expect(subStreamBuffer.byteLength).toEqual(partSize);

package/tests/UploadManager.test.ts

@@ -1,4 +1,4 @@
-import { BytescaleApiClientConfig, FileApi, UploadManager } from "../src";
+import { BytescaleApiClientConfig, FileApi, UploadManager } from "../src/index.node";
 import fetch from "node-fetch";
 import * as buffer from "buffer";
 import { createRandomStreamFactory } from "./utils/RandomStream";

package/dist/browser/cjs/_70b2.main.js

@@ -1,10 +0,0 @@
-(self["webpackChunk_bytescale_sdk"] = self["webpackChunk_bytescale_sdk"] || []).push([["_70b2"],{
-
-/***/ "?70b2":
-/***/ (function() {
-
-/* (ignored) */
-
-/***/ })
-
-}]);

package/dist/browser/cjs/_7392.main.js

@@ -1,10 +0,0 @@
-(self["webpackChunk_bytescale_sdk"] = self["webpackChunk_bytescale_sdk"] || []).push([["_7392"],{
-
-/***/ "?7392":
-/***/ (function() {
-
-/* (ignored) */
-
-/***/ })
-
-}]);

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./generated";
-export * from "./uploads";

package/dist/types/uploads/NodeUtils.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import type * as stream from "stream";
-import type * as buffer from "buffer";
-import { BlobLike } from "./UploadModel";
-/**
- * Provides access to Node.js built-in libraries. Should only be called when we're certain we're running in Node.js.
- *
- * We import lazily to support browsers, which don't have these modules, but also won't call these methods so won't trigger the imports.
- */
-export declare class NodeUtils {
-    static createStream(): Promise<stream.Readable>;
-    static createBlob(sources: string[], options?: buffer.BlobOptions): Promise<BlobLike>;
-}

package/dist/types/uploads/UploadManager.d.ts

@@ -1,39 +0,0 @@
-import { FileDetails, BytescaleApiClientConfig } from "../generated";
-import { UploadManagerParams } from "./UploadModel";
-export declare class UploadManager {
-    private readonly config;
-    private readonly stringMimeType;
-    private readonly defaultMaxConcurrentUploadParts;
-    private readonly uploadApi;
-    constructor(config: BytescaleApiClientConfig);
-    upload(request: UploadManagerParams): Promise<FileDetails>;
-    private checkIfCancelled;
-    private beginUpload;
-    private uploadPart;
-    /**
-     * Returns etag for the part.
-     */
-    private putUploadPart;
-    private coerceRequestBody;
-    private makeRequestBody;
-    private bufferToStream;
-    /**
-     * Only expected to be called in Node.js environments, and as such, we can assume 'BlobLike' is not a DOM 'File' object.
-     */
-    private blobToBuffer;
-    private sliceDataForRequest;
-    private isNodeJs;
-    private getUploadPart;
-    private calculateSize;
-    private calculateMime;
-    private calculateOriginalFileName;
-    private calculateMaxConcurrency;
-    private getChunkedStream;
-    private foldData;
-    private foldDataRaw;
-    private processUploadSource;
-    private stringToBlob;
-    private globalBlob;
-    private nodeJsBlob;
-    private mapAsync;
-}

package/dist/types/uploads/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./ChunkedStream";
-export * from "./UploadModel";
-export * from "./UploadManager";