@sprucelabs/spruce-file-utils 15.0.2 → 15.1.1

package/build/esm/index-module.d.ts

@@ -1,2 +1,4 @@
 export { default as FileUploaderImpl } from './uploading/FileUploader';
 export * from './uploading/FileUploader';
+export { default as ChunkingUploaderImpl } from './uploading/ChunkingUploader';
+export * from './uploading/ChunkingUploader';

package/build/esm/index-module.js

@@ -1,2 +1,4 @@
 export { default as FileUploaderImpl } from './uploading/FileUploader.js';
 export * from './uploading/FileUploader.js';
+export { default as ChunkingUploaderImpl } from './uploading/ChunkingUploader.js';
+export * from './uploading/ChunkingUploader.js';

package/build/esm/uploading/ChunkingUploader.d.ts

@@ -0,0 +1,55 @@
+import { MercuryConnectFactory } from '@sprucelabs/mercury-client';
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { MercuryEventEmitter } from '@sprucelabs/mercury-types';
+import { UploadedFile } from '../files.types';
+export default class ChunkingUploaderImpl extends AbstractEventEmitter<ChunkingUploaderEventContract> implements ChunkingUploader {
+    private connectToApi;
+    static fetch: typeof fetch;
+    static chunkSizeKb: number;
+    static Class?: new (connectToApi: MercuryConnectFactory) => ChunkingUploader;
+    private restEndpointUrl?;
+    private person;
+    private proxyToken;
+    protected constructor(connectToApi: MercuryConnectFactory);
+    static Uploader(connectToApi: MercuryConnectFactory): ChunkingUploaderImpl | ChunkingUploader;
+    upload(options: UploadOptions): Promise<{
+        file: UploadedFile;
+    }>;
+    private uploadChunking;
+    private splitIntoChunks;
+    private get chunkSizeKb();
+    private doesSupportChunking;
+    private emitUpload;
+    private loadRestEndpoint;
+    private login;
+    private post;
+    private get fetch();
+}
+export interface ChunkingUploader extends MercuryEventEmitter<ChunkingUploaderEventContract> {
+    upload(options: UploadOptions): Promise<{
+        file: UploadedFile;
+    }>;
+}
+declare const chunkingUploaderEventContract: {
+    eventSignatures: {
+        'did-upload-chunk': {
+            emitPayloadSchema: {
+                id: string;
+                fields: {
+                    percentComplete: {
+                        type: "number";
+                        isRequired: true;
+                    };
+                };
+            };
+        };
+    };
+};
+type ChunkingUploaderEventContract = typeof chunkingUploaderEventContract;
+export interface UploadOptions {
+    fileName: string;
+    base64: string;
+    locationId?: string;
+    organizationId?: string;
+}
+export {};

package/build/esm/uploading/ChunkingUploader.js

