@shoper/cli 0.1.0-7 → 0.1.0-8

package/build/cli/auth/api/cli_auth_api.js

@@ -1,3 +1,16 @@
-export class CliAuthApi {
-    getCredentials() { }
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { CLI_AUTH_API_NAME } from '../cli_auth_constants.js';
+export class CliAuthApi extends FeatureApi {
+    moduleName = CLI_AUTH_API_NAME;
+    #cliAuthService;
+    constructor(cliAuthService) {
+        super();
+        this.#cliAuthService = cliAuthService;
+    }
+    getCredentials() {
+        return this.#cliAuthService.getCredentials();
+    }
+    hasCredentialsExpired() {
+        return this.#cliAuthService.hasCredentialsExpired();
+    }
 }

package/build/cli/auth/cli_auth_constants.js

@@ -0,0 +1,6 @@
+export const CLI_AUTH_SCOPES = {
+    theme: 'theme',
+    app: 'app'
+};
+export const CLI_AUTH_FEATURE_NAME = 'CliAuth';
+export const CLI_AUTH_API_NAME = 'CliAuthApi';

package/build/cli/auth/cli_auth_errors_factory.js

@@ -0,0 +1,10 @@
+import { AppError } from '../class/errors/app_error/app_error.js';
+export class CliAuthErrorsFactory {
+    static createCredentialNotFoundError() {
+        return new AppError({
+            code: 'cli_auth.credential_not_found',
+            message: 'Credential not found',
+            level: 'error'
+        });
+    }
+}

package/build/cli/auth/cli_auth_initializer.js

@@ -0,0 +1,19 @@
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { CliAuthService } from './service/cli_auth_service.js';
+import { CliAuthApi } from './api/cli_auth_api.js';
+import { CLI_AUTH_TOKENS_API_NAME } from './tokens/cli_auth_tokens_constants.js';
+import { CLI_AUTH_FEATURE_NAME } from './cli_auth_constants.js';
+export class CliAuthInitializer extends SyncFeatureInitializer {
+    static featureName = CLI_AUTH_FEATURE_NAME;
+    init() {
+        const cliAuthTokensApi = this.getApiSync(CLI_AUTH_TOKENS_API_NAME);
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new CliAuthApi(new CliAuthService(cliAuthTokensApi))
+                }
+            ]
+        };
+    }
+}

package/build/cli/auth/cli_auth_utils.js

@@ -0,0 +1,22 @@
+import { CLI_AUTH_SCOPES } from './cli_auth_constants.js';
+export class CliAuthUtils {
+    static checkCredentials(credentialsApi, command) {
+        const credentials = credentialsApi.getCredentials();
+        if (!credentials)
+            return false;
+        if (credentialsApi.hasCredentialsExpired()) {
+            console.log('Credentials are expired, please reauthorize');
+            return false;
+        }
+        return CliAuthUtils.ensureScopeAccessRights(credentials.scopes, command.id);
+    }
+    // We assume for now that scopes names are same as topics names
+    static ensureScopeAccessRights(tokenScopes, commandId) {
+        if (!CliAuthUtils.isScopedCommand(Object.values(CLI_AUTH_SCOPES), commandId))
+            return true;
+        return CliAuthUtils.isScopedCommand(tokenScopes, commandId);
+    }
+    static isScopedCommand(scopes, commandId) {
+        return scopes.some((scope) => commandId.includes(scope));
+    }
+}

package/build/cli/auth/model/cli_credentials.js

@@ -0,0 +1,10 @@
+export class CliCredentials {
+    shopUrl;
+    scopes;
+    expires;
+    constructor({ shopUrl, scopes, expires }) {
+        this.expires = expires;
+        this.shopUrl = shopUrl;
+        this.scopes = scopes;
+    }
+}

package/build/cli/auth/service/cli_auth_service.js

