Bytescale JavaScript SDK (Node.js)

function upload(params: UploadManagerParams): Promise<FileDetails>

{
  "cancellationToken": CancellationToken,
  "data": Object,
  "maxConcurrentUploadParts": Number,
  "metadata": FileMetadata,
  "mime": String,
  "onProgress": Function,
  "originalFileName": String,
  "path": FilePathDefinition,
  "size": Integer,
  "tags": String[]
}

{
  "accountId": String,
  "etag": String | Null,
  "filePath": String,
  "fileUrl": String,
  "lastModified": Integer,
  "metadata": FileMetadata,
  "mime": String,
  "originalFileName": String | Null,
  "size": Integer,
  "tags": String[]
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadManager = new Bytescale.UploadManager({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadManager
  .upload({
    "data": "Hello World"
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function beginAuthSession(params: BeginAuthSessionParams): Promise<void>

{
  "accountId": String,
  "authHeaders": Function,
  "authUrl": String,
  "options": BeginAuthSessionParamsOptions,
  "serviceWorkerScript": String
}

import * as Bytescale from "@bytescale/sdk";

async function onSignIn() {

  // The URL for your auth API endpoint.
  // - For help implementing your auth API endpoint, see: https://www.bytescale.com/docs/auth/generating-jwts
  // Your URL must:
  // - Return a JWT as plain text.
  // - Return a 'content-type: text/plain' response header.
  // - Return a 200 status code.
  // - Return a signed JWT (i.e. the JWT must include 2x "." characters) using RS256.
  // - The public key certificate must be added to the Bytescale Dashboard.
  // - The JWT must not be wrapped with "".
  const authUrl = "https://your-web-app/your-auth-url";

  // Headers required by your auth API endpoint (e.g. 'authorization' header).
  const authHeaders = () => Promise.resolve({
    authorization: "some auth token"
  });

  // Wait for authentication to complete:
  await Bytescale.AuthManager.beginAuthSession({
    accountId: "YOUR_ACCOUNT_ID", // e.g. "W142hJk"
    authUrl,
    authHeaders,
    // Optional:
    // - To support modern browsers that block third-party cookies (like Safari),
    //   you should consider enabling service workers by uncommenting the below.
    // - Before uncommenting, you must implement the "/bytescale-auth-sw.js" script.
    // - See: https://www.bytescale.com/docs/types/BeginAuthSessionParams#serviceWorkerScript
    // serviceWorkerScript: "/bytescale-auth-sw.js"
  });
}

// Call this after your user signs in:
await onSignIn();

// After the 'onSignIn' promise completes:
// - You can start referencing private files in <img> elements, etc.
// - You can start performing other operations permitted by the JWT in your client-side code.
//   (e.g. file deletions, file uploads to specific folders, etc.)

function endAuthSession(): Promise<void>

function isAuthSessionActive(): boolean

function isAuthSessionReady(): boolean

function uploadFromUrl(params: UploadFromUrlParams): Promise<BasicUploadResponse>

{
  "accountId": String,
  "uploadFromUrlRequest": UploadFromUrlRequest
}

{
  "accountId": String,
  "etag": String,
  "filePath": String,
  "fileUrl": String
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadApi = new Bytescale.UploadApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadApi
  .uploadFromUrl({
    "accountId": "YOUR_ACCOUNT_ID",
    "uploadFromUrlRequest": {
      "url": "https://assets.bytescale.com/example.jpg"
    }
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function beginMultipartUpload(params: BeginMultipartUploadParams): Promise<BeginMultipartUploadResponse>

{
  "accountId": String,
  "beginMultipartUploadRequest": BeginMultipartUploadRequest
}

{
  "file": FileDetails,
  "uploadId": String,
  "uploadParts": {
    "count": Integer,
    "first": UploadPart
  }
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadApi = new Bytescale.UploadApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadApi
  .beginMultipartUpload({
    "accountId": "YOUR_ACCOUNT_ID",
    "beginMultipartUploadRequest": {
      "size": 43182
    }
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function completeUploadPart(params: CompleteUploadPartParams): Promise<CompleteMultipartUploadResponse>

{
  "accountId": String,
  "completeUploadPartRequest": CompleteUploadPartRequest,
  "uploadId": String,
  "uploadPartIndex": Integer
}

Arbitrary JSON Object

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadApi = new Bytescale.UploadApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadApi
  .completeUploadPart({
    "accountId": "YOUR_ACCOUNT_ID",
    "completeUploadPartRequest": {
      "etag": "33a64df551425fcc55e4d42a148795d9f25f89d4"
    },
    "uploadId": "Kd759aLFxttm69kZ",
    "uploadPartIndex": 7
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function getUploadPart(params: GetUploadPartParams): Promise<UploadPart>

{
  "accountId": String,
  "uploadId": String,
  "uploadPartIndex": Integer
}

{
  "range": UploadPartRange,
  "uploadId": String,
  "uploadPartIndex": Integer,
  "uploadUrl": String
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadApi = new Bytescale.UploadApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadApi
  .getUploadPart({
    "accountId": "YOUR_ACCOUNT_ID",
    "uploadId": "Kd759aLFxttm69kZ",
    "uploadPartIndex": 7
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function listUploadParts(params: ListUploadPartsParams): Promise<UploadPartList>

{
  "accountId": String,
  "uploadId": String
}

{
  "remainingUploadParts": Integer[]
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const uploadApi = new Bytescale.UploadApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

uploadApi
  .listUploadParts({
    "accountId": "YOUR_ACCOUNT_ID",
    "uploadId": "Kd759aLFxttm69kZ"
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function downloadFile(params: DownloadFileParams): Promise<BinaryResult>

{
  "accountId": String,
  "cache": Boolean,
  "cache_ttl": Number,
  "cache_ttl_404": Number,
  "filePath": String,
  "version": String
}

{
  "blob": Function,
  "json": Function,
  "stream": Function,
  "text": Function
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .downloadFile({
    "accountId": "YOUR_ACCOUNT_ID",
    "filePath": "/uploads/image.jpg"
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function processFile(params: ProcessFileParams): Promise<BinaryResult>

{
  "accountId": String,
  "artifact": String,
  "cache": Boolean,
  "cache_only": Boolean,
  "cache_perm": String,
  "cache_ttl": Number,
  "cache_ttl_404": Number,
  "filePath": String,
  "transformation": String,
  "transformationParams": TransformationParams,
  "version": String
}

{
  "blob": Function,
  "json": Function,
  "stream": Function,
  "text": Function
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .processFile({
    "accountId": "YOUR_ACCOUNT_ID",
    "filePath": "/uploads/image.jpg",
    "transformation": "image",
    "transformationParams": [
      {
        "w": 800,
        "h": 600,
        "fit": "crop"
      }
    ]
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function processFileAndSave(params: ProcessFileAndSaveParams): Promise<ProcessFileAndSaveResponse>

{
  "accountId": String,
  "filePath": String,
  "processFileAndSaveRequest": ProcessFileAndSaveRequest,
  "transformation": String,
  "transformationParams": TransformationParams
}

Arbitrary JSON Object

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .processFileAndSave({
    "accountId": "YOUR_ACCOUNT_ID",
    "filePath": "/source/image.jpg",
    "processFileAndSaveRequest": {
      "destination": "/destination/image.jpg"
    },
    "transformation": "image",
    "transformationParams": [
      {
        "w": 800,
        "h": 600,
        "fit": "crop"
      }
    ]
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function getFileDetails(params: GetFileDetailsParams): Promise<FileDetails>

{
  "accountId": String,
  "filePath": String
}

{
  "accountId": String,
  "etag": String | Null,
  "filePath": String,
  "fileUrl": String,
  "lastModified": Integer,
  "metadata": FileMetadata,
  "mime": String,
  "originalFileName": String | Null,
  "size": Integer,
  "tags": String[]
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .getFileDetails({
    "accountId": "YOUR_ACCOUNT_ID",
    "filePath": "/uploads/image.jpg"
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function copyFile(params: CopyFileParams): Promise<CopyFileResponse>

{
  "accountId": String,
  "copyFileRequest": CopyFileRequest
}

{
  "status": String
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .copyFile({
    "accountId": "YOUR_ACCOUNT_ID",
    "copyFileRequest": {
      "destination": "/destination/file.txt",
      "source": "/source/file.txt"
    }
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function copyFileBatch(params: CopyFileBatchParams): Promise<AsyncResponse>

{
  "accountId": String,
  "copyFileBatchRequest": CopyFileBatchRequest
}

{
  "jobDocs": String,
  "jobId": String,
  "jobType": String,
  "jobUrl": String
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .copyFileBatch({
    "accountId": "YOUR_ACCOUNT_ID",
    "copyFileBatchRequest": {
      "files": [
        {
          "destination": "/destination/file.txt",
          "source": "/source/file.txt"
        }
      ]
    }
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );

function deleteFile(params: DeleteFileParams): Promise<void>

{
  "accountId": String,
  "filePath": String
}

import * as Bytescale from "@bytescale/sdk";
import nodeFetch from "node-fetch";

const fileApi = new Bytescale.FileApi({
  fetchApi: nodeFetch, // import nodeFetch from "node-fetch"; // Only required for Node.js. TypeScript: 'nodeFetch as any' may be necessary.
  apiKey: "YOUR_API_KEY" // e.g. "secret_xxxxx"
});

fileApi
  .deleteFile({
    "accountId": "YOUR_ACCOUNT_ID",
    "filePath": "/uploads/image.jpg"
  })
  .then(
    result => console.log(result),
    error => console.error(error)
  );