@@ -0,0 +1,162 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { buildEventContract, } from '@sprucelabs/mercury-types';
+import { assertOptions, buildSchema } from '@sprucelabs/schema';
+import SpruceError from '../errors/SpruceError.js';
+class ChunkingUploaderImpl extends AbstractEventEmitter {
+    constructor(connectToApi) {
+        super(chunkingUploaderEventContract);
+        this.connectToApi = connectToApi;
+    }
+    static Uploader(connectToApi) {
+        var _a;
+        assertOptions({ connectToApi }, ['connectToApi']);
+        return new ((_a = this.Class) !== null && _a !== void 0 ? _a : this)(connectToApi);
+    }
+    upload(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fileName, locationId, organizationId, base64 } = assertOptions(options, ['fileName', 'base64']);
+            yield this.login();
+            yield this.loadRestEndpoint();
+            const method = this.doesSupportChunking() ? 'uploadChunking' : 'emitUpload';
+            const file = yield this[method]({
+                fileName,
+                locationId,
+                organizationId,
+                base64,
+            });
+            return { file };
+        });
+    }
+    uploadChunking(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fileName, locationId, organizationId, base64 } = options;
+            const totalChunks = Math.ceil(base64.length / (this.chunkSizeKb * 1024));
+            const initialize = yield this.post('/initialize', {
+                proxyToken: this.proxyToken,
+                fileName,
+                personId: this.person.id,
+                totalChunks,
+                locationId,
+                organizationId,
+            });
+            const chunks = this.splitIntoChunks(base64);
+            let upload = {};
+            for (let i = 0; i < chunks.length; i++) {
+                const chunk = chunks[i];
+                upload = yield this.post('/upload', {
+                    chunkIdx: i,
+                    base64: chunk,
+                }, {
+                    'x-upload-token': initialize.uploadToken,
+                });
+                const percentComplete = (i + 1) / totalChunks;
+                yield this.emit('did-upload-chunk', {
+                    percentComplete,
+                });
+            }
+            const file = upload.file;
+            return file;
+        });
+    }
+    splitIntoChunks(base64) {
+        const chunks = [];
+        for (let i = 0; i < base64.length; i += this.chunkSizeKb * 1024) {
+            chunks.push(base64.slice(i, i + this.chunkSizeKb * 1024));
+        }
+        return chunks;
+    }
+    get chunkSizeKb() {
+        return ChunkingUploaderImpl.chunkSizeKb;
+    }
+    doesSupportChunking() {
+        return !!this.restEndpointUrl;
+    }
+    emitUpload(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { organizationId, locationId, base64, fileName } = options;
+            const client = yield this.connectToApi();
+            const [{ file }] = yield client.emitAndFlattenResponses('files.upload::v2022_05_13', {
+                target: {
+                    organizationId,
+                    locationId,
+                },
+                payload: {
+                    base64Body: base64,
+                    name: fileName,
+                },
+            });
+            return file;
+        });
+    }
+    loadRestEndpoint() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.connectToApi();
+            const [{ restEndpointUrl }] = yield client.emitAndFlattenResponses('files.get-upload-endpoint::v2022_05_13');
+            this.restEndpointUrl = restEndpointUrl;
+        });
+    }
+    login() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.connectToApi();
+            const [{ type, auth }] = yield client.emitAndFlattenResponses('whoami::v2020_12_25');
+            if (type === 'anonymous') {
+                throw new SpruceError({
+                    code: 'UNAUTHORIZED',
+                    friendlyMessage: `You have to be logged in before you can upload any files.`,
+                    endpoint: 'whoami::v2020_12_25',
+                });
+            }
+            this.person = auth.person;
+            this.proxyToken = client.getProxyToken();
+            return client;
+        });
+    }
+    post(path, postBody, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.fetch(this.restEndpointUrl + path, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, headers),
+                method: 'POST',
+                body: JSON.stringify(postBody),
+            });
+            const body = yield response.json();
+            if (response.status !== 200) {
+                throw new SpruceError({
+                    code: response.status === 400 ? 'BAD_REQUEST' : 'UNAUTHORIZED',
+                    friendlyMessage: body.errorMessage,
+                    endpoint: this.restEndpointUrl + path,
+                });
+            }
+            return body;
+        });
+    }
+    get fetch() {
+        return ChunkingUploaderImpl.fetch;
+    }
+}
+ChunkingUploaderImpl.fetch = fetch;
+ChunkingUploaderImpl.chunkSizeKb = 1024;
+export default ChunkingUploaderImpl;
+const chunkingUploaderEventContract = buildEventContract({
+    eventSignatures: {
+        'did-upload-chunk': {
+            emitPayloadSchema: buildSchema({
+                id: 'didUploadChunkPayload',
+                fields: {
+                    percentComplete: {
+                        type: 'number',
+                        isRequired: true,
+                    },
+                },
+            }),
+        },
+    },
+});

package/build/index-module.d.ts

@@ -1,2 +1,4 @@
 export { default as FileUploaderImpl } from './uploading/FileUploader';
 export * from './uploading/FileUploader';
+export { default as ChunkingUploaderImpl } from './uploading/ChunkingUploader';
+export * from './uploading/ChunkingUploader';

package/build/index-module.js

@@ -17,7 +17,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileUploaderImpl = void 0;
+exports.ChunkingUploaderImpl = exports.FileUploaderImpl = void 0;
 var FileUploader_1 = require("./uploading/FileUploader");
 Object.defineProperty(exports, "FileUploaderImpl", { enumerable: true, get: function () { return __importDefault(FileUploader_1).default; } });
 __exportStar(require("./uploading/FileUploader"), exports);