@@ -0,0 +1,34 @@
+import { CliCredentials } from '../model/cli_credentials.js';
+import { CliAuthErrorsFactory } from '../cli_auth_errors_factory.js';
+export class CliAuthService {
+    #cliAuthTokensApi;
+    #credentials = null;
+    constructor(cliAuthTokensApi) {
+        this.#cliAuthTokensApi = cliAuthTokensApi;
+        this._setCredentials();
+    }
+    _setCredentials() {
+        const defaultTokenPayload = this.#cliAuthTokensApi.getDefaultTokenPayload();
+        if (!defaultTokenPayload)
+            return;
+        this.#credentials = new CliCredentials({
+            shopUrl: defaultTokenPayload.iss,
+            scopes: defaultTokenPayload.scope.split(';'),
+            expires: defaultTokenPayload.exp
+        });
+    }
+    getCredentials() {
+        if (this.#credentials)
+            return this.#credentials;
+        this._setCredentials();
+        return this.#credentials;
+    }
+    hasCredentialsExpired() {
+        if (!this.#credentials)
+            throw CliAuthErrorsFactory.createCredentialNotFoundError();
+        const defaultTokenIndex = this.#cliAuthTokensApi.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return true;
+        return this.#cliAuthTokensApi.hasTokenExpired(defaultTokenIndex);
+    }
+}

package/build/cli/auth/tokens/api/cli_auth_tokens_api.js

@@ -1 +1,43 @@
-export {};
+import { CLI_AUTH_TOKENS_API_NAME } from '../cli_auth_tokens_constants.js';
+import { FeatureApi } from '@dreamcommerce/star_core';
+export class CliAuthTokensApi extends FeatureApi {
+    moduleName = CLI_AUTH_TOKENS_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    addToken(token) {
+        this.#service.addToken(token);
+    }
+    removeToken(index) {
+        this.#service.removeToken(index);
+    }
+    setDefaultToken(index) {
+        this.#service.setDefaultToken(index);
+    }
+    getTokenPayload(index) {
+        return this.#service.getTokenPayload(index);
+    }
+    hasToken(index) {
+        return this.#service.hasToken(index);
+    }
+    getAllTokensPayloads() {
+        return this.#service.getAllTokensPayloads();
+    }
+    getDefaultTokenIndex() {
+        return this.#service.getDefaultTokenIndex();
+    }
+    getDefaultToken() {
+        return this.#service.getDefaultToken();
+    }
+    getDefaultTokenPayload() {
+        return this.#service.getDefaultTokenPayload();
+    }
+    hasTokenExpired(index) {
+        return this.#service.hasTokenExpired(index);
+    }
+    getTokensCount() {
+        return this.#service.getTokensCount();
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_constants.js

@@ -0,0 +1,6 @@
+export const CLI_AUTH_TOKENS_API_NAME = 'CliAuthTokensApi';
+export const CLI_AUTH_TOKENS_FEATURE_NAME = 'CliAuthTokens';
+export const CLI_AUTH_TOKENS_TYPES = {
+    jwt: 'jwt'
+};
+export const CLI_AUTH_TOKENS_FILE_NAME = 'credentials';

package/build/cli/auth/tokens/cli_auth_tokens_errors_factory.js

@@ -0,0 +1,10 @@
+import { AppError } from '../../class/errors/app_error/app_error.js';
+export class CliAuthTokensErrorsFactory {
+    static createTokenNotFoundError(index) {
+        return new AppError({
+            code: 'cli_auth_tokens.token_not_found',
+            message: `Token with index "${index}" not found`,
+            level: 'error'
+        });
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_initalizer.js

@@ -1 +1,35 @@
-export {};
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { CliAuthTokensApi } from './api/cli_auth_tokens_api.js';
+import { CLiAuthTokensService } from './service/cli_auth_tokens_service.js';
+import { CLI_AUTH_TOKENS_FEATURE_NAME, CLI_AUTH_TOKENS_FILE_NAME } from './cli_auth_tokens_constants.js';
+import { CLI_DATA_DIRECTORY_API_NAME } from '../../features/data_directory/cli_data_directory_constants.js';
+import { JsonCache } from '../../features/caches/json_cache/json_cache.js';
+// schema
+// {
+//     default: string;
+//     tokens: {
+//          [key: string]: {
+//              type: string;
+//              token: string;
+//              expires: string;
+//         }
+//     }
+export class CliAuthTokensInitializer extends SyncFeatureInitializer {
+    static featureName = CLI_AUTH_TOKENS_FEATURE_NAME;
+    init() {
+        const cliDataDirectoryApi = this.getApiSync(CLI_DATA_DIRECTORY_API_NAME);
+        const tokensStore = new JsonCache({
+            path: cliDataDirectoryApi.getDataDirectoryFullPath(),
+            configFileMode: 0o600,
+            name: CLI_AUTH_TOKENS_FILE_NAME
+        });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new CliAuthTokensApi(new CLiAuthTokensService(tokensStore))
+                }
+            ]
+        };
+    }
+}

package/build/cli/auth/tokens/cli_auth_tokens_utils.js

@@ -0,0 +1,26 @@
+import jwt from 'jsonwebtoken';
+export class CLiAuthTokensUtils {
+    static getTokenPayload(token) {
+        try {
+            return jwt.decode(token);
+        }
+        catch (err) {
+            console.error('Error decoding token:', err);
+            throw new Error('Invalid token');
+        }
+    }
+    static getTokenName(token) {
+        const payload = this.getTokenPayload(token);
+        const tokenName = payload?.name;
+        if (!tokenName) {
+            throw new Error('Token name not found in payload');
+        }
+        return tokenName;
+    }
+    static hasTokenExpired(token) {
+        const tokenPayload = CLiAuthTokensUtils.getTokenPayload(token);
+        if (!tokenPayload)
+            return true;
+        return tokenPayload.exp - Math.floor(Date.now() / 1000) < 0;
+    }
+}

package/build/cli/auth/tokens/service/cli_auth_tokens_service.js

@@ -1,6 +1,86 @@
+import { CLI_AUTH_TOKENS_TYPES } from '../cli_auth_tokens_constants.js';
+import { CLiAuthTokensUtils } from '../cli_auth_tokens_utils.js';
+import { CLI_AUTH_DEFAULT_TOKEN_NAME, CLI_AUTH_TOKENS_KEY } from './cli_auth_tokens_service_constants.js';
+import { CliAuthTokensErrorsFactory } from '../cli_auth_tokens_errors_factory.js';
 export class CLiAuthTokensService {
-    addToken() { }
-    removeToken() { }
-    switchToken() { }
-    listTokens() { }
+    #tokensStore;
+    constructor(tokensStore) {
+        this.#tokensStore = tokensStore;
+    }
+    addToken(token) {
+        const tokeItem = {
+            token,
+            type: CLI_AUTH_TOKENS_TYPES.jwt
+        };
+        const tokens = this._getTokenItems() ?? [];
+        tokens.push(tokeItem);
+        this._setTokens(tokens);
+    }
+    hasToken(index) {
+        return index <= this.getTokensCount();
+    }
+    removeToken(index) {
+        if (!this.hasToken(index))
+            return;
+        const tokens = this._getTokenItems();
+        const newTokens = tokens.filter((_, currIndex) => currIndex !== index - 1);
+        this._setTokens(newTokens);
+    }
+    getDefaultTokenPayload() {
+        const defaultTokenIndex = this.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return null;
+        return this.getTokenPayload(defaultTokenIndex);
+    }
+    getDefaultTokenIndex() {
+        return this.#tokensStore.get(CLI_AUTH_DEFAULT_TOKEN_NAME);
+    }
+    getTokenPayload(index) {
+        const tokenItem = this._getTokenItem(index - 1);
+        if (!tokenItem)
+            return null;
+        return CLiAuthTokensUtils.getTokenPayload(tokenItem.token);
+    }
+    hasTokenExpired(index) {
+        const tokenItem = this._getTokenItem(index - 1);
+        if (!tokenItem)
+            return true;
+        return CLiAuthTokensUtils.hasTokenExpired(tokenItem.token);
+    }
+    /**
+     * Index starts from 1
+     */
+    setDefaultToken(index) {
+        const tokens = this._getTokenItems();
+        if (tokens.length < index)
+            throw CliAuthTokensErrorsFactory.createTokenNotFoundError(index);
+        this.#tokensStore.set(CLI_AUTH_DEFAULT_TOKEN_NAME, index);
+    }
+    _getTokenItems() {
+        return this.#tokensStore.get(CLI_AUTH_TOKENS_KEY) ?? [];
+    }
+    _getTokenItem(index) {
+        const tokens = this._getTokenItems();
+        return tokens[index] ?? null;
+    }
+    _setTokens(tokens) {
+        this.#tokensStore.set(CLI_AUTH_TOKENS_KEY, tokens);
+    }
+    getTokensCount() {
+        const tokens = this._getTokenItems();
+        return tokens.length;
+    }
+    getDefaultToken() {
+        const defaultTokenIndex = this.getDefaultTokenIndex();
+        if (!defaultTokenIndex)
+            return null;
+        const tokenItem = this._getTokenItem(defaultTokenIndex - 1);
+        if (!tokenItem)
+            return null;
+        return tokenItem.token;
+    }
+    getAllTokensPayloads() {
+        const tokens = this._getTokenItems();
+        return tokens.map((tokenItem) => CLiAuthTokensUtils.getTokenPayload(tokenItem.token));
+    }
 }

package/build/cli/auth/tokens/service/cli_auth_tokens_service_constants.js

@@ -0,0 +1,2 @@
+export const CLI_AUTH_DEFAULT_TOKEN_NAME = 'default';
+export const CLI_AUTH_TOKENS_KEY = 'tokens';

package/build/cli/class/base_cli_command.js

@@ -0,0 +1,3 @@
+import { BaseCommand } from './base_command.js';
+export class BaseCliCommand extends BaseCommand {
+}

package/build/cli/class/errors/app_error/app_error.js

@@ -0,0 +1,17 @@
+import { APP_ERRORS_LEVELS } from './app_error_constants.js';
+//TODO errory do zaprojektownia
+export class AppError extends Error {
+    code;
+    level;
+    tags;
+    details;
+    stack;
+    constructor({ code, details, message, level = APP_ERRORS_LEVELS.error, tags, stack }) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.level = level;
+        this.tags = tags;
+        this.stack = stack;
+    }
+}

package/build/cli/class/errors/app_error/app_error_constants.js

@@ -0,0 +1,7 @@
+export const APP_ERRORS_LEVELS = {
+    fatal: 'fatal',
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+    debug: 'debug'
+};

package/build/cli/class/errors/file_system_errors_factory.js

@@ -0,0 +1,26 @@
+import { AppError } from './app_error/app_error.js';
+export class FileSystemErrorsFactory {
+    static createDiskFullError() {
+        return new AppError({
+            code: 'file_system.disk_full',
+            message: 'Disk is full',
+            level: 'error'
+        });
+    }
+    static createErrorMovingFile(source, destination, err) {
+        return new AppError({
+            code: 'file_system.error_moving_file',
+            message: `Failed to move file from ${source} to ${destination}`,
+            level: 'error',
+            stack: err.stack
+        });
+    }
+    static createErrorCopyingFile(source, destination, err) {
+        return new AppError({
+            code: 'file_system.error_copying_file',
+            message: `Failed to copy file from ${source} to ${destination}`,
+            level: 'error',
+            stack: err.stack
+        });
+    }
+}

package/build/cli/class/errors/http_errors_factory.js

@@ -0,0 +1,21 @@
+import { AppError } from './app_error/app_error.js';
+export class HttpErrorsFactory {
+    static createUnauthorizedError() {
+        return new AppError({
+            message: 'Unauthorized',
+            code: 'unauthorized'
+        });
+    }
+    static createForbiddenError() {
+        return new AppError({
+            message: 'Forbidden',
+            code: 'forbidden'
+        });
+    }
+    static createNotFoundError() {
+        return new AppError({
+            message: 'Not found',
+            code: 'not_found'
+        });
+    }
+}

package/build/cli/cli_constants.js

@@ -1 +1,2 @@
 export const CLI_NAME = '@shoper/cli';
+export const JSON_FILE_INDENT = 4;

package/build/cli/commands/auth/cli_auth_add_token_command.js

@@ -0,0 +1,32 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+import inquirer from 'inquirer';
+export class CliAuthAddTokenCommand extends BaseCliCommand {
+    static description = 'Add token';
+    //TODO
+    static examples = [
+        {
+            description: 'Add token.',
+            command: '<%= config.bin %> <%= command.id %>'
+        }
+    ];
+    async run() {
+        const cliAuthTokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const { token } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'token',
+                message: 'Enter token:'
+            }
+        ]);
+        try {
+            cliAuthTokensApi.addToken(token);
+            cliAuthTokensApi.setDefaultToken(cliAuthTokensApi.getTokensCount());
+            console.log('Token added successfully');
+        }
+        catch (err) {
+            //TODO handle error
+            this.error(`${err}`);
+        }
+    }
+}

