@super-protocol/sp-cli 0.0.2-alpha.1 → 0.0.2-beta.10

package/dist/services/storage.service.js

@@ -0,0 +1,308 @@
+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 { 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 { 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';
+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 && 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) {
+            localPath = join(localPath, resource.filepath);
+        }
+        await download(resource, localPath, {
+            encryption: resourceFile.encryption,
+            progressCallback: progressCb,
+            threads: params.maximumConcurrent,
+        });
+    }
+    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_;
+        }
+    }
+    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 {
+            const { data, error } = await this.providerClient.POST('/api/user-settings', {
+                body: {
+                    activeStorageId: selectedStorage,
+                },
+            });
+            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 || generateExternalId()}`;
+        const resourceFilePath = preparePath(params.outputPath || '');
+        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 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 info = await fs.stat(params.localPath);
+        let { localPath } = params;
+        let sourcePath;
+        if (info.isFile()) {
+            sourcePath = basename(localPath);
+            localPath = dirname(localPath);
+        }
+        try {
+            const uploadResult = await upload(localPath, {
+                credentials: writeCredentials,
+                filepath: '',
+                storageType: storage.storageType,
+                type: ResourceType.StorageProvider,
+            }, {
+                encryption: params.withEncryption,
+                progressCallback: progressCb,
+                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 }, 'Somethong went wrong with upload');
+            console.log(error);
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+}
+__decorate([
+    Retryable({ maxAttempts: 3, value: [StoragesUndefinedError, StorageCreateError, ProviderClientError] })
+], StorageService.prototype, "getCentralizedStorage", null);

package/dist/utils/helper.d.ts

@@ -1 +1,6 @@
 export declare const getConfigName: (name: string) => string;
+export declare const preparePath: (rawPath: string) => string;
+export type ReadJsonFileParams = {
+    path: string;
+};
+export declare const readJsonFile: <T>(params: ReadJsonFileParams) => Promise<T>;

package/dist/utils/helper.js

@@ -1 +1,23 @@
+import { existsSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
 export const getConfigName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-') + '.config.json';
+export const preparePath = (rawPath) => {
+    if (path.isAbsolute(rawPath))
+        return rawPath;
+    return path.join(process.cwd(), rawPath);
+};
+export const readJsonFile = async (params) => {
+    if (!existsSync(params.path)) {
+        throw new Error(`File could not be found in ${params.path}`);
+    }
+    const jsonString = await fs.readFile(params.path, 'utf8');
+    let parsedValue;
+    try {
+        parsedValue = JSON.parse(jsonString);
+    }
+    catch {
+        throw new Error(`Invalid JSON format of file ${params.path}`);
+    }
+    return parsedValue;
+};

package/dist/utils/progress.d.ts

@@ -0,0 +1,8 @@
+export declare const createProgressPrinter: ({ action, done, start, }: {
+    action: string;
+    done?: string;
+    start: string;
+}) => {
+    advance(key: string, num: number, message: string): void;
+    finish: () => void;
+};

package/dist/utils/progress.js

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