@shoper/cli 0.5.2 → 0.6.1

package/build/theme/commands/init/theme_init_command.js

@@ -15,6 +15,7 @@ import { Text } from '../../../ui/text.js';
 import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
 import { Box } from '../../../ui/box.js';
 import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeInitCommand extends BaseThemeCommand {
     static summary = 'Creates a copy of an existing theme by duplicating it.';
     static description = 'The new theme will be named after the source theme with a "Copy" suffix and an incremental number.\n\nYou must run this command from the root directory (not inside any theme folder) and provide the ID of the theme you want to duplicate.';
@@ -38,6 +39,7 @@ export class ThemeInitCommand extends BaseThemeCommand {
         const themeInitApi = this.getApi(THEME_INIT_API_NAME);
         const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         if (!credentials) {
             renderOnce(React.createElement(MissingCredentialsError, null));
@@ -64,12 +66,19 @@ export class ThemeInitCommand extends BaseThemeCommand {
                 return;
             }
             spinner = ora('Creating theme...').start();
-            const { themeId: createdThemeId, themeName } = await themeInitApi.initTheme({ action: copyAction, credentials });
+            const { themeId: createdThemeId, themeName } = await themeInitApi.initTheme({
+                action: copyAction,
+                credentials,
+                sourceThemeId: themeId
+            });
             spinner.stop();
             renderOnce(React.createElement(ThemeCreatedSuccess, { createdThemeId: createdThemeId, themeName: themeName }));
         }
         catch (err) {
             spinner?.stop();
+            loggerApi.error('Error during theme init command execution', {
+                error: err
+            });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
             //TODO analyze why on nodejs v22 this command does not exit properly, even all promises are resolved
             this.exit();

package/build/theme/commands/list/theme_list_command.js

@@ -4,22 +4,36 @@ import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
 import { renderOnce } from '../../../ui/ui_utils.js';
 import { Info } from '../../../ui/message_box/info.js';
 import React from 'react';
-import { Table } from '../../../ui/table/table.js';
+import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
+import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 import { ThemeListCommandUtils } from './theme_list_command_utils.js';
+import { Table } from '../../../ui/table/table.js';
 export class ThemeListCommand extends BaseThemeCommand {
     static summary = 'Displays a list of all themes available in your store, including their IDs, names, and statuses (active/inactive).';
     static description = 'Use this to check which theme is now active in your store.';
     async run() {
-        const ThemesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const themesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
         const credentials = cliAuthApi.getCredentials();
-        if (!credentials)
-            this.error('Credentials not found. Please authorize first.');
-        const themes = await ThemesListApi.getThemes(credentials);
-        if (!themes?.length) {
-            renderOnce(React.createElement(Info, { header: "No themes found for this store." }));
+        if (!credentials) {
+            renderOnce(React.createElement(MissingCredentialsError, null));
             return;
         }
-        renderOnce(React.createElement(Table, { data: ThemeListCommandUtils.mapThemeListToTableData(themes) }));
+        try {
+            const themes = await themesListApi.getThemes(credentials);
+            if (!themes?.length) {
+                renderOnce(React.createElement(Info, { header: "No themes found for this store." }));
+                return;
+            }
+            renderOnce(React.createElement(Table, { data: ThemeListCommandUtils.mapThemeListToTableData(themes) }));
+        }
+        catch (err) {
+            loggerApi.error('Error while listing themes:', {
+                error: err
+            });
+            renderOnce(React.createElement(ThemeError, { err: err }));
+        }
     }
 }

package/build/theme/commands/publish/theme_publish_command.js

@@ -10,6 +10,7 @@ import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
 import { THEME_SKINSTORE_API_NAME } from '../../features/theme/skinstore/theme_publish_constants.js';
 import { Form } from '../../../cli/features/controls/ui/form.js';
 import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemePublishCommand extends BaseThemeCommand {
     static summary = 'Permanently deletes the specified theme from your store.';
     static description = 'This action cannot be undone, so make sure you really want to remove this theme.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).';
@@ -31,6 +32,7 @@ export class ThemePublishCommand extends BaseThemeCommand {
     async run() {
         const themeId = this.args.id;
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         if (!credentials) {
@@ -69,8 +71,10 @@ export class ThemePublishCommand extends BaseThemeCommand {
             });
         }
         catch (err) {
+            loggerApi.error('Theme publish command error:', {
+                error: err
+            });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
-            return;
         }
     }
 }

package/build/theme/commands/pull/theme_pull_command.js

@@ -24,7 +24,8 @@ import { Info } from '../../../ui/message_box/info.js';
 import { directoryExists } from '../../../utils/fs/fs_utils.js';
 import { ThemeMetaDataUtils } from '../../features/theme/utils/meta_data/theme_meta_data_utils.js';
 import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
-import { ThemeError } from '../ui/theme_error.js'; //TODO jak jest error w pullu wowczas usuwamy docelowo pociagniety skin
+import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 //TODO jak jest error w pullu wowczas usuwamy docelowo pociagniety skin
 export class ThemePullCommand extends BaseThemeCommand {
     static summary = 'Downloads the current version of your theme from the store and overwrites your local theme files.';
@@ -60,6 +61,7 @@ export class ThemePullCommand extends BaseThemeCommand {
         const themeFetchApi = this.getApi(THEME_FETCH_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
         const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         if (!credentials) {
             renderOnce(React.createElement(MissingCredentialsError, null));
@@ -85,12 +87,19 @@ export class ThemePullCommand extends BaseThemeCommand {
                     themeActionsApi,
                     fetchType: this.flags.type,
                     executionContext,
-                    credentials
+                    credentials,
+                    loggerApi
                 });
             }
         }
         catch (err) {
             this.#spinner?.stop();
+            loggerApi.error('Error occurred during theme pull operation', {
+                error: err,
+                details: {
+                    executionContext
+                }
+            });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
     }
@@ -124,7 +133,7 @@ export class ThemePullCommand extends BaseThemeCommand {
         this.#spinner.stop();
         renderOnce(React.createElement(ThemePulledSuccess, null));
     }
-    async _pullThemeIntoExistingOne({ themeId, themeFetchApi, themeActionsApi, fetchType, executionContext, credentials }) {
+    async _pullThemeIntoExistingOne({ themeId, themeFetchApi, themeActionsApi, fetchType, executionContext, credentials, loggerApi }) {
         //TODO move these logi somvewhere else?
         await ThemeMetaDataUtils.ensureThemeWorkUrlMatch(executionContext.themeRootDir, credentials.shopUrl);
         const pullAction = themeActionsApi.getThemeAction({
@@ -155,10 +164,13 @@ export class ThemePullCommand extends BaseThemeCommand {
         const fetchedThemePath = join(tmpDir, name);
         const fetchedModulesPath = join(fetchedThemePath, 'modules');
         if ((await directoryExists(localModulesPath)) && (await directoryExists(fetchedModulesPath)))
-            await ThemeResourcesWithIdDirectoryUtils.updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localModulesPath, fetchedModulesPath, fetchedThemePath);
+            await ThemeResourcesWithIdDirectoryUtils.updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localModulesPath, fetchedModulesPath, fetchedThemePath, loggerApi);
         this.#spinner.stop();
         const changes = await themeMergeApi.getChangesBetweenThemes(fetchedThemePath, executionContext.themeRootDir);
-        const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
+        const themeChecksums = new ThemeChecksums({
+            themeDir: executionContext.themeRootDir,
+            loggerApi
+        });
         if (changes.length && (await themeChecksums.hasThemeBeenModified())) {
             renderOnce(React.createElement(ThemePullUnpublishedChangesWarning, { changes: changes }));
             const { proceed } = await promptConfirmation('Do you want to continue and overwrite local changes?');

package/build/theme/commands/push/theme_push_command.js

@@ -25,6 +25,7 @@ import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.
 import { THEME_FILES_STRUCTURE_FILE_NAME } from '../../features/theme/theme_constants.js';
 import { ThemeError } from '../ui/theme_error.js';
 import { ThemeUnpermittedActionsError } from './ui/theme_unpermitted_actions_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemePushCommand extends BaseThemeCommand {
     static summary = 'Uploads your local theme files to the store and overwrites the current version of the theme in your store.';
     static description = 'Check your local changes before pushing.\n\nYou must run this command from a specific theme directory (ID not needed).';
@@ -36,6 +37,7 @@ export class ThemePushCommand extends BaseThemeCommand {
     ];
     async run() {
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const themePushApi = this.getApi(THEME_PUSH_API_NAME);
         const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
@@ -51,7 +53,10 @@ export class ThemePushCommand extends BaseThemeCommand {
         }
         let spinner;
         try {
-            const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
+            const themeChecksums = new ThemeChecksums({
+                themeDir: executionContext.themeRootDir,
+                loggerApi
+            });
             await ThemeMetaDataUtils.ensureThemeWorkUrlMatch(executionContext.themeRootDir, credentials.shopUrl);
             const pushAction = themeActionsApi.getThemeAction({
                 actionType: THEME_ACTIONS_TYPES.push,
@@ -106,6 +111,7 @@ export class ThemePushCommand extends BaseThemeCommand {
         }
         catch (err) {
             spinner?.stop();
+            loggerApi.error('Error during theme push', { error: err });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
     }

package/build/theme/commands/theme_verify_command.js

@@ -18,12 +18,14 @@ import { MissingCredentialsError } from '../../cli/commands/auth/ui/missing_cred
 import { OutsideOfThemeDirectoryContextError } from './ui/ouside_of_theme_directory_context_error.js';
 import ora from 'ora';
 import { ThemeError } from './ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeVerifyCommand extends BaseThemeCommand {
     static description = 'Verify theme files structure';
     async run() {
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         if (!credentials) {
             renderOnce(React.createElement(MissingCredentialsError, null));
             return;
@@ -33,7 +35,10 @@ export class ThemeVerifyCommand extends BaseThemeCommand {
             renderOnce(React.createElement(OutsideOfThemeDirectoryContextError, null));
             return;
         }
-        const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
+        const themeChecksums = new ThemeChecksums({
+            themeDir: executionContext.themeRootDir,
+            loggerApi
+        });
         const permissions = await ThemeFilesStructureUtils.getFilesPermissions(executionContext.themeRootDir);
         if (!themeChecksums || !permissions)
             this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');

package/build/theme/commands/ui/theme_error.js

@@ -9,7 +9,7 @@ import React from 'react';
 import { ThemeWorkUrlMismatch } from './theme_work_url_mismatch.js';
 import { EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
 export const ThemeError = ({ err, executionContext }) => {
-    if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && executionContext.type === EXECUTION_CONTEXTS.theme) {
+    if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && executionContext?.type === EXECUTION_CONTEXTS.theme) {
         return (React.createElement(UnpermittedCommandError, { themeId: executionContext.themeId, commandName: "verify" }));
     }
     if (err?.code === THEME_ARCHIVE_UPLOAD_ERROR) {

package/build/theme/features/theme/actions/service/theme_actions_service.js

@@ -1,17 +1,26 @@
 import { STORE_THEMES_ACTIONS_TTL } from './theme_actions_service_constants.js';
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
 import { getNMinutesFromNow } from '../../../../../utils/date_utils.js';
 import { computeChecksum } from '../../../../../utils/checksums/checksums_utils.js';
 import { THEME_ACTION_NOT_FOUND_ERROR_CODE, THEME_ACTION_NOTS_FOUND_ERROR_CODE } from '../theme_actions_constants.js';
 export class ThemeActionsService {
     #themesListApi;
     #themesActionsStore;
-    constructor({ themesListApi, themesActionsStore }) {
+    #loggerApi;
+    constructor({ themesListApi, themesActionsStore, loggerApi }) {
         this.#themesListApi = themesListApi;
         this.#themesActionsStore = themesActionsStore;
+        this.#loggerApi = loggerApi;
     }
     getThemeAction({ actionType, themeId, credentials }) {
         const storeActions = this.#themesActionsStore.get(this._getKey(credentials.shopUrl));
+        this.#loggerApi.debug('Retrieving theme action', {
+            details: {
+                actionType,
+                themeId,
+                shopUrl: credentials.shopUrl
+            }
+        });
         if (!storeActions)
             throw new AppError({
                 code: THEME_ACTION_NOTS_FOUND_ERROR_CODE,
@@ -27,6 +36,12 @@ export class ThemeActionsService {
     }
     removeThemeActions({ themeId, credentials }) {
         const storeActions = this.#themesActionsStore.get(this._getKey(credentials.shopUrl));
+        this.#loggerApi.debug('Removing theme actions', {
+            details: {
+                themeId,
+                shopUrl: credentials.shopUrl
+            }
+        });
         if (!storeActions || !storeActions.actions[themeId]) {
             throw new AppError({
                 code: THEME_ACTION_NOTS_FOUND_ERROR_CODE,
@@ -40,10 +55,17 @@ export class ThemeActionsService {
         if (!themeId)
             return;
         const actionsData = this.#themesActionsStore.get(this._getKey(credentials.shopUrl));
+        this.#loggerApi.info('Ensuring theme actions are up to date', {
+            details: {
+                themeId,
+                shopUrl: credentials.shopUrl
+            }
+        });
         if (actionsData &&
             this._isValidThemesActions(actionsData) &&
             actionsData.actions[themeId] &&
             !this._hasThemesActionsExpired(this._getKey(credentials.shopUrl))) {
+            this.#loggerApi.debug('Theme actions are valid and not expired. Skipping fetch.');
             return Promise.resolve();
         }
         this._cleanExpiredActions();
@@ -52,6 +74,7 @@ export class ThemeActionsService {
             actions,
             expires: getNMinutesFromNow(STORE_THEMES_ACTIONS_TTL)
         });
+        this.#loggerApi.info('Fetched and stored new theme actions.');
     }
     _hasThemesActionsExpired(key) {
         const expires = this.#themesActionsStore.get(key)?.expires;
@@ -64,6 +87,11 @@ export class ThemeActionsService {
         return true;
     }
     async _fetchStoreThemesActions(credentials) {
+        this.#loggerApi.info('Fetching themes actions for store', {
+            details: {
+                shopUrl: credentials.shopUrl
+            }
+        });
         const themes = await this.#themesListApi.getThemes(credentials);
         if (!Array.isArray(themes))
             throw new AppError({
@@ -87,6 +115,11 @@ export class ThemeActionsService {
     }
     clearThemesActions({ credentials }) {
         const key = this._getKey(credentials.shopUrl);
+        this.#loggerApi.debug('Clearing themes actions for store', {
+            details: {
+                shopUrl: credentials.shopUrl
+            }
+        });
         this.#themesActionsStore.remove(key);
     }
     _getKey(shopUrl) {
@@ -94,14 +127,21 @@ export class ThemeActionsService {
     }
     _cleanExpiredActions() {
         const keys = this.#themesActionsStore.getKeys();
+        this.#loggerApi.debug('Cleaning expired actions');
         keys.forEach((key) => {
             const actionsData = this.#themesActionsStore.get(key);
             if (!actionsData || this._hasThemesActionsExpired(key)) {
+                this.#loggerApi.debug('Cleaning expired action', {
+                    details: {
+                        key
+                    }
+                });
                 this.#themesActionsStore.remove(key);
             }
         });
     }
     clearAllActions() {
+        this.#loggerApi.debug('Clearing all actions');
         this.#themesActionsStore.clear();
     }
 }

package/build/theme/features/theme/actions/theme_actions_initializer.js

@@ -5,10 +5,12 @@ import { CLI_DATA_DIRECTORY_API_NAME } from '../../../../cli/features/data_direc
 import { THEME_ACTIONS_FEATURE_NAME, THEMES_ACTIONS_FILE_NAME } from './theme_actions_constants.js';
 import { ThemeActionsApi } from './api/theme_actions_api.js';
 import { ThemeActionsService } from './service/theme_actions_service.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeActionsInitializer extends AsyncFeatureInitializer {
     static featureName = THEME_ACTIONS_FEATURE_NAME;
     async init() {
         const themesListApi = this.getApiSync(THEMES_LIST_API_NAME);
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
         const cliDataDirectoryApi = this.getApiSync(CLI_DATA_DIRECTORY_API_NAME);
         const themesActionsStore = new JsonCache({
             path: cliDataDirectoryApi.getDataDirectoryFullPath(),
@@ -19,7 +21,7 @@ export class ThemeActionsInitializer extends AsyncFeatureInitializer {
             cores: [
                 {
                     type: FEATURE_CORES_TYPES.api,
-                    instance: new ThemeActionsApi(new ThemeActionsService({ themesListApi, themesActionsStore }))
+                    instance: new ThemeActionsApi(new ThemeActionsService({ themesListApi, themesActionsStore, loggerApi }))
                 }
             ]
         };

package/build/theme/features/theme/delete/service/theme_delete_service.js

@@ -3,18 +3,29 @@ import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/do
 import { STATUS_CODES } from '@dreamcommerce/star_core';
 export class ThemeDeleteService {
     #httpApi;
-    constructor(httpApi) {
+    #logger;
+    constructor({ logger, httpApi }) {
         this.#httpApi = httpApi;
+        this.#logger = logger;
     }
     async deleteTheme({ actionData, credentials }) {
         try {
+            this.#logger.info('Deleting theme', {
+                details: {
+                    actionData
+                }
+            });
             const { response: request } = this.#httpApi.deleteTheme({ actionData, shopUrl: credentials.shopUrl });
             const response = await request;
             if (response?.status !== STATUS_CODES.ok)
                 return;
+            this.#logger.info('Successfully deleted theme');
             return response?.data;
         }
         catch (err) {
+            this.#logger.error('Error deleting theme', {
+                error: err
+            });
             //TODO to basic class
             switch (err.response?.status) {
                 case 403:

package/build/theme/features/theme/delete/theme_delete_initalizer.js

@@ -3,11 +3,16 @@ import { ThemeDeleteApi } from './api/theme_delete_api.js';
 import { ThemeDeleteService } from './service/theme_delete_service.js';
 import { ThemeDeleteHttpApi } from './http/theme_delete_http_api.js';
 import { THEME_DELETE_FEATURE_NAME } from './theme_delete_constants.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeDeleteInitializer extends SyncFeatureInitializer {
     static featureName = THEME_DELETE_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemeDeleteService(new ThemeDeleteHttpApi(httpApi));
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemeDeleteService({
+            httpApi: new ThemeDeleteHttpApi(httpApi),
+            logger: loggerApi
+        });
         return {
             cores: [
                 {

package/build/theme/features/theme/fetch/service/theme_fetch_service.js

@@ -7,61 +7,90 @@ import { getResources, mapResourcesToTree, removeOldResources } from '../../../.
 import { FetchResources } from '../../../../class/fetch_resources/fetch_resources.js';
 import { jsonIndentTransform } from '../../../../../utils/stream_transforms/json_indent_transform.js';
 import { JSON_FILE_INDENT } from '../../../../../cli/cli_constants.js';
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
 import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
 export class ThemeFetchService {
     #themeHttpApi;
     #httpApi;
-    constructor({ themeHttpApi, httpApi }) {
+    #loggerApi;
+    constructor({ themeHttpApi, httpApi, loggerApi }) {
         this.#themeHttpApi = themeHttpApi;
         this.#httpApi = httpApi;
+        this.#loggerApi = loggerApi;
     }
     async fetchTheme({ credentials, action, config }) {
         const { dist } = config;
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
         const fetchType = config?.fetchType ?? THEME_FETCH_TYPES.full;
+        this.#loggerApi.debug('Temporary directory created.', { details: { path: tmpDir } });
+        this.#loggerApi.info('Fetching theme', {
+            details: {
+                fetchType
+            }
+        });
         const { shopUrl } = credentials;
+        this.#loggerApi.info('Downloading theme archive.');
         //TODO think global mechanism to handle when user ctr+c during download
         const { basename, filename } = await downloadFile({
             dist: tmpDir,
+            logger: this.#loggerApi,
             request: this.#themeHttpApi.fetchTheme(shopUrl, action.data[fetchType]).response
         });
+        this.#loggerApi.info('Theme archive downloaded.');
         const themeDir = join(dist, basename);
+        this.#loggerApi.info('Extracting theme archive');
         await extractZip({
             source: join(tmpDir, filename),
             dist: themeDir,
+            logger: this.#loggerApi,
             getTransforms: (fileName) => (fileName.endsWith('.json') ? [jsonIndentTransform(JSON_FILE_INDENT)] : [])
         });
+        this.#loggerApi.info('Theme archive extracted');
         if (fetchType === THEME_FETCH_TYPES.full) {
+            this.#loggerApi.info('Fetching theme resources for full theme.');
             const resources = await getResources(themeDir);
             await this.fetchResources(shopUrl, themeDir, resources);
         }
         try {
+            this.#loggerApi.debug('Updating theme files structure.');
             await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
         }
-        catch (err) {
+        catch (error) {
             throw new AppError({
                 message: `Failed to update files structure in theme directory: ${themeDir}`,
                 code: 'theme_files_structure_update_error',
-                stack: err.stack
+                error
             });
         }
+        this.#loggerApi.debug('Creating .gitignore file.');
         await ThemeMetaDataUtils.createGitIgnoreFile(themeDir);
+        this.#loggerApi.debug('Updating metadata file.');
         await ThemeMetaDataUtils.updateMetadataFileWithWorkUrl(themeDir, credentials.shopUrl);
+        this.#loggerApi.debug('Updating theme checksums');
         /**
          * moze to nie powinno lezec tutaj :?
          */
-        await new ThemeChecksums(themeDir).updateAllChecksums();
+        await new ThemeChecksums({
+            themeDir,
+            loggerApi: this.#loggerApi
+        }).updateAllChecksums();
+        this.#loggerApi.info('Theme fetch completed successfully');
         return {
             name: basename
         };
     }
     async fetchResources(shopUrl, dist, resources) {
+        this.#loggerApi.debug('Removing old resources.');
         await removeOldResources(dist, resources);
+        this.#loggerApi.debug('Mapping resources to tree.');
         const resourcesTree = mapResourcesToTree(resources);
-        await Promise.all(Object.keys(resourcesTree).map((resource) => new FetchResources(this.#httpApi).fetchResources({
+        this.#loggerApi.debug('Fetching resources from remote.');
+        await Promise.all(Object.keys(resourcesTree).map((resource) => new FetchResources({
+            httpApi: this.#httpApi,
+            loggerApi: this.#loggerApi
+        }).fetchResources({
             resourcesPart: resourcesTree[resource],
             dist,
             parts: [resource],

package/build/theme/features/theme/fetch/theme_fetch_initializer.js

@@ -3,12 +3,15 @@ import { ThemeFetchApi } from './api/theme_fetch_api.js';
 import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { THEME_FETCH_FEATURE_NAME } from './theme_fetch_constants.js';
 import { ThemeFetchService } from './service/theme_fetch_service.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeFetchInitializer extends SyncFeatureInitializer {
     static featureName = THEME_FETCH_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
         const themeFetchService = new ThemeFetchService({
             themeHttpApi: new ThemeFetchHttpApi(httpApi),
+            loggerApi,
             httpApi
         });
         return {

package/build/theme/features/theme/init/service/theme_init_service.js

@@ -7,38 +7,64 @@ import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.
 import { ThemeInfoUtils } from '../../info/theme_info_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
 export class ThemeInitService {
     #httpApi;
-    constructor({ httpApi }) {
+    #loggerApi;
+    constructor({ httpApi, loggerApi }) {
         this.#httpApi = httpApi;
+        this.#loggerApi = loggerApi;
     }
-    async initTheme({ action, credentials }) {
+    async initTheme({ action, credentials, sourceThemeId }) {
+        this.#loggerApi.info('Initializing theme', {
+            details: {
+                sourceThemeId
+            }
+        });
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        this.#loggerApi.debug('Temporary directory created.', { details: { path: tmpDir } });
+        this.#loggerApi.info('Downloading theme archive.');
         //TODO think global mechanism to handle when user ctr+c during download
         const { basename, filename } = await downloadFile({
             dist: tmpDir,
-            request: this.#httpApi.initTheme(credentials.shopUrl, action.data).response
+            request: this.#httpApi.initTheme(credentials.shopUrl, action.data).response,
+            logger: this.#loggerApi
         });
+        this.#loggerApi.info('Theme archive downloaded.');
         const themeDir = join(process.cwd(), basename);
+        this.#loggerApi.info('Extracting theme archive.');
         await extractZip({
+            logger: this.#loggerApi,
             source: join(tmpDir, filename),
             dist: themeDir
         });
+        this.#loggerApi.info('Theme archive extracted.');
         try {
+            this.#loggerApi.debug('Updating theme files structure.');
             await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
         }
         catch (err) {
             throw new AppError({
                 message: `Failed to update files structure in theme directory: ${themeDir}`,
                 code: 'theme_files_structure_update_error',
-                stack: err.stack
+                error: err
             });
         }
+        this.#loggerApi.debug('Creating .gitignore file.');
         await ThemeMetaDataUtils.createGitIgnoreFile(themeDir);
+        this.#loggerApi.debug('Updating metadata file.');
         await ThemeMetaDataUtils.updateMetadataFileWithWorkUrl(themeDir, credentials.shopUrl);
-        await new ThemeChecksums(themeDir).updateAllChecksums();
+        this.#loggerApi.debug('Updating theme checksums.');
+        await new ThemeChecksums({
+            themeDir,
+            loggerApi: this.#loggerApi
+        }).updateAllChecksums();
         const themeMetaData = await ThemeMetaDataUtils.getThemeMetadata(themeDir);
+        this.#loggerApi.info('Theme initialized successfully.', {
+            details: {
+                sourceThemeId
+            }
+        });
         return {
             themeId: themeMetaData.themeId,
             themeName: await ThemeInfoUtils.getThemeName(themeDir)

package/build/theme/features/theme/init/theme_init_initializer.js

@@ -3,12 +3,15 @@ import { ThemeInitHttpApi } from './http/theme_init_http_api.js';
 import { ThemeInitApi } from './api/theme_init_api.js';
 import { ThemeInitService } from './service/theme_init_service.js';
 import { THEME_INIT_FEATURE_NAME } from './theme_init_constants.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeInitInitializer extends SyncFeatureInitializer {
     static featureName = THEME_INIT_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
         const service = new ThemeInitService({
-            httpApi: new ThemeInitHttpApi(httpApi)
+            httpApi: new ThemeInitHttpApi(httpApi),
+            loggerApi
         });
         return {
             cores: [