@super-protocol/sp-cli 0.0.2-beta.9 → 0.0.3

package/dist/services/storage.service.js

@@ -4,17 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { StorageType, } from '@super-protocol/dto-js';
+import { StorageResourceSchema, StorageType, } from '@super-protocol/dto-js';
 import { ResourceType, } from '@super-protocol/provider-client';
 import { download, upload } from '@super-protocol/sp-files-addon';
 import * as fs from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { Value } from 'typebox/value';
 import { Retryable } from 'typescript-retry-decorator';
-import { storageResourceSchema } from '../config/resource.schema.js';
 import { S3_ENDPOINT } from '../constants.js';
 import { ProviderClientError } from '../errors.js';
-import { preparePath, readJsonFile } from '../utils/helper.js';
+import { joinPaths, preparePath, readJsonFile } from '../utils/helper.js';
 export class StorageError extends Error {
 }
 export class StoragesUndefinedError extends StorageError {
@@ -58,7 +57,7 @@ export class StorageService {
     }
     async download(params, progressCb) {
         const resourceFile = await readJsonFile({ path: params.resourcePath });
-        if (!Value.Check(storageResourceSchema, resourceFile)) {
+        if (!Value.Check(StorageResourceSchema, resourceFile)) {
             throw new StorageError('Invalid resource file format, please verify resource.json against the schema.');
         }
         const { resource } = resourceFile;
@@ -67,13 +66,26 @@ export class StorageService {
         }
         let localPath = preparePath(params.downloadPath);
         if (resource.filepath) {
-            localPath = join(localPath, resource.filepath);
+            const sanitizedFilepath = resource.filepath.replaceAll('..', '').replace(/^\/+/, '');
+            localPath = joinPaths(localPath, sanitizedFilepath);
+        }
+        try {
+            this.logger.info('Starting download');
+            const downloadResult = await download(resource, localPath, {
+                encryption: resourceFile.encryption,
+                progressCallback: progressCb,
+                retry: {
+                    initialDelayMs: 0,
+                    maxRetries: 2,
+                },
+                threads: params.maximumConcurrent,
+            });
+            this.logger.info(downloadResult, 'Downloaded');
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Download failed with error');
+            throw error;
         }
-        await download(resource, localPath, {
-            encryption: resourceFile.encryption,
-            progressCallback: progressCb,
-            threads: params.maximumConcurrent,
-        });
     }
     async getCentralizedStorage() {
         try {
@@ -114,6 +126,9 @@ export class StorageService {
             throw error_;
         }
     }
+    getLabel(storage) {
+        return `${storage.isCentralized ? 'Super cloud' : `${storage.storageType} - ${storage.bucket}/${storage.prefix}`} `;
+    }
     async hasStorage() {
         try {
             const { data, error } = await this.providerClient.GET('/api/user-settings');
@@ -182,11 +197,20 @@ export class StorageService {
     async saveStorage(selectedStorage) {
         this.logger.info({ selectedStorage }, 'Saving selected storage');
         try {
-            const { data, error } = await this.providerClient.POST('/api/user-settings', {
+            let { data, error } = await this.providerClient.PATCH('/api/user-settings', {
                 body: {
                     activeStorageId: selectedStorage,
                 },
             });
+            if (error && error.statusCode === 404) {
+                const result = await this.providerClient.POST('/api/user-settings', {
+                    body: {
+                        activeStorageId: selectedStorage,
+                    },
+                });
+                error = result.error;
+                data = result.data;
+            }
             if (error) {
                 throw new StorageError(`User settings request error ${error.message}`);
             }
@@ -225,8 +249,8 @@ export class StorageService {
     }
     async upload(params, progressCb) {
         const storage = await this.getCurrentStorage();
-        const remotePath = `${params.remotePath || generateExternalId()}`;
-        const resourceFilePath = preparePath(params.outputPath || '');
+        const remotePath = params.remotePath ? params.remotePath.replaceAll('..', '').replace(/^\/+/, '') : generateExternalId();
+        const resourceFilePath = preparePath(params.outputPath ?? 'resource.json');
         try {
             await fs.stat(resourceFilePath);
             throw new Error('Output file for resource file already exists');
@@ -240,32 +264,7 @@ export class StorageService {
         if (params.metadataPath) {
             metadata = await readJsonFile({ path: preparePath(params.metadataPath) });
         }
-        const writeCredentials = storage.storageType === StorageType.StorJ
-            ? {
-                bucket: storage.bucket,
-                prefix: join(storage.prefix, remotePath),
-                token: storage.storjCredentials.writeAccessToken,
-            }
-            : {
-                accessKeyId: storage.s3Credentials.writeAccessKeyId,
-                bucket: storage.bucket,
-                endpoint: S3_ENDPOINT,
-                prefix: join(storage.prefix, remotePath),
-                secretKey: storage.s3Credentials.writeSecretAccessKey,
-            };
-        const readCredentials = storage.storageType === StorageType.StorJ
-            ? {
-                bucket: storage.bucket,
-                prefix: join(storage.prefix, remotePath),
-                token: storage.storjCredentials.readAccessToken,
-            }
-            : {
-                accessKeyId: storage.s3Credentials.readAccessKeyId,
-                bucket: storage.bucket,
-                endpoint: S3_ENDPOINT,
-                prefix: join(storage.prefix, remotePath),
-                secretKey: storage.s3Credentials.readSecretAccessKey,
-            };
+        const { readCredentials, writeCredentials } = this.getStorageCredentials(storage, remotePath);
         const info = await fs.stat(params.localPath);
         let { localPath } = params;
         let sourcePath;
@@ -274,6 +273,7 @@ export class StorageService {
             localPath = dirname(localPath);
         }
         try {
+            this.logger.info('Starting upload');
             const uploadResult = await upload(localPath, {
                 credentials: writeCredentials,
                 filepath: '',
@@ -282,6 +282,10 @@ export class StorageService {
             }, {
                 encryption: params.withEncryption,
                 progressCallback: progressCb,
+                retry: {
+                    initialDelayMs: 0,
+                    maxRetries: 2,
+                },
                 sourcePath,
                 sync: params.sync,
                 threads: params.maximumConcurrent,
@@ -296,11 +300,50 @@ export class StorageService {
             this.logger.info(`Resource file was created in ${resourceFilePath}`);
         }
         catch (error) {
-            this.logger.error({ err: error }, 'Somethong went wrong with upload');
-            console.log(error);
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
-            throw error_;
+            this.logger.error({ err: error }, 'Something went wrong with upload');
+            throw error;
+        }
+    }
+    getStorageCredentials(storage, remotePath) {
+        if (storage.storageType === StorageType.StorJ) {
+            const { readAccessToken, writeAccessToken } = storage.storjCredentials || {};
+            if (!writeAccessToken || !readAccessToken) {
+                throw new StorageError('StorJ credentials are missing or incomplete');
+            }
+            return {
+                readCredentials: {
+                    bucket: storage.bucket,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    token: readAccessToken,
+                }, writeCredentials: {
+                    bucket: storage.bucket,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    token: writeAccessToken,
+                },
+            };
+        }
+        if (storage.storageType === StorageType.S3) {
+            const { readAccessKeyId, readSecretAccessKey, writeAccessKeyId, writeSecretAccessKey } = storage.s3Credentials || {};
+            if (!writeAccessKeyId || !writeSecretAccessKey || !readAccessKeyId || !readSecretAccessKey) {
+                throw new StorageError('S3 credentials are missing or incomplete');
+            }
+            return {
+                readCredentials: {
+                    accessKeyId: readAccessKeyId,
+                    bucket: storage.bucket,
+                    endpoint: S3_ENDPOINT,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    secretKey: readSecretAccessKey,
+                }, writeCredentials: {
+                    accessKeyId: writeAccessKeyId,
+                    bucket: storage.bucket,
+                    endpoint: S3_ENDPOINT,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    secretKey: writeSecretAccessKey,
+                },
+            };
         }
+        throw new StorageError(`Unknown storage type: ${storage.storageType}`);
     }
 }
 __decorate([

package/dist/utils/helper.d.ts

@@ -1,5 +1,6 @@
 export declare const getConfigName: (name: string) => string;
 export declare const preparePath: (rawPath: string) => string;
+export declare const joinPaths: (...args: string[]) => string;
 export type ReadJsonFileParams = {
     path: string;
 };

package/dist/utils/helper.js

@@ -7,6 +7,7 @@ export const preparePath = (rawPath) => {
         return rawPath;
     return path.join(process.cwd(), rawPath);
 };
+export const joinPaths = (...args) => path.join(...args).replaceAll('\\', '/');
 export const readJsonFile = async (params) => {
     if (!existsSync(params.path)) {
         throw new Error(`File could not be found in ${params.path}`);

package/dist/utils/progress.js

@@ -2,6 +2,7 @@ import * as p from '@clack/prompts';
 export const createProgressPrinter = ({ action, done = 'completed', start, }) => {
     const progressBars = {};
     let lastKey = '';
+    let lastProgress = 0;
     const getProgress = (key) => {
         if (key in progressBars) {
             lastKey = key;
@@ -9,6 +10,7 @@ export const createProgressPrinter = ({ action, done = 'completed', start, }) =>
         }
         if (lastKey in progressBars) {
             const progressBar = progressBars[lastKey];
+            lastProgress = 0;
             progressBar.stop(`${action} ${lastKey} ${done}`);
         }
         const progressBar = p.progress({ size: 100, style: 'block' });
@@ -16,11 +18,17 @@ export const createProgressPrinter = ({ action, done = 'completed', start, }) =>
         progressBars[key] = progressBar;
         return progressBar;
     };
-    const finish = () => progressBars[lastKey].stop(`${action} ${lastKey} ${done}`);
+    const finish = () => {
+        if (lastKey && progressBars[lastKey]) {
+            lastProgress = 0;
+            progressBars[lastKey].stop(`${action} ${lastKey} ${done}`);
+        }
+    };
     return {
         advance(key, num, message) {
             const progress = getProgress(key);
-            progress.advance(num, message);
+            progress.advance(num - lastProgress, message);
+            lastProgress = num;
         },
         finish,
     };