@shoper/cli 0.5.2-5 → 0.5.2-6

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';
-import { ThemeFilesUtils } from '../../utils/files/theme_files_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 {
-            await ThemeFilesUtils.updateFilesStructure(themeDir);
+            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

@@ -6,39 +6,65 @@ import { extractZip } from '../../../../../utils/zip/extract_zip_utils.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
 import { ThemeInfoUtils } from '../../info/theme_info_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
-import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.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 {
-            await ThemeFilesUtils.updateFilesStructure(themeDir);
+            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: [

package/build/theme/features/theme/merge/service/theme_merge_service.js

@@ -2,11 +2,22 @@ import FSTree from 'fs-tree-diff';
 import { copyFileSync, getAllDirectoriesNamesInside } from '../../../../../utils/fs/fs_utils.js';
 import walkSync from 'walk-sync';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { join, platformSeparator } from '../../../../../utils/path_utils.js';
-import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeMergeService {
+    #loggerApi;
+    constructor({ loggerApi }) {
+        this.#loggerApi = loggerApi;
+    }
     async applyChanges(fromTheme, toTheme, changes) {
+        this.#loggerApi.info('Applying changes between themes.', {
+            details: {
+                from: fromTheme,
+                to: toTheme,
+                changesCount: changes.length
+            }
+        });
         FSTree.applyPatch(fromTheme, toTheme, changes, {
             create(inputPath, outputPath) {
                 copyFileSync(inputPath, outputPath);
@@ -15,19 +26,36 @@ export class ThemeMergeService {
                 copyFileSync(inputPath, outputPath);
             }
         });
-        new ThemeChecksums(toTheme).updateAllChecksums();
+        this.#loggerApi.debug('Updating checksums after applying changes.');
+        await new ThemeChecksums({
+            themeDir: toTheme,
+            loggerApi: this.#loggerApi
+        }).updateAllChecksums();
     }
     async getChangesBetweenThemes(theme1, theme2) {
+        this.#loggerApi.info('Calculating changes between themes.', {
+            details: {
+                theme1,
+                theme2
+            }
+        });
         const theme1Tree = new FSTree({
             entries: walkSync.entries(theme1)
         });
         const theme2Tree = new FSTree({
             entries: walkSync.entries(theme2)
         });
-        const theme1Checksums = new ThemeChecksums(theme1);
-        const theme2Checksums = new ThemeChecksums(theme2);
+        const theme1Checksums = new ThemeChecksums({
+            themeDir: theme1,
+            loggerApi: this.#loggerApi
+        });
+        const theme2Checksums = new ThemeChecksums({
+            themeDir: theme2,
+            loggerApi: this.#loggerApi
+        });
+        this.#loggerApi.debug('Getting user-defined root directories to exclude from changes.');
         const userDirectories = await this._getUserRootDirectories(theme2);
-        return theme2Tree
+        const patch = theme2Tree
             .calculatePatch(theme1Tree, (entryA, entryB) => {
             if (entryA.isDirectory() && entryB.isDirectory())
                 return true;
@@ -37,9 +65,15 @@ export class ThemeMergeService {
             .filter(([_, name]) => {
             return !name.startsWith(SHOPER_THEME_METADATA_DIR) && !userDirectories.some((userDir) => name.startsWith(userDir));
         });
+        this.#loggerApi.debug('Calculated patch between themes.', {
+            details: {
+                patchSize: patch.length
+            }
+        });
+        return patch;
     }
     async _getUserRootDirectories(themeDir) {
-        const filesStructure = await ThemeFilesUtils.getThemeRootDirectories(themeDir);
+        const filesStructure = await ThemeFilesStructureUtils.getThemeRootDirectories(themeDir);
         return (await getAllDirectoriesNamesInside(themeDir, {
             recursive: false,
             hidden: true

package/build/theme/features/theme/merge/theme_merge_initializer.js

@@ -2,10 +2,12 @@ import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star
 import { ThemeMergeApi } from './api/theme_merge_api.js';
 import { ThemeMergeService } from './service/theme_merge_service.js';
 import { THEME_MERGE_FEATURE_NAME } from './theme_merge_constants.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeMergeInitializer extends SyncFeatureInitializer {
     static featureName = THEME_MERGE_FEATURE_NAME;
     init() {
-        const themeMergeService = new ThemeMergeService();
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const themeMergeService = new ThemeMergeService({ loggerApi });
         return {
             cores: [
                 {

package/build/theme/features/theme/push/api/theme_push_api.js

@@ -7,7 +7,7 @@ export class ThemePushApi extends FeatureApi {
         super();
         this.#service = service;
     }
-    async partialPush(props) {
-        return this.#service.partialPush(props);
+    async push(props) {
+        return this.#service.push(props);
     }
 }

package/build/theme/features/theme/push/service/theme_push_service.js

@@ -1,112 +1,109 @@
 import tmp from 'tmp-promise';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { dirname, join } from '../../../../../utils/path_utils.js';
+import { join } from '../../../../../utils/path_utils.js';
 import { v4 as uuid } from 'uuid';
 import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
-import { THEME_FILES_LIST_FILE_NAME, THEME_MODULE_SETTINGS_FILE_NAME } from '../theme_push_constants.js';
+import { THEME_MODULE_SETTINGS_FILE_NAME } from '../theme_push_constants.js';
 import { ThemePushErrorsFactory } from '../theme_push_errors_factory.js';
 import { ThemeImagesUtils } from '../../utils/theme_images_utils.js';
 import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
-import { fileExists, getAllDirectoriesNamesInside, readJSONFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
 import { MODULES_DIRECTORY_NAME } from '../../theme_constants.js';
 import { removeOldResources } from '../../../../class/fetch_resources/fetch_resources_utils.js';
-import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
+import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
-import { ThemeArchiveUtils } from '../../utils/archive/theme_archive_utils.js';
-import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
-import uniq from 'lodash/uniq.js';
-import { FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS } from '../../utils/files/them_files_constants.js';
+import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemePushService {
     #themeFetchApi;
-    constructor({ themeFetchApi }) {
+    #loggerApi;
+    constructor({ themeFetchApi, loggerApi }) {
         this.#themeFetchApi = themeFetchApi;
+        this.#loggerApi = loggerApi;
     }
-    async partialPush({ action, filesStructure, executionContext, themeChecksums, themeFilesUploadApi, credentials }) {
+    async push({ pushAction, credentials, filesStructure, executionContext, themeChecksums, themeFilesUploadApi }) {
+        this.#loggerApi.info('Pushing theme changes.');
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        this.#loggerApi.debug('Temporary directory created.', { details: { path: tmpDir } });
         const themeRootDir = executionContext.themeRootDir;
         if (await themeChecksums.hasThemeFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(themeRootDir)))
             throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
         try {
-            //TODO to do api?
+            this.#loggerApi.debug('Getting file records from action data.');
             const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
                 themeRootDir,
-                themeAction: action,
-                filesStructure,
-                themeChecksums
+                themeAction: pushAction,
+                filesStructure
             });
-            const filesToUpload = filesRecords.filter(({ state }) => [FILE_STATES.modified, FILE_STATES.created].includes(state));
-            let localFileNameToUploaded;
+            this.#loggerApi.debug('Filtering for created or modified files to upload.');
+            const filesToUpload = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenCreated(path)) || (await themeChecksums.hasThemeFileBeenModified(path)));
+            this.#loggerApi.debug('Files to upload determined.', { details: { count: filesToUpload.length } });
             if (filesToUpload.length) {
-                const uploadData = await this._uploadThemeFiles({
+                this.#loggerApi.info(`Uploading ${filesToUpload.length} theme files.`);
+                const { localFileNameToUploaded } = await this._uploadThemeFiles({
                     filesToUpload,
                     credentials,
                     themeRootDir,
                     themeFilesUploadApi
                 });
-                if (!uploadData.isSuccess)
-                    throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl);
-                localFileNameToUploaded = uploadData.localFileNameToUploadedMap;
+                this.#loggerApi.info('Theme files uploaded.');
+                await this._createFilesList(themeRootDir, filesRecords, localFileNameToUploaded);
+            }
+            else {
+                this.#loggerApi.info('No new or modified files to upload. Creating files list for archive.');
+                await this._createFilesList(themeRootDir, filesRecords);
             }
             const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
-            const filesInArchive = await ThemeActionsUtils.getFilesThatMatchesAction({
+            this.#loggerApi.info('Creating theme archive.');
+            await new ThemeArchive(themeRootDir).createFullArchive({
+                dist: themeArchivePath,
                 actionValue: THEME_WILDCARD_ACTION_NAME,
                 actionType: THEME_ACTIONS_TYPES.push,
-                filesStructure,
-                rootDir: themeRootDir
-            });
-            const groupedFiles = await themeChecksums.groupFilesByStatus(filesInArchive);
-            const deletedFiles = await ThemeActionsUtils.getDeletedFilesThatMatchesAction({
-                actionType: THEME_ACTIONS_TYPES.push,
-                actionValue: THEME_WILDCARD_ACTION_NAME,
-                themeChecksums,
-                filesStructure,
-                rootDir: themeRootDir
+                logger: this.#loggerApi
             });
-            await this._createFilesList({
-                themeRootDir,
-                filesRecords,
-                localFileNameToUploaded,
-                deletedFiles,
-                allCustomModulesIds: await this._getAllModulesIds(themeRootDir)
-            });
-            await ThemeArchiveUtils.create({
-                dist: themeArchivePath,
-                rootDir: themeRootDir,
-                files: [
-                    ...(await this._appendSettingsIfModifiedFileFromFolderThatContainsOne(groupedFiles.modified)),
-                    ...groupedFiles.created,
-                    (await fileExists(ThemeFilesUtils.getFilesListFilePath(themeRootDir))) ? THEME_FILES_LIST_FILE_NAME : undefined
-                ].filter(Boolean)
-            });
-            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
+            this.#loggerApi.info('Theme archive created.');
             const { resources, modules } = await themeFilesUploadApi.uploadArchive({
-                action,
+                action: pushAction,
                 themeArchivePath,
                 credentials
             });
-            if (modules)
+            this.#loggerApi.info('Theme archive uploaded.');
+            if (modules) {
+                this.#loggerApi.debug('Updating data for new modules.');
                 await this._updateDataForNewCreatedModules({ modules, themeRootDir });
+            }
             if (resources) {
+                this.#loggerApi.debug('Removing old resources.');
                 await removeOldResources(themeRootDir, resources);
+                this.#loggerApi.info('Fetching new resources.');
                 await this.#themeFetchApi.fetchResources(credentials.shopUrl, themeRootDir, resources);
+                this.#loggerApi.info('New resources fetched.');
             }
-            //TODO only changed files checksum
+            this.#loggerApi.debug('Updating theme checksums.');
             await themeChecksums.updateAllChecksums();
+            this.#loggerApi.info('Push completed successfully.');
         }
-        catch (err) {
-            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
-            throw err;
+        finally {
+            this.#loggerApi.debug('Cleaning up files list.');
+            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
         }
     }
     async _uploadThemeFiles({ filesToUpload, themeRootDir, credentials, themeFilesUploadApi }) {
         try {
+            this.#loggerApi.debug('Uploading individual files.');
             const { uploadedImageData, rejectedImageData } = await themeFilesUploadApi.uploadFiles(filesToUpload);
-            if (uploadedImageData.length)
+            this.#loggerApi.debug('Individual files upload finished.', {
+                details: {
+                    uploadedCount: uploadedImageData.length,
+                    rejectedCount: rejectedImageData.length
+                }
+            });
+            if (uploadedImageData.length) {
+                this.#loggerApi.debug('Removing original files for uploaded images.');
                 await ThemeImagesUtils.removeUploadedOriginalFiles(themeRootDir, uploadedImageData);
+            }
             return {
-                isSuccess: rejectedImageData.length === 0,
-                rejectedImageData,
-                localFileNameToUploadedMap: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
+                localFileNameToUploaded: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
                     return {
                         ...acc,
                         [originalFilename]: uploadedFilename ?? originalFilename
@@ -120,40 +117,12 @@ export class ThemePushService {
     }
     async _updateDataForNewCreatedModules({ modules, themeRootDir }) {
         for (const [moduleDirectoryName, metaData] of Object.entries(modules)) {
+            this.#loggerApi.debug('Updating settings for new module.', { details: { module: moduleDirectoryName } });
             await writeJSONFile(join(themeRootDir, MODULES_DIRECTORY_NAME, moduleDirectoryName, THEME_MODULE_SETTINGS_FILE_NAME), JSON.parse(metaData[THEME_MODULE_SETTINGS_FILE_NAME]));
         }
     }
-    async _createFilesList({ deletedFiles, localFileNameToUploaded, filesRecords, themeRootDir, allCustomModulesIds }) {
-        const filesListContent = ThemeFilesUtils.mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded);
-        if (deletedFiles?.length)
-            filesListContent.removed = deletedFiles;
-        if (allCustomModulesIds?.length)
-            filesListContent[FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS] = allCustomModulesIds;
-        await ThemeFilesUtils.createAFilesListFile(themeRootDir, filesListContent);
-    }
-    async _appendSettingsIfModifiedFileFromFolderThatContainsOne(modifiedFiles) {
-        const withSettingsFiles = [...modifiedFiles];
-        for (const filePath of modifiedFiles) {
-            if (await fileExists(join(dirname(filePath), 'settings.json'))) {
-                withSettingsFiles.push(join(dirname(filePath), 'settings.json'));
-            }
-        }
-        return uniq(withSettingsFiles);
-    }
-    async _getAllModulesIds(themeRootDir) {
-        const modulesPath = join(themeRootDir, MODULES_DIRECTORY_NAME);
-        if (!(await fileExists(modulesPath)))
-            return [];
-        const moduleDirs = await getAllDirectoriesNamesInside(modulesPath);
-        const modulesIds = [];
-        for (const moduleDir of moduleDirs) {
-            const moduleSettingsPath = join(themeRootDir, MODULES_DIRECTORY_NAME, moduleDir, THEME_MODULE_SETTINGS_FILE_NAME);
-            if (await fileExists(moduleSettingsPath)) {
-                const settingsContent = await readJSONFile(moduleSettingsPath);
-                if (settingsContent.id && Number.isInteger(settingsContent.id))
-                    modulesIds.push(settingsContent.id);
-            }
-        }
-        return modulesIds;
+    async _createFilesList(themeRootDir, filesRecords, localFileNameToUploaded = {}) {
+        this.#loggerApi.debug('Creating filesList.json for the archive.');
+        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded));
     }
 }

package/build/theme/features/theme/push/theme_push_errors_factory.js

@@ -1,4 +1,4 @@
-import { AppError } from '../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../../cli/utilities/features/logger/logs/app_error.js';
 import { THEME_ARCHIVE_UPLOAD_ERROR, THEME_FILES_UPLOAD_ERROR } from './theme_push_constants.js';
 export class ThemePushErrorsFactory {
     static createErrorWhileUploadingThemeFiles(shopUrl, messages) {
@@ -16,7 +16,7 @@ export class ThemePushErrorsFactory {
             code: 'theme.push.error_creating_theme_archive',
             message: `Error while creating theme archive for shop "${shopUrl}"`,
             level: 'error',
-            stack: error.stack
+            error
         });
     }
     static createErrorWhilePushingUnpublishedThemeWithSkinstoreData(shopUrl) {

package/build/theme/features/theme/push/theme_push_initializer.js

@@ -3,11 +3,13 @@ import { ThemePushService } from './service/theme_push_service.js';
 import { THEME_PUSH_FEATURE_NAME } from './theme_push_constants.js';
 import { ThemePushApi } from './api/theme_push_api.js';
 import { THEME_FETCH_API_NAME } from '../fetch/theme_fetch_constants.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemePushInitializer extends SyncFeatureInitializer {
     static featureName = THEME_PUSH_FEATURE_NAME;
     init() {
         const service = new ThemePushService({
-            themeFetchApi: this.getApiSync(THEME_FETCH_API_NAME)
+            themeFetchApi: this.getApiSync(THEME_FETCH_API_NAME),
+            loggerApi: this.getApiSync(LOGGER_API_NAME)
         });
         return {
             cores: [

package/build/theme/features/theme/push/theme_push_utils.js

@@ -1,10 +1,10 @@
 import globs from 'fast-glob';
-import { AppError } from '../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../../cli/utilities/features/logger/logs/app_error.js';
 import { toUnixPath } from '../../../../utils/path_utils.js';
-import { ThemeFilesUtils } from '../utils/files/theme_files_utils.js';
+import { ThemeFilesStructureUtils } from '../utils/files_structure/theme_files_structure_utils.js';
 export class ThemePushUtils {
     static async getAllFilesThatAreSendToRemote(themeDir) {
-        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
+        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
         if (!filesStructure)
             throw new AppError({
                 message: `Files structure not found in theme directory: ${themeDir}`,

package/build/theme/features/theme/utils/files_structure/theme_file_structure_errors_factory.js

@@ -0,0 +1,9 @@
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
+export class ThemeFileStructureErrorsFactory {
+    static createNoFilesStructureError() {
+        return new AppError({
+            code: 'theme.file_structure.no_files_structure',
+            message: 'No files structure found for the theme.'
+        });
+    }
+}