@shoper/cli 0.5.2 → 0.6.0

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

@@ -6,7 +6,18 @@ import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_file
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { join, platformSeparator } from '../../../../../utils/path_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,6 +65,12 @@ 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 ThemeFilesStructureUtils.getThemeRootDirectories(themeDir);

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/service/theme_push_service.js

@@ -7,7 +7,7 @@ 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 { removeFile, 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 { ThemeArchive } from '../../../../class/archive/theme_archive.js';
@@ -16,63 +16,92 @@ import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
 import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemePushService {
     #themeFetchApi;
-    constructor({ themeFetchApi }) {
+    #loggerApi;
+    constructor({ themeFetchApi, loggerApi }) {
         this.#themeFetchApi = themeFetchApi;
+        this.#loggerApi = loggerApi;
     }
     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: pushAction,
                 filesStructure
             });
+            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) {
+                this.#loggerApi.info(`Uploading ${filesToUpload.length} theme files.`);
                 const { localFileNameToUploaded } = await this._uploadThemeFiles({
                     filesToUpload,
                     credentials,
                     themeRootDir,
                     themeFilesUploadApi
                 });
+                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`);
+            this.#loggerApi.info('Creating theme archive.');
             await new ThemeArchive(themeRootDir).createFullArchive({
                 dist: themeArchivePath,
                 actionValue: THEME_WILDCARD_ACTION_NAME,
-                actionType: THEME_ACTIONS_TYPES.push
+                actionType: THEME_ACTIONS_TYPES.push,
+                logger: this.#loggerApi
             });
+            this.#loggerApi.info('Theme archive created.');
             const { resources, modules } = await themeFilesUploadApi.uploadArchive({
                 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.');
             }
+            this.#loggerApi.debug('Updating theme checksums.');
             await themeChecksums.updateAllChecksums();
+            this.#loggerApi.info('Push completed successfully.');
         }
         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);
-            // if (rejectedImageData.length) await this._removeUploadedThemeFiles(rejectedImageData, themeRootDir);
+            }
             return {
                 localFileNameToUploaded: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
                     return {
@@ -86,15 +115,14 @@ export class ThemePushService {
             throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl, err);
         }
     }
-    async _removeUploadedThemeFiles(uploadedImageData, themeRootDir) {
-        await Promise.all(uploadedImageData.map(({ location, originalFilename }) => removeFile(join(themeRootDir, location, originalFilename))));
-    }
     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(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,5 +1,5 @@
 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 { ThemeFilesStructureUtils } from '../utils/files_structure/theme_files_structure_utils.js';
 export class ThemePushUtils {

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

@@ -1,10 +1,9 @@
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+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.',
-            level: 'error'
+            message: 'No files structure found for the theme.'
         });
     }
 }

package/build/theme/features/theme/utils/hidden_directory/hidden_directory_utils.js

@@ -5,9 +5,12 @@ import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_conts
 import { computeFileChecksum } from '../../../../../utils/checksums/checksums_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class HiddenDirectoryUtils {
-    static async ensureFilesInsideThemeMetaDataDirectoryUntouched(themeDirectory) {
+    static async ensureFilesInsideThemeMetaDataDirectoryUntouched(themeDirectory, logger) {
         const themeMetadataPath = this.getThemeHiddenDirectoryPath(themeDirectory);
-        const themeChecksums = new ThemeChecksums(themeDirectory);
+        const themeChecksums = new ThemeChecksums({
+            themeDir: themeDirectory,
+            loggerApi: logger
+        });
         if (!(await themeChecksums.verify()))
             throw new Error('Theme checksum file is not valid');
         const filesNames = (await getAllFilesNamesInside(themeMetadataPath)).filter((fileName) => fileName !== THEME_CURRENT_CHECKSUMS_FILE_NAME &&

package/build/theme/features/theme/utils/meta_data/theme_meta_data_error_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_WORK_URL_MISMATCH_ERROR } from './theme_meta_data_constants.js';
 export class ThemeMetaDataErrorFactory {
     static createThemeWorkUrlMismatchError(executionUrl, themeWorkUrl) {

package/build/theme/features/theme/utils/resources/theme_resources_with_id_directory_utils.js

@@ -5,7 +5,7 @@ import { fileExists, readJSONFile, renameFile } from '../../../../../utils/fs/fs
 import { join } from '../../../../../utils/path_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class ThemeResourcesWithIdDirectoryUtils {
-    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, remoteResourcesDir, remoteThemeDir) {
+    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, remoteResourcesDir, remoteThemeDir, loggerApi) {
         const localThemeTree = new FSTree({
             entries: walkSync.entries(localResourcesDir, {
                 globs: ['*/'],
@@ -37,7 +37,10 @@ export class ThemeResourcesWithIdDirectoryUtils {
             /**
              * If these become performance bottlenecks, we can consider computing checksums only for the changed directories.
              */
-            await new ThemeChecksums(remoteThemeDir).updateAllChecksums();
+            await new ThemeChecksums({
+                themeDir: remoteThemeDir,
+                loggerApi
+            }).updateAllChecksums();
         }
     }
     static async _getResourceIdToFilePathMap(entries) {

package/build/theme/features/theme/verify/theme_verify_initializer.js

@@ -1,12 +1,13 @@
-import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { ThemeVerifyApi } from './api/theme_verify_api.js';
 import { THEME_VERIFY_FEATURE_NAME } from './theme_verify_constants.js';
 import { ThemeVerifyService } from './verify/theme_verify_service.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeVerifyInitializer extends SyncFeatureInitializer {
     static featureName = THEME_VERIFY_FEATURE_NAME;
     init() {
-        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemeVerifyService();
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemeVerifyService({ loggerApi });
         return {
             cores: [
                 {

package/build/theme/features/theme/verify/verify/theme_verify_service.js

@@ -10,21 +10,33 @@ import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_file
 import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
 import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemeVerifyService {
+    #loggerApi;
+    constructor({ loggerApi }) {
+        this.#loggerApi = loggerApi;
+    }
     async verifyTheme({ verifyAction, executionContext, credentials, themeChecksums, filesStructure, themeFilesUploadApi }) {
+        this.#loggerApi.info('Verifying theme.');
         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: verifyAction,
                 filesStructure
             });
+            this.#loggerApi.debug('Filtering for modified or not created files to verify.');
             const filesToVerify = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenModified(path)) || !(await themeChecksums.hasThemeFileBeenCreated(path)));
+            this.#loggerApi.debug('Files to verify determined.', { details: { count: filesToVerify.length } });
             if (filesToVerify.length) {
+                this.#loggerApi.info(`Verifying ${filesToVerify.length} theme files.`);
                 const { rejectedImageData } = await themeFilesUploadApi.uploadFiles(filesToVerify);
+                this.#loggerApi.debug('Individual files verification finished.', {
+                    details: { rejectedCount: rejectedImageData.length }
+                });
                 if (rejectedImageData.length)
                     return {
                         isSuccess: false,
@@ -33,23 +45,29 @@ export class ThemeVerifyService {
             }
             await this._createFilesList(themeRootDir, filesToVerify);
             const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
+            this.#loggerApi.info('Creating theme archive for verification.');
             await new ThemeArchive(themeRootDir).createFullArchive({
                 dist: themeArchivePath,
                 actionValue: THEME_WILDCARD_ACTION_NAME,
-                actionType: THEME_ACTIONS_TYPES.push
+                actionType: THEME_ACTIONS_TYPES.push,
+                logger: this.#loggerApi
             });
+            this.#loggerApi.info('Theme archive created.');
             const { isSuccess, messages } = await themeFilesUploadApi.uploadArchive({
                 action: verifyAction,
                 themeArchivePath,
                 credentials
             });
+            this.#loggerApi.info('Theme archive verification finished.');
             return { isSuccess, messages };
         }
         finally {
+            this.#loggerApi.debug('Cleaning up files list.');
             await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
         }
     }
     async _createFilesList(themeRootDir, filesRecords) {
+        this.#loggerApi.debug('Creating filesList.json for the archive.');
         await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords));
     }
 }

package/build/theme/features/theme/watch/api/theme_watch_api.js

@@ -0,0 +1,11 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+export class ThemeWatchApi extends FeatureApi {
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    async watchTheme(props) {
+        return this.#service.watchTheme(props);
+    }
+}

package/build/theme/features/theme/watch/service/theme_watch_service.js

@@ -0,0 +1,48 @@
+// import chokidar from 'chokidar';
+import { relative } from '../../../../../utils/path_utils.js';
+export class ThemeWatchService {
+    #themePushApi;
+    constructor({ themePushApi }) {
+        this.#themePushApi = themePushApi;
+    }
+    async watchTheme({ themeChecksums, executionContext, onChange, credentials, themeFilesUploadApi, filesStructure, action }) {
+        const themePath = executionContext.themeRootDir;
+        console.log(`[watch] Watching for changes in: ${themePath}`);
+        // const watcher = chokidar.watch(themePath, {
+        //     ignored: /(^|[\/\\])\../, // ignore dotfiles
+        //     persistent: true,
+        //     ignoreInitial: true // Don't trigger on initial scan
+        // });
+        const handleFileChange = async (filePath) => {
+            const relativePath = relative(themePath, filePath);
+            console.log(`[watch] Detected change in: ${relativePath}. Pushing theme...`);
+            try {
+                // Assuming pushTheme handles the logic of pushing the entire theme
+                return;
+                //@ts-ignore
+                await this.#themePushApi.partialPush({
+                    credentials,
+                    filesStructure,
+                    action,
+                    executionContext,
+                    themeChecksums,
+                    themeFilesUploadApi
+                });
+                console.log(`[watch] Theme pushed successfully.`);
+            }
+            catch (error) {
+                console.error(`[watch] Error pushing theme:`, error);
+            }
+        };
+        //
+        // watcher
+        //     .on('add', handleFileChange)
+        //     .on('change', handleFileChange)
+        //     .on('unlink', handleFileChange)
+        //     //@ts-ignore
+        //     .on('error', (error) => console.error(`[watch] Watcher error: ${error}`))
+        //     .on('ready', () => console.log('[watch] Initial scan complete. Ready for changes.'));
+        // Keep the process alive while watching
+        return new Promise(() => { });
+    }
+}

package/build/theme/features/theme/watch/theme_watch_constants.js

@@ -0,0 +1,2 @@
+export const THEME_WATCH_FEATURE_NAME = 'ThemeWatch';
+export const THEME_WATCH_API_NAME = 'ThemeWatchApi';

package/build/theme/features/theme/watch/theme_watch_initializer.js

@@ -0,0 +1,20 @@
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { THEME_WATCH_FEATURE_NAME } from './theme_watch_constants.js';
+import { ThemeWatchService } from './service/theme_watch_service.js';
+import { THEME_PUSH_API_NAME } from '../push/theme_push_constants.js';
+import { ThemeWatchApi } from './api/theme_watch_api.js';
+export class ThemeWatchInitializer extends SyncFeatureInitializer {
+    static featureName = THEME_WATCH_FEATURE_NAME;
+    init() {
+        const themePushApi = this.getApiSync(THEME_PUSH_API_NAME);
+        const service = new ThemeWatchService({ themePushApi });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeWatchApi(service)
+                }
+            ]
+        };
+    }
+}

package/build/theme/features/themes/list/services/themes_list_service.js

@@ -4,20 +4,38 @@ import { HttpErrorsFactory } from '../../../../../cli/class/errors/http/http_err
 import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
 export class ThemesListService {
     #httpApi;
-    constructor(httpApi) {
+    #loggerApi;
+    constructor(httpApi, loggerApi) {
         this.#httpApi = httpApi;
+        this.#loggerApi = loggerApi;
     }
     async getThemes({ shopUrl }) {
+        this.#loggerApi.info('Fetching themes list.', {
+            details: {
+                shopUrl
+            }
+        });
         try {
             const { response: request } = this.#httpApi.getThemes(shopUrl);
             const response = await request;
-            if (response?.status !== STATUS_CODES.ok)
+            if (response?.status !== STATUS_CODES.ok) {
+                this.#loggerApi.debug('Failed to fetch themes list.', {
+                    details: {
+                        status: response?.status
+                    }
+                });
                 return;
-            //TODO baseHttpApi + model mapper
-            return response?.data.map(({ _links, ...rest }) => new ThemeMetaData({
+            }
+            const themes = response?.data.map(({ _links, ...rest }) => new ThemeMetaData({
                 ...rest,
                 links: _links
             }));
+            this.#loggerApi.info('Successfully fetched themes list.', {
+                details: {
+                    count: themes.length
+                }
+            });
+            return themes;
         }
         catch (err) {
             switch (err.response?.status) {
@@ -35,9 +53,22 @@ export class ThemesListService {
         }
     }
     async getTheme({ themeId, shopUrl }) {
+        this.#loggerApi.debug('Getting a specific theme from list.', {
+            details: {
+                themeId,
+                shopUrl
+            }
+        });
         const themes = await this.getThemes({ shopUrl });
         if (!themes)
             return;
-        return themes.find((theme) => String(theme.skinId) === themeId);
+        const theme = themes.find((theme) => String(theme.skinId) === themeId);
+        this.#loggerApi.debug(theme ? 'Theme found.' : 'Theme not found.', {
+            details: {
+                themeId,
+                found: !!theme
+            }
+        });
+        return theme;
     }
 }

package/build/theme/features/themes/list/themes_list_initializer.js

@@ -3,11 +3,13 @@ import { ThemesListApi } from './api/themes_list_api.js';
 import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { THEMES_LIST_FEATURE_NAME } from './themes_list_constants.js';
 import { ThemesListHttpApi } from './http/themes_list_http_api.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemesListInitializer extends SyncFeatureInitializer {
     static featureName = THEMES_LIST_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemesListService(new ThemesListHttpApi(httpApi));
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemesListService(new ThemesListHttpApi(httpApi), loggerApi);
         return {
             cores: [
                 {

package/build/theme/hooks/ensure_theme_meta_data_untouched_hook.js

@@ -1,13 +1,15 @@
-import { useApi } from '../../cli/hooks/ensure_cli_initialized_hook.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
 import { HiddenDirectoryUtils } from '../features/theme/utils/hidden_directory/hidden_directory_utils.js';
+import { LOGGER_API_NAME } from '../../cli/utilities/features/logger/logger_constants.js';
+import { useApi } from '../../utils/use_api.js';
 const ensureThemeMetaDataUntouched = async () => {
     const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
     const executionContext = await executionContextApi.getExecutionContext();
     if (executionContext.type !== EXECUTION_CONTEXTS.theme)
         return;
+    const loggerApi = useApi(LOGGER_API_NAME);
     try {
-        await HiddenDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir);
+        await HiddenDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir, loggerApi);
     }
     catch (err) {
         console.error(err);

package/build/theme/hooks/theme_checksums/ensure_theme_current_checksums_up_to_date_hook.js

@@ -1,7 +1,8 @@
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
-import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
 import { THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS } from './ensure_theme_current_checksums_up_to_date_constants.js';
 import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
+import { useApi } from '../../../utils/use_api.js';
 export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
     if (!THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS.includes(Command.id))
         return;
@@ -9,10 +10,14 @@ export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
     const executionContext = await executionContextApi.getExecutionContext();
     if (executionContext.type !== EXECUTION_CONTEXTS.theme)
         return;
+    const loggerApi = useApi(LOGGER_API_NAME);
     /**
      * Naive solution, recalculate checksums every time a command based on checksums calculation is executed;
      * If performance becomes an issue, we can implement a more sophisticated solution, eg. recalculate checksums only when files in the theme directory have changed.
      */
-    await new ThemeChecksums(executionContext.themeRootDir).updateCurrentChecksums();
+    await new ThemeChecksums({
+        themeDir: executionContext.themeRootDir,
+        loggerApi
+    }).updateCurrentChecksums();
 };
 export default ensureThemeChecksumsUpToDate;

package/build/theme/hooks/themes_actions/ensure_themes_actions_hook.js

@@ -1,10 +1,10 @@
-import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
 import { THEME_ACTIONS_API_NAME } from '../../features/theme/actions/theme_actions_constants.js';
 import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
 import { THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST } from './ensure_themes_actions_hook_constants.js';
 import { CLI_AUTH_TOKENS_API_NAME } from '../../../cli/auth/tokens/cli_auth_tokens_constants.js';
 import { promptForToken } from '../../../cli/commands/utils/prompt_for_token_utils.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+import { useApi } from '../../../utils/use_api.js';
 const ensureThemesActionsHook = async ({ Command, argv }) => {
     if (!THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST.includes(Command.id))
         return;
@@ -38,8 +38,7 @@ const ensureThemesActionsHook = async ({ Command, argv }) => {
             });
         }
         else {
-            console.error(err);
-            process.exit(1);
+            throw err;
         }
     }
 };

package/build/ui/gradient.js

@@ -0,0 +1,2 @@
+import InkGradient from 'ink-gradient';
+export const Gradient = InkGradient;