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

package/dist/services/auth.service.js

@@ -0,0 +1,93 @@
+export class AuthError extends Error {
+}
+export class AuthService {
+    accountManager;
+    configManager;
+    providerClient;
+    logger;
+    constructor(accountManager, configManager, providerClient, logger) {
+        this.accountManager = accountManager;
+        this.configManager = configManager;
+        this.providerClient = providerClient;
+        this.logger = logger;
+    }
+    async auth() {
+        const address = this.accountManager.getAddress();
+        const { error: nonceError, user } = await this.getUserNonce(address);
+        if (nonceError && nonceError.statusCode === 404) {
+            this.logger.debug('Nonce error call sign up');
+            const { data: nonceResponse, error: signUpError } = await this.providerClient.POST('/api/auth/sign-up', {
+                body: {
+                    address,
+                },
+            });
+            if (signUpError && signUpError.statusCode === 409) {
+                this.logger.debug({ signUpError }, 'Error signing up');
+                const { error: nonceError, user } = await this.getUserNonce(address);
+                this.logger.debug({ nonceError, user }, 'Requesting nonce again');
+                if (user && user.nonce) {
+                    await this.getTokens(user.nonce);
+                }
+                else {
+                    throw new AuthError('User exists but nonce is unavailable. Please try again or contact support.');
+                }
+            }
+            else if (signUpError) {
+                this.logger.error({ signUpError }, 'Sign-up failed');
+                throw new AuthError('Sign-up failed. Please try again later.');
+            }
+            else {
+                const nonce = nonceResponse?.nonce;
+                if (!nonce) {
+                    this.logger.error({ response: nonceResponse }, 'Unexpected sign-up response');
+                    throw new AuthError('Provider did not return a nonce.');
+                }
+                await this.getTokens(nonce);
+            }
+        }
+        else if (user && user.nonce) {
+            this.logger.debug({ user }, 'Requesting for existed user');
+            await this.getTokens(user.nonce);
+        }
+        else {
+            throw new AuthError('Unable to retrieve authentication nonce. Please try again later or contact support if the issue persists.');
+        }
+    }
+    async getTokens(nonce) {
+        const signature = await this.accountManager.createSign(nonce);
+        const { data: tokenResponse, error, } = await this.providerClient.POST('/api/auth/token', {
+            body: {
+                address: this.accountManager.getAddress(),
+                provider: 'sp-cli',
+                signature,
+            },
+        });
+        if (error) {
+            this.logger.error({ err: error }, 'Token exchange failed');
+            throw new AuthError(error.message);
+        }
+        const { accessToken } = tokenResponse || {};
+        if (!accessToken) {
+            this.logger.error({ response: tokenResponse }, 'Unexpected token response');
+            throw new AuthError('Provider returned an unexpected token response.');
+        }
+        await this.configManager.setCredentials({ accessKey: accessToken });
+    }
+    async getUserNonce(address) {
+        try {
+            const { data, error } = await this.providerClient.GET('/api/users/nonce/{address}', {
+                params: {
+                    path: {
+                        address,
+                    },
+                },
+            });
+            this.logger.debug({ data, error }, 'Getting user nonce');
+            return { error, user: data };
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Error request nonce');
+            throw new AuthError('Connection failure, please try again later');
+        }
+    }
+}

package/dist/services/storage.service.d.ts

@@ -0,0 +1,47 @@
+import { AddStorageDto, ProviderClient, StorageResponseDto, UpdateStorageDto } from '@super-protocol/provider-client';
+import pino from 'pino';
+export declare class StorageError extends Error {
+}
+export declare class StoragesEmptyError extends StorageError {
+}
+export declare class StorageCreateError extends StorageError {
+}
+export declare class StorageUpdateError extends StorageError {
+}
+export declare class StorageGetError extends StorageError {
+}
+export declare class StorageService {
+    private readonly providerClient;
+    private readonly logger;
+    constructor(providerClient: ProviderClient, logger: pino.BaseLogger);
+    createStorage(storage: AddStorageDto): Promise<StorageResponseDto>;
+    getCentralizedStorage(): Promise<{
+        bucket: string;
+        createdAt: string;
+        id: string;
+        isCentralized: boolean;
+        prefix: string;
+        s3Credentials?: import("@super-protocol/provider-client").components["schemas"]["S3CredentialsResponseDto"];
+        storageType: import("@super-protocol/provider-client").components["schemas"]["StorageType"];
+        storjCredentials?: import("@super-protocol/provider-client").components["schemas"]["StorJCredentialsResponseDto"];
+        updatedAt: string;
+        userId: string;
+    } | undefined>;
+    getCurrentStorage(): Promise<StorageResponseDto>;
+    hasStorage(): Promise<boolean>;
+    initStorage(): Promise<{
+        bucket: string;
+        createdAt: string;
+        id: string;
+        isCentralized: boolean;
+        prefix: string;
+        s3Credentials?: import("@super-protocol/provider-client").components["schemas"]["S3CredentialsResponseDto"];
+        storageType: import("@super-protocol/provider-client").components["schemas"]["StorageType"];
+        storjCredentials?: import("@super-protocol/provider-client").components["schemas"]["StorJCredentialsResponseDto"];
+        updatedAt: string;
+        userId: string;
+    }>;
+    requestStorages(): Promise<StorageResponseDto[]>;
+    saveStorage(selectedStorage: string): Promise<void>;
+    updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
+}

package/dist/services/storage.service.js

@@ -0,0 +1,179 @@
+import { ProviderClientError } from '../errors.js';
+export class StorageError extends Error {
+}
+export class StoragesEmptyError extends StorageError {
+}
+export class StorageCreateError extends StorageError {
+}
+export class StorageUpdateError extends StorageError {
+}
+export class StorageGetError extends StorageError {
+}
+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 getCentralizedStorage() {
+        const storages = await this.requestStorages();
+        return storages.find(storage => storage.isCentralized);
+    }
+    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) {
+                const storage = await this.getCentralizedStorage();
+                if (storage) {
+                    await this.saveStorage(storage.id);
+                    return true;
+                }
+                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 initStorage() {
+        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 || !data?.length) {
+                this.logger.warn('Storages list is empty');
+                throw new StoragesEmptyError('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');
+        }
+        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_;
+        }
+    }
+}