@shoper/cli 0.1.0-9 → 0.2.1-0

package/build/theme/features/theme/skinstore/http/theme_skinstore_http_api.js

@@ -0,0 +1,17 @@
+export class ThemeSkinstoreHttpApi {
+    #httpApi;
+    constructor(httpApi) {
+        this.#httpApi = httpApi;
+    }
+    getPublishFormData({ actionData, shopUrl }) {
+        const { method, url } = actionData;
+        return this.#httpApi.fetch({
+            url: `${shopUrl}${url}`,
+            method,
+            sanitizeOptions: {
+                disable: true
+            },
+            isPrivate: true
+        });
+    }
+}

package/build/theme/features/theme/skinstore/service/theme_skinstore_service.js

@@ -0,0 +1,32 @@
+import { STATUS_CODES } from '@dreamcommerce/star_core';
+import { HttpErrorsFactory } from '../../../../../cli/class/errors/http/http_errors_factory.js';
+import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
+import { toControls } from '../../../../../cli/features/controls/controls_dto_mappers.js';
+export class ThemeSkinstoreService {
+    #httpApi;
+    constructor(httpApi) {
+        this.#httpApi = httpApi;
+    }
+    async getPublishFormData({ credentials, actionData }) {
+        try {
+            const { response: request } = this.#httpApi.getPublishFormData({ actionData, shopUrl: credentials.shopUrl });
+            const response = await request;
+            if (response?.status !== STATUS_CODES.ok)
+                throw response;
+            return response?.data ? toControls(response.data) : [];
+        }
+        catch (err) {
+            //TODO to basic class
+            switch (err.response?.status) {
+                case 403:
+                    throw HttpErrorsFactory.createForbiddenError();
+                case 401:
+                    throw HttpErrorsFactory.createUnauthorizedError();
+                case 404:
+                    throw HttpErrorsFactory.createNotFoundError();
+                default:
+                    throw DownloadFileErrorsFactory.downloadError(err.response.status);
+            }
+        }
+    }
+}

package/build/theme/features/theme/skinstore/theme_publish_constants.js

@@ -0,0 +1,4 @@
+export const THEME_SKINSTORE_LOCATION = 'skinstore';
+export const THEME_SKINSTORE_SETTINGS_FILE_NAME = 'settings.json';
+export const THEME_SKINSTORE_API_NAME = 'ThemeSkinstoreApi';
+export const THEME_SKINSTORE_FEATURE_NAME = 'ThemeSkinstore';

package/build/theme/features/theme/skinstore/theme_skinstore_initialzier.js

@@ -0,0 +1,20 @@
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { THEME_SKINSTORE_FEATURE_NAME } from './theme_publish_constants.js';
+import { ThemeSkinstoreService } from './service/theme_skinstore_service.js';
+import { ThemeSkinstoreHttpApi } from './http/theme_skinstore_http_api.js';
+import { ThemeSkinstoreApi } from './api/theme_skinstore_api.js';
+export class ThemeSkinstoreInitializer extends SyncFeatureInitializer {
+    static featureName = THEME_SKINSTORE_FEATURE_NAME;
+    init() {
+        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const service = new ThemeSkinstoreService(new ThemeSkinstoreHttpApi(httpApi));
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeSkinstoreApi(service)
+                }
+            ]
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppError } from '../../../../../cli/class/errors/app/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'
+        });
+    }
+}

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

