@bytescale/sdk 1.1.0 → 1.3.0

package/dist/types/{generated → public/shared/generated}/runtime.d.ts

@@ -10,22 +10,61 @@ import { ErrorResponse } from "./models";
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-export declare const BASE_PATH: string;
 export interface BytescaleApiClientConfig {
+    /**
+     * Required for Node.js: you must provide an instance of requires("node-fetch")
+     *
+     * Not required for the browser.
+     */
     fetchApi?: FetchAPI;
-    apiKey?: string | ((name: string) => string);
+    /**
+     * Required for all environments. Must begin with "public_" or "secret_".
+     *
+     * Please note: if you require JWT-based auth, you must provide an API key to this field, and then call 'AuthManager.beginAuthSession' to start a JWT-based auth session. The JWT's permissions will be merged with the API key's permissions, with precedence given to the JWT.
+     */
+    apiKey: string;
+    /**
+     * The base URL of the Bytescale API.
+     */
+    apiUrl?: string;
+    /**
+     * The base URL of the Bytescale CDN.
+     */
+    cdnUrl?: string;
+    /**
+     * Headers to include in all API requests.
+     *
+     * These headers take precedence over any headers automatically added by the SDK (e.g. "Authorization", "Content-Type", etc.).
+     */
     headers?: () => Promise<HTTPHeaders>;
 }
+export declare class BytescaleApiClientConfigResolver {
+    static defaultApiUrl: string;
+    static defaultCdnUrl: string;
+    static getApiUrl(config: BytescaleApiClientConfig): string;
+    static getCdnUrl(config: BytescaleApiClientConfig): string;
+    static getFetchApi(config: BytescaleApiClientConfig): FetchAPI;
+}
 /**
  * This is the base class for all generated API classes.
  */
 export declare class BaseAPI {
     protected readonly config: BytescaleApiClientConfig;
+    protected static readonly specialApiKeys: string[];
+    protected static readonly specialApiKeyAccountId = "W142hJk";
+    protected static readonly accountIdLength = 7;
     constructor(config: BytescaleApiClientConfig);
-    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, operationBasePathOverride: string | undefined): Promise<Response>;
+    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, baseUrlOverride: string | undefined): Promise<Response>;
+    /**
+     * Returns a successful response (2**) else throws an error.
+     */
+    protected doFetch(url: string, init: RequestInit, isBytescaleApi: boolean): Promise<Response>;
     protected encodeParam(paramName: string, paramValue: string): string;
     private createFetchParams;
