@bytescale/sdk 1.0.0-alpha.1

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

@@ -0,0 +1,178 @@
+import { ErrorResponse } from "./models";
+/**
+ * @bytescale/bytescale-api
+ * Bytescale API
+ *
+ * The version of the OpenAPI document: 2.0.0
+ * Contact: hello@bytescale.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare const BASE_PATH: string;
+export interface ConfigurationParameters {
+    basePath?: string;
+    fetchApi?: FetchAPI;
+    middleware?: Middleware[];
+    queryParamsStringify?: (params: HTTPQuery) => string;
+    username?: string;
+    password?: string;
+    apiKey?: string | ((name: string) => string);
+    accessToken?: string | Promise<string> | ((name?: string, scopes?: string[]) => string | Promise<string>);
+    headers?: HTTPHeaders;
+    credentials?: RequestCredentials;
+}
+export declare class Configuration {
+    private configuration;
+    constructor(configuration?: ConfigurationParameters);
+    set config(configuration: Configuration);
+    get basePath(): string;
+    get fetchApi(): FetchAPI | undefined;
+    get middleware(): Middleware[];
+    get queryParamsStringify(): (params: HTTPQuery) => string;
+    get username(): string | undefined;
+    get password(): string | undefined;
+    get apiKey(): ((name: string) => string) | undefined;
+    get accessToken(): ((name?: string, scopes?: string[]) => string | Promise<string>) | undefined;
+    get headers(): HTTPHeaders | undefined;
+    get credentials(): RequestCredentials | undefined;
+}
+export declare const DefaultConfig: Configuration;
+/**
+ * This is the base class for all generated API classes.
+ */
+export declare class BaseAPI {
+    protected configuration: Configuration;
+    private middleware;
+    constructor(configuration?: Configuration);
+    withMiddleware<T extends BaseAPI>(this: T, ...middlewares: Middleware[]): T;
+    withPreMiddleware<T extends BaseAPI>(this: T, ...preMiddlewares: Array<Middleware["pre"]>): T;
+    withPostMiddleware<T extends BaseAPI>(this: T, ...postMiddlewares: Array<Middleware["post"]>): T;
+    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, operationBasePathOverride: string | undefined): Promise<Response>;
+    private createFetchParams;
+    private fetchApi;
+    /**
+     * Create a shallow clone of `this` by constructing a new instance
+     * and then shallow cloning data members.
+     */
+    private clone;
+}
+export declare class UploadApiError extends Error {
+    name: "UploadApiError";
+    readonly errorCode: string;
+    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 const COLLECTION_FORMATS: {
+    csv: string;
+    ssv: string;
+    tsv: string;
+    pipes: string;
+};
+export declare type FetchAPI = WindowOrWorkerGlobalScope["fetch"];
+export declare type Json = any;
+export declare type HTTPMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+export declare type HTTPHeaders = {
+    [key: string]: string;
+};
+export declare type HTTPQuery = {
+    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery;
+};
+export declare type HTTPBody = Json | FormData | URLSearchParams;
+export declare type HTTPRequestInit = {
+    headers?: HTTPHeaders;
+    method: HTTPMethod;
+    credentials?: RequestCredentials;
+    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;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+export declare function querystring(params: HTTPQuery, prefix?: string): string;
+export declare function canConsumeForm(consumes: Consume[]): boolean;
+export interface Consume {
+    contentType: string;
+}
+export interface RequestContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+}
+export interface ResponseContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    response: Response;
+}
+export interface ErrorContext {
+    fetch: FetchAPI;
+    url: string;
+    init: RequestInit;
+    error: unknown;
+    response?: Response;
+}
+export interface Middleware {
+    pre?(context: RequestContext): Promise<FetchParams | void>;
+    post?(context: ResponseContext): Promise<Response | void>;
+    onError?(context: ErrorContext): Promise<Response | void>;
+}
+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>);
+    value(): Promise<T>;
+}
+export declare class VoidApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<void>;
+}
+export declare class BinaryResult {
+    raw: Response;
+    constructor(raw: Response);
+    stream(): ReadableStream<Uint8Array>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+    json(): Promise<any>;
+}
+export declare class TextApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./gen";
+export * from "./utils";