@@ -0,0 +1,76 @@
+import { readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { join, looksLikeDirectory, mapKeysPathsToWindowPlatform, toUnixPath } from '../../../../../utils/path_utils.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
+import { THEME_FILES_STRUCTURE_FILE_NAME } from '../../theme_constants.js';
+import { isWindowsOs } from '../../../../../utils/platform_utils.js';
+import { validateDirectory } from '../../../../utils/directory_validator/directory_validator_utils.js';
+import path from 'node:path';
+import { THEME_FILES_LIST_FILE_NAME } from '../../push/theme_push_constants.js';
+export class ThemeFilesStructureUtils {
+    static async getThemeFilesStructure(themeDirectory) {
+        const filesStructure = await readJSONFile(join(themeDirectory, SHOPER_THEME_METADATA_DIR, THEME_FILES_STRUCTURE_FILE_NAME));
+        if (!isWindowsOs())
+            return filesStructure;
+        return mapKeysPathsToWindowPlatform(filesStructure);
+    }
+    static async writeThemeFilesStructure(themeDirectory, filesStructure) {
+        const filePath = join(themeDirectory, SHOPER_THEME_METADATA_DIR, THEME_FILES_STRUCTURE_FILE_NAME);
+        await writeJSONFile(filePath, filesStructure);
+    }
+    static async getFilesPermissions(themeDirectory) {
+        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        return Object.entries(fileStructure).reduce((acc, [key, value]) => {
+            return {
+                ...acc,
+                [key]: value.permissions
+            };
+        }, {});
+    }
+    static async validateThemeDirectoryStructure({ checksums, permissions, rootDirectory }) {
+        return await validateDirectory({
+            permissions,
+            checksums,
+            rootDirectory
+        });
+    }
+    static async getThemeRootDirectories(themeDirectory) {
+        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        return Object.keys(filesStructure).filter((path) => {
+            return looksLikeDirectory(path);
+        });
+    }
+    static mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded = {}) {
+        return filesRecords.reduce((acc, { fileGlob, fileName }) => {
+            const name = localFileNameToUploaded[fileName] ?? fileName;
+            if (looksLikeDirectory(fileGlob)) {
+                const existingFiles = acc[fileGlob] || [];
+                return {
+                    ...acc,
+                    [fileGlob]: [...existingFiles, name]
+                };
+            }
+            else {
+                return {
+                    ...acc,
+                    [fileGlob]: name
+                };
+            }
+        }, {});
+    }
+    static async createAFilesListFile(themeRootDir, filesList) {
+        if (!filesList || !Object.keys(filesList).length)
+            return;
+        const toUnixStyleFilesList = Object.entries(filesList).reduce((acc, [filePath, value]) => {
+            const unixPath = toUnixPath(filePath);
+            const finalPath = looksLikeDirectory(unixPath) ? `${unixPath}${path.posix.sep}` : unixPath;
+            return {
+                ...acc,
+                [finalPath]: value
+            };
+        }, {});
+        await writeJSONFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME), toUnixStyleFilesList);
+    }
+    static async removeAFilesListFile(themeRootDir) {
+        await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
+    }
+}

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

@@ -0,0 +1,32 @@
+import { getAllFilesNamesInside } from '../../../../../utils/fs/fs_utils.js';
+import { THEME_CURRENT_CHECKSUMS_FILE_NAME, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME } from '../../theme_constants.js';
+import { join } from '../../../../../utils/path_utils.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
+import { computeFileChecksum } from '../../../../../utils/checksums/checksums_utils.js';
+import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
+export class HiddenDirectoryUtils {
+    static async ensureFilesInsideThemeMetaDataDirectoryUntouched(themeDirectory) {
+        const themeMetadataPath = this.getThemeHiddenDirectoryPath(themeDirectory);
+        const themeChecksums = new ThemeChecksums(themeDirectory);
+        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 &&
+            fileName !== THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME &&
+            fileName !== THEME_INITIAL_CHECKSUMS_FILE_NAME &&
+            fileName !== THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME);
+        for (const fileName of filesNames) {
+            if (fileName === THEME_CURRENT_CHECKSUMS_FILE_NAME)
+                continue;
+            const fileFullPath = join(themeMetadataPath, fileName);
+            const fileRelativePath = join(SHOPER_THEME_METADATA_DIR, fileName);
+            const currentChecksum = await computeFileChecksum(fileFullPath);
+            const initialChecksum = await themeChecksums.getInitialChecksumFromPath(fileRelativePath);
+            if (currentChecksum !== initialChecksum) {
+                throw new Error(`File ${fileName} inside theme metadata directory (${themeMetadataPath}) has been modified. You cannot modify files inside .shoper directory`);
+            }
+        }
+    }
+    static getThemeHiddenDirectoryPath(themeDirectory) {
+        return join(themeDirectory, SHOPER_THEME_METADATA_DIR);
+    }
+}