package/build/cli/commands/auth/cli_auth_list_tokens_command.js

@@ -0,0 +1,17 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+export class CliAuthListTokensCommand extends BaseCliCommand {
+    static description = 'List all added tokens';
+    static examples = [`$ cli token:list`];
+    async run() {
+        const tokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const tokensPayloads = tokensApi.getAllTokensPayloads();
+        if (!tokensPayloads.length) {
+            this.log('No tokens found');
+            return;
+        }
+        tokensPayloads.forEach((tokenPayload) => {
+            this.log(`Token name: ${tokenPayload.name}, storeUrl: ${tokenPayload.iss}`);
+        });
+    }
+}

package/build/cli/commands/auth/cli_auth_remove_token_command.js

@@ -0,0 +1,37 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { Args } from '@oclif/core';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+export class CliAuthRemoveTokenCommand extends BaseCliCommand {
+    static summary = 'Remove the access token';
+    static description = 'Remove the access token with the provided index.';
+    static examples = [
+        {
+            description: 'Remove token with index 2',
+            command: '<%= config.bin %> <%= command.id %> 2'
+        }
+    ];
+    static args = {
+        index: Args.integer({
+            description: 'Index of the token to remove',
+            required: true
+        })
+    };
+    async run() {
+        const cliAuthTokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const data = await this.parse(CliAuthRemoveTokenCommand);
+        const { args } = data;
+        const { index } = args;
+        if (!cliAuthTokensApi.hasToken(index)) {
+            this.log(`Token with index "${index}" does not exist.`);
+            return;
+        }
+        try {
+            cliAuthTokensApi.removeToken(index);
+            cliAuthTokensApi.setDefaultToken(cliAuthTokensApi.getTokensCount());
+            this.log(`Access token ${index} removed successfully.`);
+        }
+        catch {
+            this.error('Failed to remove the access token. Please try again later.');
+        }
+    }
+}