-    private fetchApi;
+}
+export declare class CancelledError extends Error {
+    name: "CancelledError";
+    constructor();
 }
 export declare class BytescaleApiError extends Error {
     name: "BytescaleApiError";
@@ -33,21 +72,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";
@@ -63,15 +87,10 @@ export declare type HTTPRequestInit = {
     method: HTTPMethod;
     body?: HTTPBody;
 };
-export declare type ModelPropertyNaming = "camelCase" | "snake_case" | "PascalCase" | "original";
 export declare type InitOverrideFunction = (requestContext: {
     init: HTTPRequestInit;
     context: RequestOpts;
 }) => Promise<RequestInit>;
-export interface FetchParams {
-    url: string;
-    init: RequestInit;
-}
 export interface RequestOpts {
     path: string;
     method: HTTPMethod;
@@ -84,13 +103,9 @@ export interface ApiResponse<T> {
     raw: Response;
     value(): Promise<T>;
 }
-export interface ResponseTransformer<T> {
-    (json: any): T;
-}
 export declare class JSONApiResponse<T> {
     raw: Response;
-    private transformer;
-    constructor(raw: Response, transformer?: ResponseTransformer<T>);
+    constructor(raw: Response);
     value(): Promise<T>;
 }
 export declare class VoidApiResponse {

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

@@ -0,0 +1,4 @@
+export * from "./generated";
+export * from "./CommonTypes";
+export * from "./UrlBuilder";
+export * from "./UrlBuilderTypes";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytescale/sdk",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Bytescale JavaScript SDK",
   "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
     "typecheck": "tsc --noEmit",
     "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --runInBand --silent=false --verbose=false",
-    "prepack": "npm run clean && webpack && tsc-alias",
+    "prepack": "npm run clean && webpack && tsc-alias && rm dist/types/index.browser.d.ts && mv dist/types/index.node.d.ts dist/types/index.d.ts",
     "postpack": "[ ! -f bytescale-sdk-*.tgz ] || mv bytescale-sdk-*.tgz bytescale-sdk.tgz",
     "prepare": "husky install",
     "prepack:cdn": "npm run clean && webpack --config webpack.config.cdn.js && find dist -name \"*.ts\" -type f -delete && for f in dist/*.js; do cp -- \"$f\" \"${f%.js}\"; done",

package/tests/ChunkedStream.test.ts

@@ -1,4 +1,4 @@
-import { ChunkedStream } from "../src/uploads";
+import { NodeChunkedStream } from "../src/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/tests/UrlBuilder.test.ts

@@ -0,0 +1,168 @@
+import { UrlBuilder } from "../src/public/shared";
+
+describe("UrlBuilder", () => {
+  test("raw file without params", () => {
+    const actual = new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg" });
+    const expected = "https://upcdn.io/1234abc/raw/example.jpg";
+    expect(actual).toEqual(expected);
+  });
+
+  test("raw file with one param", () => {
+    const actual = new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", options: { auth: true } });
+    const expected = "https://upcdn.io/1234abc/raw/example.jpg?auth=true";
+    expect(actual).toEqual(expected);
+  });
+
+  test("raw file with multiple params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: { auth: true, cache: true, version: "42" }
+    });
+    const expected = "https://upcdn.io/1234abc/raw/example.jpg?auth=true&cache=true&version=42";
+    expect(actual).toEqual(expected);
+  });
+
+  test("raw file with rewritten params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: { auth: true, cache: true, cacheTtl: 100 } // cacheTtl is rewritten to cache_ttl
+    });
+    const expected = "https://upcdn.io/1234abc/raw/example.jpg?auth=true&cache=true&cache_ttl=100";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation preset without params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: { transformation: { type: "preset", preset: "thumbnail" } }
+    });
+    const expected = "https://upcdn.io/1234abc/thumbnail/example.jpg";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation preset with one param", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: { transformation: { type: "preset", preset: "thumbnail", params: { artifact: "/foo" } } }
+    });
+    const expected = "https://upcdn.io/1234abc/thumbnail/example.jpg?artifact=%2Ffoo";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation preset with multiple params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: { type: "preset", preset: "thumbnail", params: { large: false, artifact: "/foo" } }
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/thumbnail/example.jpg?large=false&artifact=%2Ffoo";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation preset with rewritten params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        // cachePermanently is rewritten to cache_perm
+        transformation: { type: "preset", preset: "thumbnail", params: { cachePermanently: false, artifact: "/foo" } }
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/thumbnail/example.jpg?cache_perm=false&artifact=%2Ffoo";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation API without params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: {
+          type: "image"
+        }
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/image/example.jpg";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation API with one param", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: {
+          type: "image",
+          params: {
+            w: 42
+          }
+        }
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/image/example.jpg?w=42";
+    expect(actual).toEqual(expected);
+  });
+
+  test("transformation API with a mix of params", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: {
+          type: "image",
+          params: {
+            w: 42,
+            h: 50
+          }
+        },
+        auth: true
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/image/example.jpg?auth=true&w=42&h=50";
+    expect(actual).toEqual(expected);
+  });
+
+  test("elide null and undefined", () => {
+    const actual = new UrlBuilder().url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: {
+          type: "image",
+          params: {
+            w: null,
+            h: undefined,
+            r: 52
+          }
+        },
+        auth: true
+      }
+    });
+    const expected = "https://upcdn.io/1234abc/image/example.jpg?auth=true&r=52";
+    expect(actual).toEqual(expected);
+  });
+
+  test("custom CNAME", () => {
+    const actual = new UrlBuilder({ cdnUrl: "https://example.com" }).url({
+      accountId: "1234abc",
+      filePath: "/example.jpg",
+      options: {
+        transformation: {
+          type: "image",
+          params: {
+            w: 42,
+            h: 50
+          }
+        }
+      }
+    });
+    const expected = "https://example.com/1234abc/image/example.jpg?w=42&h=50";
+    expect(actual).toEqual(expected);
+  });
+});

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/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";