package/build/theme/features/theme/utils/meta_data/theme_meta_data_constants.js

@@ -0,0 +1 @@
+export const THEME_WORK_URL_MISMATCH_ERROR = 'theme.meta_data.error_work_url_mismatch';

package/build/theme/features/theme/utils/meta_data/theme_meta_data_error_factory.js

@@ -0,0 +1,15 @@
+import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { THEME_WORK_URL_MISMATCH_ERROR } from './theme_meta_data_constants.js';
+export class ThemeMetaDataErrorFactory {
+    static createThemeWorkUrlMismatchError(executionUrl, themeWorkUrl) {
+        return new AppError({
+            code: THEME_WORK_URL_MISMATCH_ERROR,
+            message: `Theme work URL "${themeWorkUrl}" does not match execution URL "${executionUrl}".`,
+            level: 'error',
+            details: {
+                executionUrl,
+                themeWorkUrl
+            }
+        });
+    }
+}

package/build/theme/features/theme/utils/meta_data/theme_meta_data_utils.js

@@ -0,0 +1,39 @@
+import { closestFile, readJSONFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
+import { join } from '../../../../../utils/path_utils.js';
+import { HiddenDirectoryUtils } from '../hidden_directory/hidden_directory_utils.js';
+import { ThemeMetaDataErrorFactory } from './theme_meta_data_error_factory.js';
+export class ThemeMetaDataUtils {
+    static async closestThemeRootDirectory(path) {
+        return closestFile(SHOPER_THEME_METADATA_DIR, path);
+    }
+    static getThemeMetadataFilePath(themeDirectory) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDirectory), 'metadata.json');
+    }
+    static async getThemeMetadata(themeDirectory) {
+        const filePath = this.getThemeMetadataFilePath(themeDirectory);
+        const metadataFileContent = await readJSONFile(filePath);
+        return {
+            themeId: String(metadataFileContent.skin_id)
+        };
+    }
+    static async updateThemeMetadata(themeDirectory, data) {
+        const filePath = this.getThemeMetadataFilePath(themeDirectory);
+        const newData = {
+            ...data,
+            skin_id: data.themeId
+        };
+        delete newData.themeId;
+        await writeJSONFile(filePath, newData);
+    }
+    static async getThemeWorkUrl(themeDirectory) {
+        const metadataFilePath = this.getThemeMetadataFilePath(themeDirectory);
+        const metadata = await readJSONFile(metadataFilePath);
+        return metadata.workUrl || '';
+    }
+    static async ensureThemeWorkUrlMatch(themeDirectory, executionWorkUrl) {
+        const metadataWorkUrl = await this.getThemeWorkUrl(themeDirectory);
+        if (metadataWorkUrl !== executionWorkUrl)
+            throw ThemeMetaDataErrorFactory.createThemeWorkUrlMismatchError(executionWorkUrl, metadataWorkUrl);
+    }
+}

package/build/theme/features/theme/utils/{directories → resources}/theme_resources_with_id_directory_utils.js

@@ -3,12 +3,9 @@ import walkSync from 'walk-sync';
 import { THEME_FILES_OPERATIONS } from '../../merge/theme_merge_constants.js';
 import { fileExists, readJSONFile, renameFile } from '../../../../../utils/fs/fs_utils.js';
 import { join } from '../../../../../utils/path_utils.js';
