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

package/dist/commands/storage/update.js

@@ -0,0 +1,239 @@
+import { confirm, input, password, select, } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { StorageType } from '@super-protocol/provider-client';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { StoragesEmptyError } from '../../services/storage.service.js';
+import { BaseStorageCommand } from './base.js';
+export default class StorageUpdate extends BaseStorageCommand {
+    static description = 'Update the configuration of an existing storage.';
+    static examples = [
+        '<%= config.bin %> storage update --id=2de3e3a4-0000-1111-2222-333344445555 --fromFile ./storage-update.json',
+        '<%= config.bin %> storage update --id=2de3e3a4-0000-1111-2222-333344445555',
+    ];
+    static flags = {
+        fromFile: Flags.string({
+            char: 'f',
+            description: 'Path to a JSON file that contains UpdateStorageDto payload.',
+        }),
+        id: Flags.string({
+            char: 'i',
+            description: 'Storage ID to update',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StorageUpdate);
+        try {
+            const shouldRequestStorages = !flags.fromFile || !flags.id;
+            const storages = shouldRequestStorages ? await this.storageService.requestStorage() : undefined;
+            let storageId = flags.id;
+            if (!storageId) {
+                const choices = (storages || []).filter(cp => !cp.isCentralized).map(storage => ({
+                    name: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
+                    value: storage.id,
+                }));
+                if (!choices || choices.length === 0) {
+                    throw new StoragesEmptyError('No storages available to update');
+                }
+                storageId = await select({
+                    choices,
+                    message: 'Select storage to update',
+                });
+            }
+            if (!storageId) {
+                this.error('Storage ID is required');
+            }
+            const storageToUpdate = storages?.find(storage => storage.id === storageId);
+            const updatePayload = flags.fromFile
+                ? await this.loadStorageFromFile(flags.fromFile)
+                : await this.promptStorageUpdate(storageToUpdate);
+            await this.storageService.updateStorage(storageId, updatePayload);
+            this.log(`Storage updated: ${storageId}`);
+        }
+        catch (error) {
+            if (error instanceof StoragesEmptyError) {
+                this.error('No storages available. Run "sp storage create" first.');
+            }
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    ensureNonEmptyString(value, fieldName) {
+        if (typeof value !== 'string' || !value.trim()) {
+            this.error(`${fieldName} must be a non-empty string`);
+        }
+        return value.trim();
+    }
+    ensureUpdatePayload(payload) {
+        if (!payload || typeof payload !== 'object') {
+            this.error('Storage update definition must be an object');
+        }
+        const updateFields = ['bucket', 'prefix', 'storageType', 's3Credentials', 'storjCredentials'];
+        const hasUpdates = updateFields.some(key => payload[key] !== undefined);
+        if (!hasUpdates) {
+            this.error('Update payload must include at least one property');
+        }
+        if (payload.storageType && !Object.values(StorageType).includes(payload.storageType)) {
+            this.error(`Unsupported storage type: ${payload.storageType}`);
+        }
+        if (payload.s3Credentials) {
+            const { readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId, writeSecretAccessKey, } = payload.s3Credentials;
+            if (!readAccessKeyId || !readSecretAccessKey || !region || !writeAccessKeyId || !writeSecretAccessKey) {
+                this.error('S3 credentials must include readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId and writeSecretAccessKey');
+            }
+        }
+        if (payload.storjCredentials) {
+            const { readAccessToken, writeAccessToken } = payload.storjCredentials;
+            if (!readAccessToken || !writeAccessToken) {
+                this.error('StorJ credentials must include readAccessToken and writeAccessToken');
+            }
+        }
+        const sanitized = {};
+        if (payload.bucket !== undefined) {
+            sanitized.bucket = this.ensureNonEmptyString(payload.bucket, 'Bucket');
+        }
+        if (payload.prefix !== undefined) {
+            sanitized.prefix = this.ensureNonEmptyString(payload.prefix, 'Prefix');
+        }
+        if (payload.storageType) {
+            sanitized.storageType = payload.storageType;
+        }
+        if (payload.s3Credentials) {
+            sanitized.s3Credentials = {
+                readAccessKeyId: this.ensureNonEmptyString(payload.s3Credentials.readAccessKeyId, 'S3 credential "readAccessKeyId"'),
+                readSecretAccessKey: this.ensureNonEmptyString(payload.s3Credentials.readSecretAccessKey, 'S3 credential "readSecretAccessKey"'),
+                region: this.ensureNonEmptyString(payload.s3Credentials.region, 'S3 credential "region"'),
+                writeAccessKeyId: this.ensureNonEmptyString(payload.s3Credentials.writeAccessKeyId, 'S3 credential "writeAccessKeyId"'),
+                writeSecretAccessKey: this.ensureNonEmptyString(payload.s3Credentials.writeSecretAccessKey, 'S3 credential "writeSecretAccessKey"'),
+            };
+        }
+        if (payload.storjCredentials) {
+            sanitized.storjCredentials = {
+                readAccessToken: this.ensureNonEmptyString(payload.storjCredentials.readAccessToken, 'StorJ credential "readAccessToken"'),
+                writeAccessToken: this.ensureNonEmptyString(payload.storjCredentials.writeAccessToken, 'StorJ credential "writeAccessToken"'),
+            };
+        }
+        return sanitized;
+    }
+    async loadStorageFromFile(filePath) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(this.currentDir, filePath);
+        try {
+            const fileContent = await fs.readFile(absolutePath, 'utf8');
+            const parsed = JSON.parse(fileContent);
+            return this.ensureUpdatePayload(parsed);
+        }
+        catch (error) {
+            this.error(`Failed to load storage update definition: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async promptS3Credentials() {
+        const region = await input({
+            message: 'AWS region',
+            validate(value) {
+                return value ? true : 'Region is required';
+            },
+        }).then(value => value.trim());
+        const readAccessKeyId = await input({
+            message: 'Read access key ID',
+            validate(value) {
+                return value ? true : 'Read access key ID is required';
+            },
+        }).then(value => value.trim());
+        const readSecretAccessKey = await password({
+            message: 'Read secret access key',
+            validate(value) {
+                return value ? true : 'Read secret access key is required';
+            },
+        }).then(value => value.trim());
+        const writeAccessKeyId = await input({
+            message: 'Write access key ID',
+            validate(value) {
+                return value ? true : 'Write access key ID is required';
+            },
+        }).then(value => value.trim());
+        const writeSecretAccessKey = await password({
+            message: 'Write secret access key',
+            validate(value) {
+                return value ? true : 'Write secret access key is required';
+            },
+        }).then(value => value.trim());
+        return {
+            readAccessKeyId,
+            readSecretAccessKey,
+            region,
+            writeAccessKeyId,
+            writeSecretAccessKey,
+        };
+    }
+    async promptStorageUpdate(existingStorage) {
+        const payload = {};
+        const bucket = await input({
+            default: existingStorage?.bucket ?? '',
+            message: 'Bucket name (leave empty to keep current)',
+        }).then(value => value.trim());
+        if (bucket) {
+            payload.bucket = bucket;
+        }
+        const prefix = await input({
+            default: existingStorage?.prefix ?? '',
+            message: 'Prefix (leave empty to keep current)',
+        }).then(value => value.trim());
+        if (prefix) {
+            payload.prefix = prefix;
+        }
+        let newStorageType;
+        const shouldChangeType = await confirm({
+            default: false,
+            message: existingStorage
+                ? `Change storage type? (current: ${existingStorage.storageType})`
+                : 'Change storage type?',
+        });
+        if (shouldChangeType) {
+            newStorageType = await select({
+                choices: [
+                    { name: 'Amazon S3', value: StorageType.S3 },
+                    { name: 'StorJ', value: StorageType.StorJ },
+                ],
+                message: 'Select new storage type',
+            });
+            payload.storageType = newStorageType;
+        }
+        const effectiveType = newStorageType ?? existingStorage?.storageType;
+        const credentialsRequired = Boolean(newStorageType);
+        if (effectiveType) {
+            const updateCredentials = credentialsRequired || await confirm({
+                default: false,
+                message: `Update ${effectiveType} credentials?`,
+            });
+            if (updateCredentials) {
+                if (effectiveType === StorageType.S3) {
+                    payload.s3Credentials = await this.promptS3Credentials();
+                }
+                else {
+                    payload.storjCredentials = await this.promptStorJCredentials();
+                }
+            }
+        }
+        if (Object.keys(payload).length === 0) {
+            this.error('No changes provided');
+        }
+        return this.ensureUpdatePayload(payload);
+    }
+    async promptStorJCredentials() {
+        const readAccessToken = await password({
+            message: 'Read access token',
+            validate(value) {
+                return value ? true : 'Read access token is required';
+            },
+        }).then(value => value.trim());
+        const writeAccessToken = await password({
+            message: 'Write access token',
+            validate(value) {
+                return value ? true : 'Write access token is required';
+            },
+        }).then(value => value.trim());
+        return {
+            readAccessToken,
+            writeAccessToken,
+        };
+    }
+}

package/dist/config/config.schema.d.ts

@@ -17,6 +17,7 @@ export declare const cliConfigSchema: import("@sinclair/typebox").TObject<{
     cookies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
     name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     providerUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    selectedStorage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;

package/dist/config/config.schema.js

@@ -21,4 +21,5 @@ export const cliConfigSchema = Type.Object({
     cookies: Type.Optional(Type.Unknown()),
     name: Type.Optional(Type.String()),
     providerUrl: Type.Optional(Type.String({ format: 'url' })),
+    selectedStorage: Type.Optional(Type.String({ maxLength: 36, minLength: 36 })),
 });

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const FILE_ACCESS_PERMS = 384;
 export declare const DIR_ACCESS_PERMS = 448;
 export declare const PROVIDER_URL = "https://api.dp.superprotocol.com";
+export declare const REFRESH_TOKEN_URI = "/api/auth/refresh-access";

package/dist/constants.js

@@ -3,3 +3,4 @@ export const FILE_ACCESS_PERMS = 0o600;
 //  Directory permissions.     'drwx------'
 export const DIR_ACCESS_PERMS = 0o700;
 export const PROVIDER_URL = 'https://api.dp.superprotocol.com';
+export const REFRESH_TOKEN_URI = '/api/auth/refresh-access';

package/dist/errors.d.ts

@@ -6,3 +6,5 @@ export declare class InvalidPrivateKeyError extends Error {
 }
 export declare class AuthorizationRequiredError extends Error {
 }
+export declare class ProviderClientError extends Error {
+}

package/dist/errors.js

@@ -6,3 +6,5 @@ export class InvalidPrivateKeyError extends Error {
 }
 export class AuthorizationRequiredError extends Error {
 }
+export class ProviderClientError extends Error {
+}

package/dist/lib/container.d.ts

@@ -29,9 +29,10 @@ export declare class AppContainer {
     initAccountManager(): this;
     initConfigFileManager(): this;
     initConfigManager(): this;
-    initProviderClient({ enableAuth, enableCookies }?: {
+    initProviderClient({ enableAuth, enableCookies, rebuild }?: {
         enableAuth?: boolean;
         enableCookies?: boolean;
+        rebuild?: boolean;
     }): this;
     setupRuntimeConfig(config: RuntimeConfig): this;
     private queueInit;

package/dist/lib/container.js

@@ -104,10 +104,10 @@ export class AppContainer {
             this._configManager = configManager;
         });
     }
-    initProviderClient({ enableAuth = true, enableCookies = true } = {}) {
+    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false } = {}) {
         this.initConfigManager();
         return this.queueInit('providerClient', async () => {
-            if (this._providerClient) {
+            if (this._providerClient && !rebuild) {
                 return;
             }
             await this.waitFor('configManager');
@@ -143,7 +143,7 @@ export class AppContainer {
                 providerClient.use(authMiddleware);
             }
             this._providerClient = providerClient;
-        });
+        }, rebuild);
     }
     setupRuntimeConfig(config) {
         if (this.initQueue.size > 0) {
@@ -160,8 +160,8 @@ export class AppContainer {
         }
         return this;
     }
-    queueInit(name, task) {
-        if (!this.initQueue.has(name)) {
+    queueInit(name, task, force = false) {
+        if (!this.initQueue.has(name) || force) {
             const promise = task();
             this.initQueue.set(name, promise);
             this.initPromises.push(promise);

package/dist/middlewares/auth-middleware.js

@@ -1,4 +1,5 @@
 import { decode } from 'jsonwebtoken';
+import { REFRESH_TOKEN_URI } from '../constants.js';
 import { AuthorizationRequiredError } from '../errors.js';
 function isAccessKeyExpired(accessKey) {
     try {
@@ -23,7 +24,7 @@ export async function createAuthMiddleware(configManager, providerClient, logger
         logger.info('Performed refresh token');
         let refreshResult;
         try {
-            refreshResult = await providerClient.POST('/api/auth/refresh-access');
+            refreshResult = await providerClient.POST(REFRESH_TOKEN_URI);
         }
         catch (error) {
             logger.error({ err: error }, 'failure refresh token');
@@ -76,6 +77,9 @@ export async function createAuthMiddleware(configManager, providerClient, logger
     }
     const middleware = {
         async onRequest({ request }) {
+            if (request.url.endsWith(REFRESH_TOKEN_URI)) {
+                return request;
+            }
             const accessToken = await ensureAccessKey();
             if (accessToken) {
                 request.headers.set('Authorization', `Bearer ${accessToken}`);

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

@@ -0,0 +1,34 @@
+import { AddStorageDto, ProviderClient, StorageResponseDto, UpdateStorageDto } from '@super-protocol/provider-client';
+import pino from 'pino';
+import { IConfigManager } from '../interfaces/config-manager.interface.js';
+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 StorageService {
+    private readonly configManager;
+    private readonly providerClient;
+    private readonly logger;
+    constructor(configManager: IConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
+    createStorage(storage: AddStorageDto): 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;
+    }>;
+    requestStorage(): Promise<StorageResponseDto[]>;
+    saveStorage(selectedStorage: string): Promise<void>;
+    updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
+}

package/dist/services/storage.service.js

@@ -0,0 +1,113 @@
+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 StorageService {
+    configManager;
+    providerClient;
+    logger;
+    constructor(configManager, providerClient, logger) {
+        this.configManager = configManager;
+        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 hasStorage() {
+        return Boolean(await this.configManager.get('selectedStorage'));
+    }
+    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);
+            }
+            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 requestStorage() {
+        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');
+        await this.configManager.set('selectedStorage', selectedStorage);
+    }
+    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_;
+        }
+    }
+}