@super-protocol/sp-cli 0.0.9 → 0.0.10-beta

package/dist/services/storage.service.js

@@ -1,378 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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 * as fs from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-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 { Value } from 'typebox/value';
-import { Retryable } from 'typescript-retry-decorator';
-import { S3_ENDPOINT } from '../constants.js';
-import { ProviderClientError } from '../errors.js';
-import { joinPaths, preparePath, readJsonFile } from '../utils/helper.js';
-export class StorageError extends Error {
-}
-export class StoragesUndefinedError extends StorageError {
-}
-export class StorageCreateError extends StorageError {
-}
-export class StorageUpdateError extends StorageError {
-}
-export class StorageGetError extends StorageError {
-}
-export const generateExternalId = () => Array.from({ length: 16 })
-    .map(() => Math.floor(Math.random() * 16).toString(16))
-    .join('');
-export class StorageService {
-    providerClient;
-    logger;
-    constructor(providerClient, logger) {
-        this.providerClient = providerClient;
-        this.logger = logger;
-    }
-    async createStorage(storage) {
-        this.logger.info({ storageType: storage.storageType }, 'Creating storage');
-        try {
-            const { data, error } = await this.providerClient.POST('/api/storages', {
-                body: storage,
-            });
-            if (error?.message) {
-                this.logger.error({ err: error }, 'Failed to create storage');
-                throw new StorageCreateError(error.message);
-            }
-            if (!data) {
-                this.logger.error('Provider returned empty storage response');
-                throw new StorageCreateError('Incorrect response');
-            }
-            this.logger.info({ storageId: data.id }, 'Storage created successfully');
-            return data;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Storage creation failed');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async download(params, progressCb) {
-        const resourceFile = await readJsonFile({
-            path: params.resourcePath,
-        });
-        if (!Value.Check(StorageResourceSchema, resourceFile)) {
-            throw new StorageError('Invalid resource file format, please verify resource.json against the schema.');
-        }
-        const { resource } = resourceFile;
-        if (resource.type !== ResourceType.StorageProvider) {
-            throw new StorageError(`Resource type ${resource.type} is not supported, use StorageProvider type for this command`);
-        }
-        let localPath = preparePath(params.downloadPath);
-        if (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;
-        }
-    }
-    async getCentralizedStorage() {
-        try {
-            const storages = await this.requestStorages();
-            const centralized = storages.find((storage) => storage.isCentralized);
-            if (!centralized) {
-                const storage = await this.initCentralizedStorage();
-                return storage;
-            }
-            return centralized;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Error getting centralized storage');
-            if (error instanceof StoragesUndefinedError) {
-                const storage = await this.initCentralizedStorage();
-                return storage;
-            }
-            throw error;
-        }
-    }
-    async getCurrentStorage() {
-        try {
-            const { data, error } = await this.providerClient.GET('/api/user-settings');
-            if (error) {
-                throw new StorageGetError('Error getting storage');
-            }
-            const { activeStorageId } = data || {};
-            const storages = await this.requestStorages();
-            const storage = storages.find((storage) => storage.id === activeStorageId);
-            if (!storage) {
-                throw new StorageError('Selected storage not found please select storage first');
-            }
-            return storage;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Failed to get current storage');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            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');
-            if (error && error.statusCode === 404) {
-                return false;
-            }
-            if (error) {
-                this.logger.error({ err: error }, 'Error checking storage');
-                throw new StorageError(`Error request storage ${error}`);
-            }
-            if (!data) {
-                throw new StorageError('Error request storage');
-            }
-            return Boolean(data.activeStorageId);
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Storage initialization failed');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async initCentralizedStorage() {
-        this.logger.info('Requesting storage initialization');
-        try {
-            const result = await this.providerClient.POST('/api/storages/centralized');
-            if (result.error) {
-                this.logger.error({ err: result.error }, 'Failed to initialize storage');
-                throw new StorageCreateError(result.error.message);
-            }
-            if (!result.data) {
-                this.logger.error('Provider returned empty storage initialization response');
-                throw new StorageCreateError('Incorrect response');
-            }
-            this.logger.info('Storage initialized successfully');
-            return result.data;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Storage initialization failed');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async requestStorages() {
-        let data;
-        this.logger.info('Requesting available storages');
-        try {
-            const result = await this.providerClient.GET('/api/storages');
-            data = result.data;
-            if (result.error) {
-                this.logger.error({ err: result.error }, 'Failed to fetch storages');
-                throw new StorageError(result.error.message);
-            }
-            if (data === undefined) {
-                this.logger.warn('Storages list response is wrong');
-                throw new StoragesUndefinedError('Storages is empty please create or import first one');
-            }
-            this.logger.debug({ count: data.length }, 'Received storages list');
-            return data;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Failed to request storages');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async saveStorage(selectedStorage) {
-        this.logger.info({ selectedStorage }, 'Saving selected storage');
-        try {
-            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}`);
-            }
-            this.logger.info({ selectedStorage: data?.activeStorageId }, 'Selected storage saved successfully');
-            return data;
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Failed to save selected storage');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async updateStorage(id, storage) {
-        this.logger.info({ storageId: id }, 'Updating storage');
-        try {
-            const { data, error } = await this.providerClient.PATCH('/api/storages/{id}', {
-                body: storage,
-                params: { path: { id } },
-            });
-            if (error) {
-                this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
-                throw new StorageUpdateError(error.message);
-            }
-            if (!data) {
-                this.logger.error({ storageId: id }, 'Provider returned empty storage update response');
-                throw new StorageUpdateError('Incorrect response');
-            }
-            this.logger.info({ storageId: data.id }, 'Storage updated successfully');
-            return data;
-        }
-        catch (error) {
-            this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
-            const error_ = error instanceof StorageError
-                ? error
-                : new ProviderClientError('Request failed please try again later');
-            throw error_;
-        }
-    }
-    async upload(params, progressCb) {
-        const storage = await this.getCurrentStorage();
-        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');
-        }
-        catch (error) {
-            if (error instanceof Error && 'code' in error && error.code !== 'ENOENT') {
-                throw error;
-            }
-        }
-        let metadata = {};
-        if (params.metadataPath) {
-            metadata = await readJsonFile({
-                path: preparePath(params.metadataPath),
-            });
-        }
-        const { readCredentials, writeCredentials } = this.getStorageCredentials(storage, remotePath);
-        const info = await fs.stat(params.localPath);
-        let { localPath } = params;
-        let sourcePath;
-        if (info.isFile()) {
-            sourcePath = basename(localPath);
-            localPath = dirname(localPath);
-        }
-        try {
-            this.logger.info('Starting upload');
-            const uploadResult = await upload(localPath, {
-                credentials: writeCredentials,
-                filepath: '',
-                storageType: storage.storageType,
-                type: ResourceType.StorageProvider,
-            }, {
-                encryption: params.withEncryption,
-                progressCallback: progressCb,
-                retry: {
-                    initialDelayMs: 0,
-                    maxRetries: 2,
-                },
-                sourcePath,
-                sync: params.sync,
-                threads: params.maximumConcurrent,
-            });
-            uploadResult.resource.storageType = storage.storageType;
-            uploadResult.resource.credentials = readCredentials;
-            const result = {
-                ...metadata,
-                ...uploadResult,
-            };
-            await fs.writeFile(resourceFilePath, JSON.stringify(result, null, 2));
-            this.logger.info(`Resource file was created in ${resourceFilePath}`);
-        }
-        catch (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([
-    Retryable({
-        maxAttempts: 3,
-        value: [StoragesUndefinedError, StorageCreateError, ProviderClientError],
-    })
-], StorageService.prototype, "getCentralizedStorage", null);