-import fs from 'node:fs';
-import fsPromises from 'node:fs/promises';
-import { computeChecksumsFromSource } from '../../../../../utils/checksums/checksums_utils.js';
-import { ThemeChecksumsUtils } from '../checksums/theme_checksums_utils.js';
+import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class ThemeResourcesWithIdDirectoryUtils {
-    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, localThemeDir, remoteResourcesDir, remoteThemeDir) {
+    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, remoteResourcesDir, remoteThemeDir) {
         const localThemeTree = new FSTree({
             entries: walkSync.entries(localResourcesDir, {
                 globs: ['*/'],
@@ -37,18 +34,10 @@ export class ThemeResourcesWithIdDirectoryUtils {
             if (!remoteResourceDirectoryRelativePath)
                 continue;
             await renameFile(join(remoteResourcesDir, remoteResourceDirectoryRelativePath), join(remoteResourcesDir, resourceDirectoryRelativePath));
-            const resultPath = join(remoteResourcesDir, resourceDirectoryRelativePath);
-            const stat = fs.lstatSync(resultPath);
-            console.log('stat', stat.isDirectory());
-            if (stat.isSymbolicLink()) {
-                console.warn(`[WARN] Renamed path became a symlink: ${resultPath}`);
-                console.warn(`Points to: ${await fsPromises.readlink(resultPath)}`);
-            }
             /**
              * If these become performance bottlenecks, we can consider computing checksums only for the changed directories.
              */
-            const checksums = await computeChecksumsFromSource(remoteThemeDir);
-            await ThemeChecksumsUtils.createThemeChecksumsFiles(remoteThemeDir, checksums);
+            await new ThemeChecksums(remoteThemeDir).updateAllChecksums();
         }
     }
     static async _getResourceIdToFilePathMap(entries) {

package/build/theme/features/theme/utils/theme_images_utils.js

@@ -1,27 +1,9 @@
 import { join } from '../../../../utils/path_utils.js';
 import { removeFile } from '../../../../utils/fs/fs_utils.js';
 export class ThemeImagesUtils {
-    static updateOriginalFilenameToUploadedFilename(filesList, uploadedImageData) {
-        const newFilesList = { ...filesList };
-        uploadedImageData
-            .filter(({ uploadedFilename }) => Boolean(uploadedFilename))
-            .forEach(({ originalFilename, uploadedFilename, location }) => {
-            if (typeof newFilesList[location] === 'string' && uploadedFilename) {
-                newFilesList[location] = uploadedFilename;
-                return;
-            }
-            if (Array.isArray(newFilesList[location]) && uploadedFilename) {
-                const indexOfOriginalFilename = newFilesList[location].indexOf(originalFilename);
-                if (indexOfOriginalFilename === -1 && !uploadedFilename)
-                    return;
-                newFilesList[location].splice(indexOfOriginalFilename, 1, uploadedFilename);
-            }
-        });
-        return newFilesList;
-    }
     static async removeUploadedOriginalFiles(themeRootDir, uploadedImagesData) {
         await Promise.all(uploadedImagesData
-            .filter(({ originalFilename }) => Boolean(originalFilename))
+            .filter(({ originalFilename, uploadedFilename }) => Boolean(originalFilename) && Boolean(uploadedFilename))
             .map(({ originalFilename, location }) => {
             const originalFilePath = join(themeRootDir, location, originalFilename);
             return removeFile(originalFilePath);

package/build/theme/features/theme/verify/api/theme_verify_api.js

@@ -0,0 +1,13 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { THEME_VERIFY_API_NAME } from '../theme_verify_constants.js';
+export class ThemeVerifyApi extends FeatureApi {
+    moduleName = THEME_VERIFY_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    async verifyTheme(props) {
+        return this.#service.verifyTheme(props);
+    }
+}

package/build/theme/features/theme/verify/http/theme_verify_http_api.js

@@ -0,0 +1,30 @@
+export class ThemeVerifyHttpApi {
+    #httpApi;
+    constructor(httpApi) {
+        this.#httpApi = httpApi;
+    }
+    verifyTheme(props) {
+        return this._verifyThemeData(props);
+    }
+    verifySkinstoreFiles(props) {
+        return this._verifyThemeData(props);
+    }
+    verifyThumbnail(props) {
+        return this._verifyThemeData(props);
+    }
+    _verifyThemeData({ actionData, shopUrl, stream }) {
+        const { method, url } = actionData;
+        return this.#httpApi.fetch({
+            url: `${shopUrl}${url}`,
+            method,
+            data: stream,
+            sanitizeOptions: {
+                disable: true
+            },
+            headers: {
+                'Content-Type': 'application/octet-stream'
+            },
+            isPrivate: true
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export const THEME_VERIFY_API_NAME = 'ThemeVerifyApi';
+export const THEME_VERIFY_FEATURE_NAME = 'ThemeVerify';

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

@@ -0,0 +1,19 @@
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, 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';
+export class ThemeVerifyInitializer extends SyncFeatureInitializer {
+    static featureName = THEME_VERIFY_FEATURE_NAME;
+    init() {
+        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const service = new ThemeVerifyService();
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeVerifyApi(service)
+                }
+            ]
+        };
+    }
+}

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

@@ -0,0 +1,55 @@
+import tmp from 'tmp-promise';
+import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
+import { ThemePushErrorsFactory } from '../../push/theme_push_errors_factory.js';
+import { join } from '../../../../../utils/path_utils.js';
+import { v4 as uuid } from 'uuid';
+import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
+import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
+import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
+import { ArrayUtils } from '@dreamcommerce/utilities';
+export class ThemeVerifyService {
+    async verifyTheme({ verifyAction, executionContext, credentials, themeChecksums, filesStructure, themeFilesUploadApi }) {
+        const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        const themeRootDir = executionContext.themeRootDir;
+        if (await themeChecksums.hasThemeFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(themeRootDir)))
+            throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
+        try {
+            //TODO to do api?
+            const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
+                themeRootDir,
+                themeAction: verifyAction,
+                filesStructure
+            });
+            const filesToVerify = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenModified(path)) || !(await themeChecksums.hasThemeFileBeenCreated(path)));
+            if (filesToVerify.length) {
+                const { rejectedImageData } = await themeFilesUploadApi.uploadFiles(filesToVerify);
+                if (rejectedImageData.length)
+                    return {
+                        isSuccess: false,
+                        messages: rejectedImageData.flatMap((file) => file.messages)
+                    };
+            }
+            await this._createFilesList(themeRootDir, filesToVerify);
+            const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
+            await new ThemeArchive(themeRootDir).createFullArchive({
+                dist: themeArchivePath,
+                actionValue: THEME_WILDCARD_ACTION_NAME,
+                actionType: THEME_ACTIONS_TYPES.push
+            });
+            const { isSuccess, messages } = await themeFilesUploadApi.uploadArchive({
+                action: verifyAction,
+                themeArchivePath,
+                credentials
+            });
+            return { isSuccess, messages };
+        }
+        finally {
+            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
+        }
+    }
+    async _createFilesList(themeRootDir, filesRecords) {
+        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords));
+    }
+}

package/build/theme/features/themes/list/api/themes_list_api.js

@@ -10,4 +10,7 @@ export class ThemesListApi extends FeatureApi {
     async getThemes(credentials) {
         return this.#service.getThemes(credentials);
     }
+    async getTheme(props) {
+        return this.#service.getTheme(props);
+    }
 }

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

@@ -1,20 +1,20 @@
 import { ThemeMetaData } from '../model/theme_list_metadata.js';
 import { STATUS_CODES } from '@dreamcommerce/star_core';
-import { HttpErrorsFactory } from '../../../../../cli/class/errors/http_errors_factory.js';
+import { HttpErrorsFactory } from '../../../../../cli/class/errors/http/http_errors_factory.js';
 import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
 export class ThemesListService {
-    httpApi;
+    #httpApi;
     constructor(httpApi) {
-        this.httpApi = httpApi;
+        this.#httpApi = httpApi;
     }
     async getThemes({ shopUrl }) {
         try {
-            const { response } = this.httpApi.getThemes(shopUrl);
-            const { data, status } = await response;
-            if (status !== STATUS_CODES.ok)
+            const { response: request } = this.#httpApi.getThemes(shopUrl);
+            const response = await request;
+            if (response?.status !== STATUS_CODES.ok)
                 return;
             //TODO baseHttpApi + model mapper
-            return data.map(({ _links, ...rest }) => new ThemeMetaData({
+            return response?.data.map(({ _links, ...rest }) => new ThemeMetaData({
                 ...rest,
                 links: _links
             }));
@@ -34,4 +34,10 @@ export class ThemesListService {
             }
         }
     }
+    async getTheme({ themeId, shopUrl }) {
+        const themes = await this.getThemes({ shopUrl });
+        if (!themes)
+            return;
+        return themes.find((theme) => String(theme.skinId) === themeId);
+    }
 }

package/build/theme/hooks/{ensure_theme_meta_data_untouched.js → ensure_theme_meta_data_untouched_hook.js}

@@ -1,13 +1,13 @@
 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 { ThemeDirectoryUtils } from '../features/theme/directory/theme_directory_utils.js';
+import { HiddenDirectoryUtils } from '../features/theme/utils/hidden_directory/hidden_directory_utils.js';
 const ensureThemeMetaDataUntouched = async () => {
     const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
     const executionContext = await executionContextApi.getExecutionContext();
     if (executionContext.type !== EXECUTION_CONTEXTS.theme)
         return;
     try {
-        await ThemeDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir);
+        await HiddenDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir);
     }
     catch (err) {
         console.error(err);

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

@@ -1,7 +1,6 @@
 import { THEME_COMMANDS_NAME } from '../../commands/theme_commands_constants.js';
 export const THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS = [
     THEME_COMMANDS_NAME.push,
-    THEME_COMMANDS_NAME.showChanges,
-    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.pull,
     THEME_COMMANDS_NAME.verify
 ];

package/build/theme/hooks/theme_checksums/{ensure_theme_current_checksums_up_to_date.js → ensure_theme_current_checksums_up_to_date_hook.js}

@@ -1,10 +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 { ThemeChecksumsUtils } from '../../features/theme/utils/checksums/theme_checksums_utils.js';
-import { computeChecksumsFromSource } from '../../../utils/checksums/checksums_utils.js';
 import { THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS } from './ensure_theme_current_checksums_up_to_date_constants.js';
+import { ThemeChecksums } from '../../../theme/class/checksums/theme_checksums.js';
 export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
-    console.log('Command', Command.id);
     if (!THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS.includes(Command.id))
         return;
     const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
@@ -15,7 +13,6 @@ export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
      * 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.
      */
-    const checksums = await computeChecksumsFromSource(executionContext.themeRootDir);
-    await ThemeChecksumsUtils.createThemeCurrentChecksumsFile(executionContext.themeRootDir, checksums);
+    await new ThemeChecksums(executionContext.themeRootDir).updateCurrentChecksums();
 };
 export default ensureThemeChecksumsUpToDate;

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

@@ -31,6 +31,7 @@ const ensureThemesActionsHook = async ({ Command, argv }) => {
             console.error('Unauthorized. Please authorize first.');
             const cliAuthTokensApi = useApi(CLI_AUTH_TOKENS_API_NAME);
             await promptForToken(cliAuthTokensApi);
+            //TODO loader
             await themesActionsApi.ensureThemesActions({
                 credentials,
                 themeId

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

@@ -3,5 +3,5 @@ export const THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST = [
     THEME_COMMANDS_NAME.pull,
     THEME_COMMANDS_NAME.init,
     THEME_COMMANDS_NAME.push,
-    THEME_COMMANDS_NAME.showChanges
+    THEME_COMMANDS_NAME.delete
 ];

package/build/theme/index.js

@@ -1,15 +1,41 @@
-import { ThemeListCommand } from './commands/theme_list_command.js';
-import { ThemePullCommand } from './commands/theme_pull_command.js';
-import { ThemeInitCommand } from './commands/theme_init_command.js';
-import { THEME_COMMANDS_NAME } from './commands/theme_commands_constants.js';
-import { ThemePushCommand } from './commands/theme_push_command.js';
-import { ThemeShowChangesCommand } from './commands/theme_show_changes_command.js';
+import { ThemeListCommand } from './commands/list/theme_list_command.js';
+import { ThemePullCommand } from './commands/pull/theme_pull_command.js';
+import { ThemeInitCommand } from './commands/init/theme_init_command.js';
+import { THEME_COMMANDS_NAME, THEME_TOPIC_NAME } from './commands/theme_commands_constants.js';
+import { ThemePushCommand } from './commands/push/theme_push_command.js';
 import { ThemeVerifyCommand } from './commands/theme_verify_command.js';
+import { ThemeInfoCommand } from './commands/info/theme_info_command.js';
+import { ThemeDeleteCommand } from './commands/delete/theme_delete_command.js';
+import { ThemePublishCommand } from './commands/publish/theme_publish_command.js';
+import { ThemesListInitializer } from './features/themes/list/themes_list_initializer.js';
+import { ThemeMergeInitializer } from './features/theme/merge/theme_merge_initializer.js';
+import { ThemeFetchInitializer } from './features/theme/fetch/theme_fetch_initializer.js';
+import { ThemeInitInitializer } from './features/theme/init/theme_init_initializer.js';
+import { ThemePushInitializer } from './features/theme/push/theme_push_initializer.js';
+import { ThemeVerifyInitializer } from './features/theme/verify/theme_verify_initializer.js';
+import { ThemeDeleteInitializer } from './features/theme/delete/theme_delete_initalizer.js';
+import { ThemeActionsInitializer } from './features/theme/actions/theme_actions_initializer.js';
 export const COMMANDS = {
     [THEME_COMMANDS_NAME.list]: ThemeListCommand,
     [THEME_COMMANDS_NAME.pull]: ThemePullCommand,
     [THEME_COMMANDS_NAME.init]: ThemeInitCommand,
     [THEME_COMMANDS_NAME.push]: ThemePushCommand,
-    [THEME_COMMANDS_NAME.showChanges]: ThemeShowChangesCommand,
-    [THEME_COMMANDS_NAME.verify]: ThemeVerifyCommand
+    [THEME_COMMANDS_NAME.verify]: ThemeVerifyCommand,
+    [THEME_COMMANDS_NAME.info]: ThemeInfoCommand,
+    [THEME_COMMANDS_NAME.delete]: ThemeDeleteCommand,
+    [THEME_COMMANDS_NAME.publish]: ThemePublishCommand
+};
+export const COMMAND_TO_FEATURES_MAP = {
+    [THEME_COMMANDS_NAME.pull]: [ThemeMergeInitializer, ThemeFetchInitializer],
+    [THEME_COMMANDS_NAME.init]: ThemeInitInitializer,
+    [THEME_COMMANDS_NAME.push]: [ThemeFetchInitializer, ThemePushInitializer],
+    [THEME_COMMANDS_NAME.verify]: ThemeVerifyInitializer,
+    [THEME_COMMANDS_NAME.delete]: ThemeDeleteInitializer
+};
+export const getThemeInitializersForCommand = (commandName) => {
+    if (!commandName)
+        return [];
+    const alwaysIncludedInitializers = [ThemesListInitializer, ThemeActionsInitializer];
+    const initializers = COMMAND_TO_FEATURES_MAP[`${THEME_TOPIC_NAME}:${commandName}`] ?? [];
+    return [...alwaysIncludedInitializers, ...(Array.isArray(initializers) ? initializers : [initializers])];
 };

package/build/theme/utils/directory_validator/directory_validator_constants.js

@@ -1,13 +1,9 @@
+import { platformSeparator } from '../../../utils/path_utils.js';
 export const FILES_MODIFICATION_TYPES = {
     add: 'add',
     remove: 'remove',
     edit: 'edit'
 };
 export const DEFAULT_PERMISSION_FOR_ALL_FILES_KEY = '*';
-export const DEFAULT_PERMISSION_FOR_DIRECTORY_KEY = '*/';
+export const DEFAULT_PERMISSION_FOR_DIRECTORY_KEY = `*${platformSeparator}`;
 export const PERMISSION_KEY = '__permission__';
-export const DEFAULT_DIRECTORY_STRUCTURE_PERMISSION = {
-    canAdd: false,
-    canEdit: false,
-    canDelete: false
-};