package/build/cli/commands/auth/cli_auth_switch_token_command.js

@@ -0,0 +1,36 @@
+import { BaseCliCommand } from '../../class/base_cli_command.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
+import { Args } from '@oclif/core';
+export class CliAuthSwitchTokenCommand extends BaseCliCommand {
+    static description = 'Set token with provided index as default';
+    //TODO
+    static examples = [
+        {
+            description: 'Set token 2 as default.',
+            command: '<%= config.bin %> <%= command.id %> 2'
+        }
+    ];
+    static args = {
+        index: Args.integer({
+            description: 'Index of the token to set as default',
+            required: true
+        })
+    };
+    async run() {
+        const cliAuthTokensApi = this.getApi(CLI_AUTH_TOKENS_API_NAME);
+        const { args } = await this.parse(CliAuthSwitchTokenCommand);
+        const { index } = args;
+        if (!cliAuthTokensApi.hasToken(index)) {
+            this.log(`Token with index "${index}" does not exist.`);
+            return;
+        }
+        try {
+            cliAuthTokensApi.setDefaultToken(index);
+        }
+        catch (err) {
+            //TODO
+            this.log(`Error: ${err}`);
+            return;
+        }
+    }
+}

package/build/cli/commands/cli_update_command.js

@@ -1,7 +1,7 @@
-import { BaseCommand } from '../class/base_command.js';
 import { CLI_VERSION_API_NAME } from '../features/version/cli_version_constants.js';
 import { CLI_NAME } from '../cli_constants.js';
-export class CliUpdateCommand extends BaseCommand {
+import { BaseCliCommand } from '../class/base_cli_command.js';
+export class CliUpdateCommand extends BaseCliCommand {
     static summary = 'Update the Shoper CLI';
     static description = 'Update the Shoper CLI to the latest version.';
     static examples = [`$ shoper update`];
@@ -14,7 +14,11 @@ export class CliUpdateCommand extends BaseCommand {
             const stdout = await cliVersionApi.update();
             this.log(stdout);
         }
-        catch {
+        catch (error) {
+            //npm code for EACCES
+            if (error?.code === 243) {
+                this.error(error);
+            }
             this.error('Failed to update the CLI. Please try again later.');
         }
     }

package/build/cli/commands/commands_constants.js

@@ -1,5 +1,9 @@
 export const CLI_COMMANDS_NAMES = {
     help: 'help',
     version: 'version',
-    update: 'update'
+    update: 'update',
+    authListTokens: 'auth:list-tokens',
+    authAddToken: 'auth:add-token',
+    authRemoveToken: 'auth:remove-token',
+    switchToken: 'auth:switch-token'
 };