+var ChunkingUploader_1 = require("./uploading/ChunkingUploader");
+Object.defineProperty(exports, "ChunkingUploaderImpl", { enumerable: true, get: function () { return __importDefault(ChunkingUploader_1).default; } });
+__exportStar(require("./uploading/ChunkingUploader"), exports);

package/build/uploading/ChunkingUploader.d.ts

@@ -0,0 +1,55 @@
+import { MercuryConnectFactory } from '@sprucelabs/mercury-client';
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { MercuryEventEmitter } from '@sprucelabs/mercury-types';
+import { UploadedFile } from '../files.types';
+export default class ChunkingUploaderImpl extends AbstractEventEmitter<ChunkingUploaderEventContract> implements ChunkingUploader {
+    private connectToApi;
+    static fetch: typeof fetch;
+    static chunkSizeKb: number;
+    static Class?: new (connectToApi: MercuryConnectFactory) => ChunkingUploader;
+    private restEndpointUrl?;
+    private person;
+    private proxyToken;
+    protected constructor(connectToApi: MercuryConnectFactory);
+    static Uploader(connectToApi: MercuryConnectFactory): ChunkingUploaderImpl | ChunkingUploader;
+    upload(options: UploadOptions): Promise<{
+        file: UploadedFile;
+    }>;
+    private uploadChunking;
+    private splitIntoChunks;
+    private get chunkSizeKb();
+    private doesSupportChunking;
+    private emitUpload;
+    private loadRestEndpoint;
+    private login;
+    private post;
+    private get fetch();
+}
+export interface ChunkingUploader extends MercuryEventEmitter<ChunkingUploaderEventContract> {
+    upload(options: UploadOptions): Promise<{
+        file: UploadedFile;
+    }>;
+}
+declare const chunkingUploaderEventContract: {
+    eventSignatures: {
+        'did-upload-chunk': {
+            emitPayloadSchema: {
+                id: string;
+                fields: {
+                    percentComplete: {
+                        type: "number";
+                        isRequired: true;
+                    };
+                };
+            };
+        };
+    };
+};
+type ChunkingUploaderEventContract = typeof chunkingUploaderEventContract;
+export interface UploadOptions {
+    fileName: string;
+    base64: string;
+    locationId?: string;
+    organizationId?: string;
+}
+export {};

