@shoper/cli 0.1.0-9 → 0.2.0

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

@@ -6,86 +6,92 @@ import { createReadStream } from 'node:fs';
 import { v4 as uuid } from 'uuid';
 import globs from 'fast-glob';
 import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
-import { getFilesGlobsThatMatchesActionName } from '../../actions/theme_actions_utils.js';
+import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
 import { THEME_FILES_LIST_FILE_NAME, THEME_MODULE_SETTINGS_FILE_NAME } from '../theme_push_constants.js';
 import { THEME_PUSH_WILDCARD_GLOBS_FOR_FILES } from './theme_push_service_constants.js';
 import { ThemePushErrorsFactory } from '../theme_push_errors_factory.js';
 import { ThemeImagesUtils } from '../../utils/theme_images_utils.js';
-import { ThemePublishUtils } from '../../publish/theme_publish_utils.js';
+import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
 import { formatJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
-import { computeChecksumsFromSource } from '../../../../../utils/checksums/checksums_utils.js';
-import { ThemeChecksumsUtils } from '../../utils/checksums/theme_checksums_utils.js';
 import { MODULES_DIRECTORY_NAME } from '../../theme_constants.js';
+import path from 'node:path';
+import { removeOldResources } from '../../../../class/fetch_resources/fetch_resources_utils.js';
 export class ThemePushService {
     #themePushHttpApi;
-    #themeMergeApi;
     #themeFetchApi;
-    constructor({ themePushHttpApi, themeMergeApi, themeFetchApi }) {
+    constructor({ themePushHttpApi, themeFetchApi }) {
         this.#themePushHttpApi = themePushHttpApi;
-        this.#themeMergeApi = themeMergeApi;
         this.#themeFetchApi = themeFetchApi;
     }
-    async push({ pushAction, filesStructure, credentials, executionContext }) {
+    async push({ pushAction, filesStructure, credentials, executionContext, themeChecksums }) {
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
-        if (await this.#themeMergeApi.hasFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(executionContext.themeRootDir), executionContext))
+        const themeRootDir = executionContext.themeRootDir;
+        if (await themeChecksums.hasThemeFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(themeRootDir)))
             throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
-        const { uploadData, localFiles } = await this._getActionDataForFilesToUpload({
-            pushAction,
-            filesStructure,
-            executionContext
-        });
-        if (uploadData.length) {
-            await this._uploadThemeFiles({
-                filesToUpload: uploadData,
-                actionData: pushAction.data[THEME_WILDCARD_ACTION_NAME],
+        try {
+            const { uploadData, localFiles } = await this._getActionDataForFilesToUpload({
+                pushAction,
+                filesStructure,
+                executionContext,
+                themeChecksums
+            });
+            if (uploadData.length) {
+                const { newFiles } = await this._uploadThemeFiles({
+                    filesToUpload: uploadData,
+                    credentials,
+                    localFiles,
+                    themeRootDir
+                });
+                await this._createAFilesListFile(themeRootDir, newFiles);
+            }
+            else {
+                await this._createAFilesListFile(themeRootDir, localFiles);
+            }
+            const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
+            await this._createThemeArchive({
+                themeRootDir: themeRootDir,
+                filesToArchive: ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                    actionType: THEME_ACTIONS_TYPES.push,
+                    actionValue: THEME_WILDCARD_ACTION_NAME,
+                    filesStructure
+                }),
+                dist: themeArchivePath,
+                credentials
+            });
+            const { resources, modules } = await this._uploadThemeArchive({
+                themeArchivePath,
                 credentials,
-                localFiles,
-                themeRootDir: executionContext.themeRootDir
+                pushAction
             });
+            if (modules)
+                await this._updateDataForNewCreatedModules({ modules, themeRootDir });
+            if (resources) {
+                await removeOldResources(themeRootDir, resources);
+                await this.#themeFetchApi.fetchResources(credentials.shopUrl, themeRootDir, resources);
+            }
+            await themeChecksums.updateAllChecksums();
         }
-        else {
-            await this._createAFilesListFile(executionContext.themeRootDir, localFiles);
+        finally {
+            await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
         }
-        const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
+    }
+    async _createThemeArchive({ themeRootDir, filesToArchive, dist, credentials }) {
         try {
-            await this._createThemeArchive({
-                themeRootDir: executionContext.themeRootDir,
-                filesToArchive: [
-                    ...getFilesGlobsThatMatchesActionName(THEME_ACTIONS_TYPES.push, THEME_WILDCARD_ACTION_NAME, filesStructure),
-                    THEME_FILES_LIST_FILE_NAME
-                ],
-                dist: themeArchivePath
+            const filesInThemeDirectory = await globs(filesToArchive, {
+                suppressErrors: true,
+                onlyFiles: true,
+                cwd: themeRootDir
+            });
+            await this._formatJsonFiles(themeRootDir, filesInThemeDirectory);
+            return createZip({
+                files: filesInThemeDirectory,
+                baseDir: themeRootDir,
+                dist
             });
         }
         catch (err) {
             throw ThemePushErrorsFactory.createErrorWhileCreatingThemeArchive(credentials.shopUrl, err);
         }
-        const { resources, modules } = await this._uploadThemeArchive({
-            themeArchivePath,
-            credentials,
-            pushAction
-        });
-        if (modules)
-            await this._updateDataForNewCreatedModules({ modules, themeRootDir: executionContext.themeRootDir });
-        console.log(JSON.stringify(resources));
-        if (resources)
-            await this.#themeFetchApi.fetchResources(credentials.shopUrl, executionContext.themeRootDir, resources);
-        await removeFile(join(executionContext.themeRootDir, THEME_FILES_LIST_FILE_NAME));
-        const checksums = await computeChecksumsFromSource(executionContext.themeRootDir);
-        await ThemeChecksumsUtils.createThemeChecksumsFiles(executionContext.themeRootDir, checksums);
-    }
-    async _createThemeArchive({ themeRootDir, filesToArchive, dist }) {
-        const filesInThemeDirectory = await globs(filesToArchive, {
-            suppressErrors: true,
-            onlyFiles: true,
-            cwd: themeRootDir
-        });
-        await this._formatJsonFiles(themeRootDir, filesInThemeDirectory);
-        return createZip({
-            files: filesInThemeDirectory,
-            baseDir: themeRootDir,
-            dist
-        });
     }
     async _uploadThemeArchive({ themeArchivePath, credentials, pushAction }) {
         try {
@@ -100,7 +106,6 @@ export class ThemePushService {
             return response.data;
         }
         catch (err) {
-            console.log('error', err.response.data.messages);
             throw ThemePushErrorsFactory.createErrorWhileUploadingTheme(credentials.shopUrl, err.response.data.messages);
         }
     }
@@ -109,20 +114,27 @@ export class ThemePushService {
             .filter((path) => extname(path).toLowerCase() === '.json')
             .map((jsonFile) => formatJSONFile(join(themeRootDir, jsonFile))));
     }
+    //TODO osobna klasa do uploadu
     async _uploadThemeFiles({ filesToUpload, themeRootDir, localFiles, credentials }) {
         try {
-            const uploadedImageData = await this._uploadFiles(filesToUpload, credentials);
+            const { uploadedImageData, rejectedImageData } = await this._uploadFiles(filesToUpload, credentials);
             const newFilesList = ThemeImagesUtils.updateOriginalFilenameToUploadedFilename(localFiles, uploadedImageData);
             if (uploadedImageData.length)
                 await ThemeImagesUtils.removeUploadedOriginalFiles(themeRootDir, uploadedImageData);
-            await this._createAFilesListFile(themeRootDir, newFilesList);
+            if (rejectedImageData.length)
+                await this._removeUploadedThemeFiles(rejectedImageData, themeRootDir);
+            return { newFiles: newFilesList };
         }
         catch (err) {
             throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl, err);
         }
     }
+    async _removeUploadedThemeFiles(uploadedImageData, themeRootDir) {
+        await Promise.all(uploadedImageData.map(({ location, originalFilename }) => removeFile(join(themeRootDir, location, originalFilename))));
+    }
     async _uploadFiles(uploadData, credentials) {
         const uploadedImageData = [];
+        const rejectedImageData = [];
         await Promise.all(uploadData.map(({ actionData, path }) => this.#themePushHttpApi
             .pushThemeData({
             actionData,
@@ -130,22 +142,33 @@ export class ThemePushService {
             shopUrl: credentials.shopUrl
         })
             .response.then((response) => {
-            if (response.status !== 200 || !response.data.isSuccess)
-                throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl, response.data?.messages ?? []);
             uploadedImageData.push({
                 location: dirname(path),
                 originalFilename: basename(path),
                 uploadedFilename: response.data.imageId
             });
+        })
+            .catch(() => {
+            rejectedImageData.push({
+                location: dirname(path),
+                originalFilename: basename(path)
+            });
         })));
-        return uploadedImageData;
+        return {
+            uploadedImageData,
+            rejectedImageData
+        };
     }
-    async _getActionDataForFilesToUpload({ pushAction, filesStructure, executionContext }) {
+    async _getActionDataForFilesToUpload({ pushAction, filesStructure, executionContext, themeChecksums }) {
         const uploadData = [];
         const localFiles = {};
         for (const [actionKey, actionData] of Object.entries(pushAction.data)) {
             if (actionData.type === THEME_ACTION_DATA_TYPE.file) {
-                const filesGlobs = getFilesGlobsThatMatchesActionName(THEME_ACTIONS_TYPES.push, actionKey, filesStructure);
+                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                    actionType: THEME_ACTIONS_TYPES.push,
+                    actionValue: actionKey,
+                    filesStructure
+                });
                 for (const fileGlob of filesGlobs) {
                     const files = await globs(fileGlob, {
                         suppressErrors: true,
@@ -162,8 +185,8 @@ export class ThemePushService {
                         localFiles[fileGlob] = files.length ? basename(files[0]) : null;
                     }
                     for (const filePath of files) {
-                        if ((await this.#themeMergeApi.hasFileBeenCreated(filePath, executionContext)) ||
-                            (await this.#themeMergeApi.hasFileBeenModified(filePath, executionContext))) {
+                        if ((await themeChecksums.hasThemeFileBeenCreated(filePath)) ||
+                            (await themeChecksums.hasThemeFileBeenModified(filePath))) {
                             uploadData.push({
                                 actionData,
                                 actionKey,
@@ -187,9 +210,9 @@ export class ThemePushService {
     async _createAFilesListFile(themeRootDir, filesList) {
         if (!filesList || !Object.keys(filesList).length)
             return;
-        const toUnixStyleFilesList = Object.entries(filesList).reduce((acc, [path, value]) => {
-            const unixPath = toUnixPath(path);
-            const finalPath = looksLikeDirectory(path) ? `${unixPath}/` : unixPath;
+        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

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

@@ -2,3 +2,5 @@ export const THEME_PUSH_FEATURE_NAME = 'ThemePush';
 export const THEME_PUSH_API_NAME = 'ThemePushApi';
 export const THEME_FILES_LIST_FILE_NAME = 'filesList.json';
 export const THEME_MODULE_SETTINGS_FILE_NAME = 'settings.json';
+export const THEME_ARCHIVE_UPLOAD_ERROR = 'theme.push.error_uploading_theme_archive';
+export const THEME_FILES_UPLOAD_ERROR = 'theme.push.error_uploading_theme_files';

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

@@ -1,11 +1,14 @@
-import { AppError } from '../../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../../cli/class/errors/app/app_error.js';
+import { THEME_ARCHIVE_UPLOAD_ERROR, THEME_FILES_UPLOAD_ERROR } from './theme_push_constants.js';
 export class ThemePushErrorsFactory {
     static createErrorWhileUploadingThemeFiles(shopUrl, messages) {
         return new AppError({
-            code: 'theme.push.error_uploading_theme_files',
+            code: THEME_FILES_UPLOAD_ERROR,
             message: `Error while uploading theme files to shop "${shopUrl}"`,
             level: 'error',
-            details: messages
+            details: {
+                messages
+            }
         });
     }
     static createErrorWhileCreatingThemeArchive(shopUrl, error) {
@@ -32,7 +35,7 @@ export class ThemePushErrorsFactory {
     }
     static createErrorWhileUploadingTheme(shopUrl, messages) {
         return new AppError({
-            code: 'theme.push.error_uploading_theme',
+            code: THEME_ARCHIVE_UPLOAD_ERROR,
             message: `Error while uploading theme to shop "${shopUrl}"`,
             level: 'error',
             details: messages

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

@@ -3,16 +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 { ThemePushHttpApi } from './http_api/theme_push_http_api.js';
-import { THEME_MERGE_API_NAME } from '../merge/theme_merge_constants.js';
 import { THEME_FETCH_API_NAME } from '../fetch/theme_fetch_constants.js';
 export class ThemePushInitializer extends SyncFeatureInitializer {
     static featureName = THEME_PUSH_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const themeMergeApi = this.getApiSync(THEME_MERGE_API_NAME);
         const service = new ThemePushService({
             themePushHttpApi: new ThemePushHttpApi(httpApi),
-            themeMergeApi,
             themeFetchApi: this.getApiSync(THEME_FETCH_API_NAME)
         });
         return {

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

@@ -0,0 +1,25 @@
+import globs from 'fast-glob';
+import { AppError } from '../../../../cli/class/errors/app/app_error.js';
+import { toUnixPath } from '../../../../utils/path_utils.js';
+import { ThemeFilesStructureUtils } from '../utils/files_structure/theme_files_structure_utils.js';
+export class ThemePushUtils {
+    static async getAllFilesThatAreSendToRemote(themeDir) {
+        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
+        if (!filesStructure)
+            throw new AppError({
+                message: `Files structure not found in theme directory: ${themeDir}`,
+                code: 'theme_files_structure_not_found'
+            });
+        //need unix styles globs
+        const filesToArchive = Object.keys(filesStructure)
+            .map((path) => toUnixPath(path))
+            .filter((path) => path !== '*');
+        //need unix styles globs
+        filesToArchive.push('styles/src/**/*');
+        return await globs(filesToArchive, {
+            suppressErrors: true,
+            onlyFiles: true,
+            cwd: themeDir
+        }).then((files) => files.sort());
+    }
+}

package/build/theme/features/theme/skinstore/api/theme_skinstore_api.js

@@ -0,0 +1,19 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { THEME_SKINSTORE_API_NAME } from '../theme_publish_constants.js';
+export class ThemeSkinstoreApi extends FeatureApi {
+    moduleName = THEME_SKINSTORE_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    async getPublishFormData(props) {
+        return this.#service.getPublishFormData(props);
+    }
+    async publish(themeId) {
+        // return this.#service.publish(themeId);
+    }
+    async update() {
+        // return this.#service.update();
+    }
+}

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_files_structure_utils.js

@@ -0,0 +1,40 @@
+import { readJSONFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { join, looksLikeDirectory, mapKeysPathsToWindowPlatform } 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';
+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);
+        });
+    }
+}

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

@@ -21,7 +21,7 @@ export class ThemeImagesUtils {
     }
     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/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);
+    }
 }