package/dist/types/utils/ChunkedStream.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+export declare class ChunkedStream {
+    private readonly source;
+    private buffer;
+    private consumer;
+    private isSourceFullyConsumed;
+    private isFinishedConsuming;
+    private resolver;
+    constructor(source: NodeJS.ReadableStream);
+    /**
+     * If the source stream is larger than the 'size' the user is consuming (i.e. they're only wanting to upload a subset
+     * of the stream) then the stream won't be resolved by the 'end' event inside 'runChunkPipeline', so calling this
+     * method is necessary.
+     */
+    finishedConsuming(): void;
+    /**
+     * Promise resolves when the entire stream has finished processing, or an error occurs.
+     * You must call 'take' a sufficient number of times after calling this method in order for this promise to resolve.
+     */
+    runChunkPipeline(): Promise<void>;
+    /**
+     * Only call 'take' after the previously returned stream has been fully consumed.
+     */
+    take(bytes: number): Promise<NodeJS.ReadableStream>;
+    private consumeFromBuffer;
+    private splitBuffer;
+    private emptyStream;
+    private finishStream;
+}

package/dist/types/utils/Model.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+/**
+ * Supported implementations:
+ * - Node.js 'buffer.Blob', e.g. 'new buffer.Blob([JSON.stringify({someValue: 42})], {type: "application/json"})'
+ * - 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 "../gen";
+import { ChunkedStream } from "./ChunkedStream";
+export interface BlobLike {
+    readonly name?: string;
+    readonly size: number;
+    readonly type?: string;
+    slice: (start?: number, end?: number) => BlobLike;
+}
+export interface CancellationToken {
+    isCancelled: boolean;
+}
+export declare class CancelledError extends Error {
+    msg?: string | undefined;
+    name: "CancelledError";
+    constructor(msg?: string | undefined);
+}
+export declare type UploadSource = NodeJS.ReadableStream | BlobLike | Buffer | string;
+export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "size" | "protocol"> {
+    accountId: string;
+    cancellationToken?: CancellationToken;
+    data: UploadSource;
+    maxConcurrentUploadParts?: number;
+    /**
+     * Only required if 'data' is a 'ReadableStream'.
+     */
+    size?: number;
+}
+export declare type UploadSourceProcessed = ChunkedStream | BlobLike | Buffer;

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type * as stream from "stream";
+import type * as buffer from "buffer";
+import { BlobLike } from "./Model";
+/**
+ * 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/utils/UploadManager.d.ts

@@ -0,0 +1,39 @@
+import { FileDetails } from "../gen";
+import { UploadManagerParams } from "./Model";
+export declare class UploadManager {
+    private readonly configuration;
+    private readonly stringMimeType;
+    private readonly defaultMaxConcurrentUploadParts;
+    private readonly uploadApi;
+    constructor(configuration?: import("../gen").Configuration);
+    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/utils/index.d.ts

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

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@bytescale/sdk",
+  "version": "1.0.0-alpha.1",
+  "description": "Bytescale JavaScript SDK",
+  "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
+  "license": "MIT",
+  "types": "dist/types/index.d.ts",
+  "main": "dist/node/cjs/main.js",
+  "module": "dist/node/esm/main.mjs",
+  "browser": "dist/browser/cjs/main.js",
+  "exports": {
+    ".": {
+      "node": {
+        "require": "./dist/node/cjs/main.js",
+        "import": "./dist/node/esm/main.mjs"
+      },
+      "browser": {
+        "require": "./dist/browser/cjs/main.js"
+      },
+      "default": "./dist/node/esm/main.mjs"
+    }
+  },
+  "homepage": "https://github.com/bytescale/bytescale-javascript-sdk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytescale/bytescale-javascript-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bytescale/bytescale-javascript-sdk/issues"
+  },
+  "files": [
+    "/dist/**/*",
+    "/tests/**/*"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist && rm -f bytescale-sdk.tgz",
+    "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",
+    "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",
+    "publish:executeIfReleaseCommit": "bash -c 'COMMIT=$(git log -1 --pretty=%B) && [ \"${COMMIT:0:8}\" != \"Release \" ] || npm run publish:execute'",
+    "publish:execute": "npm run publish:cdn && npm publish && npm run publish:createGitHubRelease",
+    "publish:createGitHubRelease": "gh release create v$(node -p \"require('./package.json').version\")",
+    "publish:cdn": "npm run prepack:cdn && aws s3 cp --recursive --content-type application/javascript dist/ s3://bytescale-js-releases/sdk/ && aws cloudfront create-invalidation --distribution-id EO4VJPLCDN8HY --paths '/sdk/*'"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*/**/*.{ts,tsx}": [
+      "bash -c \"tsc --noEmit\""
+    ],
+    "*/**/*.{js,jsx,ts,tsx}": [
+      "eslint"
+    ],
+    "*.{js,jsx,ts,tsx,json,css,html,md,yaml,yml}": [
+      "prettier -w"
+    ]
+  },
+  "devDependencies": {
+    "@babel/cli": "7.19.3",
+    "@babel/core": "7.20.5",
+    "@babel/preset-env": "7.20.2",
+    "@types/jest": "29.2.4",
+    "@typescript-eslint/eslint-plugin": "4.33.0",
+    "@typescript-eslint/parser": "4.33.0",
+    "babel-loader": "8.2.1",
+    "babel-plugin-transform-async-to-promises": "0.8.15",
+    "eslint": "7.32.0",
+    "eslint-config-prettier": "6.15.0",
+    "eslint-config-standard-with-typescript": "19.0.1",
+    "eslint-plugin-import": "2.22.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "4.2.1",
+    "eslint-plugin-return-types-object-literals": "1.0.1",
+    "eslint-plugin-standard": "4.1.0",
+    "husky": "7.0.4",
+    "jest": "29.3.1",
+    "lint-staged": "10.5.1",
+    "node-fetch": "3.3.0",
+    "prettier": "2.8.1",
+    "ts-jest": "29.0.3",
+    "ts-loader": "9.2.2",
+    "tsc-alias": "1.2.10",
+    "typescript": "4.4.4",
+    "webpack": "5.75.0",
+    "webpack-cli": "4.10.0",
+    "webpack-node-externals": "2.5.2",
+    "webpack-shell-plugin-next": "2.3.1",
+    "wrapper-webpack-plugin": "2.2.2"
+  }
+}