package/build/uploading/ChunkingUploader.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mercury_event_emitter_1 = require("@sprucelabs/mercury-event-emitter");
+const mercury_types_1 = require("@sprucelabs/mercury-types");
+const schema_1 = require("@sprucelabs/schema");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+class ChunkingUploaderImpl extends mercury_event_emitter_1.AbstractEventEmitter {
+    constructor(connectToApi) {
+        super(chunkingUploaderEventContract);
+        this.connectToApi = connectToApi;
+    }
+    static Uploader(connectToApi) {
+        (0, schema_1.assertOptions)({ connectToApi }, ['connectToApi']);
+        return new (this.Class ?? this)(connectToApi);
+    }
+    async upload(options) {
+        const { fileName, locationId, organizationId, base64 } = (0, schema_1.assertOptions)(options, ['fileName', 'base64']);
+        await this.login();
+        await this.loadRestEndpoint();
+        const method = this.doesSupportChunking() ? 'uploadChunking' : 'emitUpload';
+        const file = await this[method]({
+            fileName,
+            locationId,
+            organizationId,
+            base64,
+        });
+        return { file };
+    }
+    async uploadChunking(options) {
+        const { fileName, locationId, organizationId, base64 } = options;
+        const totalChunks = Math.ceil(base64.length / (this.chunkSizeKb * 1024));
+        const initialize = await this.post('/initialize', {
+            proxyToken: this.proxyToken,
+            fileName,
+            personId: this.person.id,
+            totalChunks,
+            locationId,
+            organizationId,
+        });
+        const chunks = this.splitIntoChunks(base64);
+        let upload = {};
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            upload = await this.post('/upload', {
+                chunkIdx: i,
+                base64: chunk,
+            }, {
+                'x-upload-token': initialize.uploadToken,
+            });
+            const percentComplete = (i + 1) / totalChunks;
+            await this.emit('did-upload-chunk', {
+                percentComplete,
+            });
+        }
+        const file = upload.file;
+        return file;
+    }
+    splitIntoChunks(base64) {
+        const chunks = [];
+        for (let i = 0; i < base64.length; i += this.chunkSizeKb * 1024) {
+            chunks.push(base64.slice(i, i + this.chunkSizeKb * 1024));
+        }
+        return chunks;
+    }
+    get chunkSizeKb() {
+        return ChunkingUploaderImpl.chunkSizeKb;
+    }
+    doesSupportChunking() {
+        return !!this.restEndpointUrl;
+    }
+    async emitUpload(options) {
+        const { organizationId, locationId, base64, fileName } = options;
+        const client = await this.connectToApi();
+        const [{ file }] = await client.emitAndFlattenResponses('files.upload::v2022_05_13', {
+            target: {
+                organizationId,
+                locationId,
+            },
+            payload: {
+                base64Body: base64,
+                name: fileName,
+            },
+        });
+        return file;
+    }
+    async loadRestEndpoint() {
+        const client = await this.connectToApi();
+        const [{ restEndpointUrl }] = await client.emitAndFlattenResponses('files.get-upload-endpoint::v2022_05_13');
+        this.restEndpointUrl = restEndpointUrl;
+    }
+    async login() {
+        const client = await this.connectToApi();
+        const [{ type, auth }] = await client.emitAndFlattenResponses('whoami::v2020_12_25');
+        if (type === 'anonymous') {
+            throw new SpruceError_1.default({
+                code: 'UNAUTHORIZED',
+                friendlyMessage: `You have to be logged in before you can upload any files.`,
+                endpoint: 'whoami::v2020_12_25',
+            });
+        }
+        this.person = auth.person;
+        this.proxyToken = client.getProxyToken();
+        return client;
+    }
+    async post(path, postBody, headers) {
+        const response = await this.fetch(this.restEndpointUrl + path, {
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+            method: 'POST',
+            body: JSON.stringify(postBody),
+        });
+        const body = await response.json();
+        if (response.status !== 200) {
+            throw new SpruceError_1.default({
+                code: response.status === 400 ? 'BAD_REQUEST' : 'UNAUTHORIZED',
+                friendlyMessage: body.errorMessage,
+                endpoint: this.restEndpointUrl + path,
+            });
+        }
+        return body;
+    }
+    get fetch() {
+        return ChunkingUploaderImpl.fetch;
+    }
+}
+ChunkingUploaderImpl.fetch = fetch;
+ChunkingUploaderImpl.chunkSizeKb = 1024;
+exports.default = ChunkingUploaderImpl;
+const chunkingUploaderEventContract = (0, mercury_types_1.buildEventContract)({
+    eventSignatures: {
+        'did-upload-chunk': {
+            emitPayloadSchema: (0, schema_1.buildSchema)({
+                id: 'didUploadChunkPayload',
+                fields: {
+                    percentComplete: {
+                        type: 'number',
+                        isRequired: true,
+                    },
+                },
+            }),
+        },
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@sprucelabs/spruce-file-utils",
 	"description": "Utils for working with files and Sprucebot.",
-	"version": "15.0.2",
+	"version": "15.1.1",
 	"skill": {
 		"namespace": "files"
 	},
@@ -25,6 +25,11 @@
 		"build/uploading/FileUploader.d.ts",
 		"build/uploading/FileUploader.js",
 		
+		"build/esm/uploading/ChunkingUploader.d.ts",
+		"build/esm/uploading/ChunkingUploader.js",
+		"build/uploading/ChunkingUploader.d.ts",
+		"build/uploading/ChunkingUploader.js",
+		
 		"build/esm/uploading/LocalUploadStrategy.d.ts",
 		"build/esm/uploading/LocalUploadStrategy.js",
 		"build/uploading/LocalUploadStrategy.d.ts",
@@ -42,10 +47,11 @@
 	},
 	"dependencies": {
 		"@sprucelabs/schema": "latest",
+		"@sprucelabs/mercury-event-emitter": "latest",
 		"aws-sdk": "^2.1558.0",
 		"file-type": "16.5.3",
-		"mime-types": "^2.1.35",
-		"uuid": "^9.0.1"
+		"@types/mime-types": "^3.0.1",
+		"uuid": "^11.1.0"
 	},
 	"engines": {
 		"yarn": "1.x"