package/tests/ChunkedStream.test.ts

@@ -0,0 +1,49 @@
+import { ChunkedStream } from "../src";
+import { createRandomStreamFactory } from "./utils/RandomStream";
+import { streamToBuffer } from "./utils/StreamToBuffer";
+
+describe("ChunkedStream", () => {
+  test(
+    "forward the entire stream",
+    async () => {
+      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 worker = chunkedStream.runChunkPipeline();
+      let remaining = expectedSize;
+      const buffersFromParts = Array<Buffer>();
+
+      while (remaining > 0) {
+        const nextPartSize = (): number => {
+          const next = Math.min(remaining, Math.round(Math.random() * maxPartSize) + 1);
+          remaining -= next;
+          return next;
+        };
+
+        const partSize = nextPartSize();
+
+        const subStream = await chunkedStream.take(partSize);
+        const subStreamBuffer = await streamToBuffer(subStream);
+
+        expect(subStreamBuffer.byteLength).toEqual(partSize);
+        expect(subStreamBuffer.length).toEqual(partSize);
+
+        buffersFromParts.push(subStreamBuffer);
+      }
+
+      chunkedStream.finishedConsuming();
+      await worker;
+
+      const actual = Buffer.concat(buffersFromParts);
+      const expected = await streamToBuffer(expectedData());
+
+      const buffersEqual = Buffer.compare(expected, actual) === 0;
+
+      expect(actual.length).toEqual(expected.length);
+      expect(actual.byteLength).toEqual(expected.byteLength);
+      expect(buffersEqual).toEqual(true);
+    },
+    10 * 60 * 1000
+  );
+});

package/tests/UploadManager.test.ts

@@ -0,0 +1,164 @@
+import { UploadManager, Configuration, FileApi } from "../src";
+import fetch from "node-fetch";
+import * as buffer from "buffer";
+import { createRandomStreamFactory } from "./utils/RandomStream";
+import { streamToBuffer } from "./utils/StreamToBuffer";
+import { promises as fsAsync } from "fs";
+import { prepareTempDirectory } from "./utils/TempUtils";
+import * as Path from "path";
+
+if (process.env.BYTESCALE_SECRET_API_KEY === undefined) {
+  throw new Error("Expected env var: BYTESCALE_SECRET_API_KEY");
+}
+if (process.env.BYTESCALE_ACCOUNT_ID === undefined) {
+  throw new Error("Expected env var: BYTESCALE_ACCOUNT_ID");
+}
+const accountId = process.env.BYTESCALE_ACCOUNT_ID;
+
+const configuration = new Configuration({
+  fetchApi: fetch as any,
+  apiKey: process.env.BYTESCALE_SECRET_API_KEY // e.g. "secret_xxxxx"
+});
+
+const uploadManager = new UploadManager(configuration);
+const fileApi = new FileApi(configuration);
+const largeFileSize = Math.pow(1024, 2) * 500; // 500MB
+
+async function testStreamingUpload(expectedSize: number): Promise<void> {
+  const expectedData = await createRandomStreamFactory(expectedSize);
+  const uploadedFile = await uploadManager.upload({
+    accountId,
+    data: expectedData(),
+    size: expectedSize
+  });
+  const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+  const actualData = (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).stream();
+  const expectedDataBuffer = await streamToBuffer(expectedData());
+  const actualDataBuffer = await streamToBuffer(actualData as any);
+  const buffersEqual = Buffer.compare(expectedDataBuffer, actualDataBuffer) === 0;
+  const actualSize = fileDetails.size;
+
+  expect(actualSize).toEqual(expectedSize);
+  expect(actualDataBuffer.length).toEqual(expectedDataBuffer.length);
+  expect(actualDataBuffer.byteLength).toEqual(expectedDataBuffer.byteLength);
+
+  if (!buffersEqual) {
+    const dir = await prepareTempDirectory();
+    await fsAsync.writeFile(Path.join(dir, "expected.txt"), expectedDataBuffer);
+    await fsAsync.writeFile(Path.join(dir, "actual.txt"), actualDataBuffer);
+  }
+
+  expect(buffersEqual).toEqual(true);
+}
+
+describe("UploadManager", () => {
+  test("upload an empty string", async () => {
+    const expectedData = "";
+    const expectedSize = 0;
+    const uploadedFile = await uploadManager.upload({
+      accountId,
+      data: expectedData
+    });
+    const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+    const actualData = await (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).text();
+    const actualSize = fileDetails.size;
+    expect(actualData).toEqual(expectedData);
+    expect(actualSize).toEqual(expectedSize);
+  });
+
+  test("upload a string", async () => {
+    const expectedData = "Example Data";
+    const expectedMime = "text/plain";
+    const uploadedFile = await uploadManager.upload({
+      accountId,
+      data: expectedData
+    });
+    const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+    const actualData = await (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).text();
+    const actualMime = fileDetails.mime;
+    expect(actualData).toEqual(expectedData);
+    expect(actualMime).toEqual(expectedMime);
+  });
+
+  test("upload a BLOB", async () => {
+    const expectedData = JSON.stringify({ someValue: 42 });
+    const expectedMime = "application/json";
+    const uploadedFile = await uploadManager.upload({
+      accountId,
+      data: new buffer.Blob([expectedData], { type: expectedMime })
+    });
+    const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+    const actualData = await (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).text();
+    const actualMime = fileDetails.mime;
+    expect(actualData).toEqual(expectedData);
+    expect(actualMime).toEqual(expectedMime);
+  });
+
+  test("upload a buffer (override MIME)", async () => {
+    const expectedData = "Example Data";
+    const expectedMime = "text/plain";
+    const uploadedFile = await uploadManager.upload({
+      accountId,
+      data: Buffer.from(expectedData, "utf8"),
+      mime: expectedMime
+    });
+    const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+    const actualData = await (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).text();
+    const actualMime = fileDetails.mime;
+    expect(actualData).toEqual(expectedData);
+    expect(actualMime).toEqual(expectedMime);
+  });
+
+  test("upload a small buffer", async () => {
+    const expectedData = "Example Data";
+    const expectedMime = "application/octet-stream";
+    const uploadedFile = await uploadManager.upload({
+      accountId,
+      data: Buffer.from(expectedData, "utf8")
+    });
+    const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+    const actualData = await (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).text();
+    const actualMime = fileDetails.mime;
+    expect(actualData).toEqual(expectedData);
+    expect(actualMime).toEqual(expectedMime);
+  });
+
+  test(
+    "upload a large buffer",
+    async () => {
+      const expectedSize = largeFileSize;
+      const expectedData = await streamToBuffer((await createRandomStreamFactory(expectedSize))());
+      const uploadedFile = await uploadManager.upload({
+        accountId,
+        data: expectedData
+      });
+      const fileDetails = await fileApi.getFileDetails({ accountId, filePath: uploadedFile.filePath });
+      const actualStream = (await fileApi.downloadFile({ accountId, filePath: uploadedFile.filePath })).stream();
+      const actualData = await streamToBuffer(actualStream as any);
+      const actualSize = fileDetails.size;
+      const buffersEqual = Buffer.compare(expectedData, actualData) === 0;
+
+      expect(actualSize).toEqual(expectedSize);
+      expect(actualData.length).toEqual(expectedData.length);
+      expect(actualData.byteLength).toEqual(expectedData.byteLength);
+      expect(buffersEqual).toEqual(true);
+    },
+    10 * 60 * 1000
+  );
+
+  test(
+    "upload a small stream",
+    async () => {
+      await testStreamingUpload(Math.pow(1024, 2) * 2); // 2MB
+    },
+    10 * 60 * 1000
+  );
+
+  test(
+    "upload a large stream",
+    async () => {
+      await testStreamingUpload(largeFileSize); // 500MB
+    },
+    10 * 60 * 1000
+  );
+});