@shoper/cli 0.2.0 → 0.2.1-0

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

@@ -1,8 +1,8 @@
 import { BaseThemeCommand } from '../../class/base_theme_command.js';
 import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
-import { THEME_ACTION_NOT_FOUND_ERROR_CODE, THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
-import { THEME_ARCHIVE_UPLOAD_ERROR, THEME_FILES_UPLOAD_ERROR, THEME_PUSH_API_NAME } from '../../features/theme/push/theme_push_constants.js';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
+import { THEME_PUSH_API_NAME } from '../../features/theme/push/theme_push_constants.js';
 import { ThemeMetaDataUtils } from '../../features/theme/utils/meta_data/theme_meta_data_utils.js';
 import { mapChecksumToTree } from '../../../utils/checksums/checksums_utils.js';
 import { mapToPermissionsTree } from '../../utils/directory_validator/directory_validator_utils.js';
@@ -13,19 +13,18 @@ import { OutsideOfThemeDirectoryContextError } from '../ui/ouside_of_theme_direc
 import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
 import { ThemePushedSuccess } from './ui/theme_pushed_success.js';
 import ora from 'ora';
-import { MissingThemeFiles } from '../ui/missing_theme_files.js';
-import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
-import { THEME_FILES_STRUCTURE_FILE_NAME } from '../../features/theme/theme_constants.js';
 import { ThemePushSkipInfo } from './ui/theme_push_skip_into.js';
 import { ThemeUnpermittedActionsError } from './ui/theme_unpermitted_actions_error.js';
-import { Error } from '../../../ui/message_box/error.js';
-import { Text } from '../../../ui/text.js';
-import { ThemeWorkUrlMismatch } from '../ui/theme_work_url_mismatch.js';
-import { THEME_WORK_URL_MISMATCH_ERROR } from '../../features/theme/utils/meta_data/theme_meta_data_constants.js';
 import { ThemeFilesStructureUtils } from '../../features/theme/utils/files_structure/theme_files_structure_utils.js';
 import { ThemeInfoUtils } from '../../features/theme/info/theme_info_utils.js';
-import { ValidationErrors } from '../../../ui/validation_errors/validation_errors.js';
 import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
+import { ThemeFilesUpload } from '../../class/files_upload/theme_files_upload.js';
+import { ThemeFilesUploadHttpApi } from '../../class/files_upload/theme_files_upload_http_api.js';
+import { HTTP_REQUESTER_API_NAME } from '@dreamcommerce/star_core';
+import { MissingThemeFiles } from '../ui/missing_theme_files.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
+import { THEME_FILES_STRUCTURE_FILE_NAME } from '../../features/theme/theme_constants.js';
+import { ThemeError } from '../ui/theme_error.js';
 export class ThemePushCommand extends BaseThemeCommand {
     static summary = 'Uploads your local theme files to the store and overwrites the current version of the theme in your store.';
     static description = 'Check your local changes before pushing.\n\nYou must run this command from a specific theme directory (ID not needed).';
@@ -65,6 +64,11 @@ export class ThemePushCommand extends BaseThemeCommand {
             }
             const initialChecksums = await themeChecksums.getInitialChecksums();
             const permissions = await ThemeFilesStructureUtils.getFilesPermissions(executionContext.themeRootDir);
+            const themeFilesUploadApi = new ThemeFilesUpload({
+                themeRootDir: executionContext.themeRootDir,
+                credentials,
+                themeFilesUploadHttpApi: new ThemeFilesUploadHttpApi(this.getApi(HTTP_REQUESTER_API_NAME))
+            });
             if (!initialChecksums || !permissions)
                 this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');
             if (!(await themeChecksums.hasThemeBeenModified())) {
@@ -94,41 +98,15 @@ export class ThemePushCommand extends BaseThemeCommand {
                 filesStructure,
                 pushAction,
                 themeChecksums,
-                executionContext
+                executionContext,
+                themeFilesUploadApi
             });
             spinner.stop();
             renderOnce(React.createElement(ThemePushedSuccess, { themeName: await ThemeInfoUtils.getThemeName(executionContext.themeRootDir) }));
         }
         catch (err) {
             spinner?.stop();
-            this._handleError(err, executionContext);
-        }
-    }
-    _handleError(err, executionContext) {
-        if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE) {
-            renderOnce(React.createElement(UnpermittedCommandError, { themeId: executionContext.themeId, commandName: "push" }));
-            return;
-        }
-        if (err?.code === THEME_ARCHIVE_UPLOAD_ERROR) {
-            renderOnce(React.createElement(ValidationErrors, { errors: err?.details }));
-            return;
-        }
-        if (err?.code === THEME_WORK_URL_MISMATCH_ERROR) {
-            this._renderUrlMismatchError();
-            return;
+            renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
-        if (err?.code === THEME_FILES_UPLOAD_ERROR) {
-            renderOnce(React.createElement(Error, { header: "Uploading theme files to the shop failed.\n" },
-                React.createElement(Text, null, "The rejected files have been removed locally. Please ensure that the files are not corrupted and that the file extensions are supported.")));
-            return;
-        }
-        if (err?.message) {
-            renderOnce(React.createElement(ValidationErrors, { errors: err.message }));
-            return;
-        }
-        this.error(String(err));
-    }
-    _renderUrlMismatchError() {
-        renderOnce(React.createElement(ThemeWorkUrlMismatch, { command: "push" }));
     }
 }

package/build/theme/commands/theme_commands_constants.js

@@ -1,11 +1,11 @@
+export const THEME_TOPIC_NAME = 'theme';
 export const THEME_COMMANDS_NAME = {
-    list: 'theme:list',
-    pull: 'theme:pull',
-    init: 'theme:init',
-    push: 'theme:push',
-    showChanges: 'theme:show-changes',
-    verify: 'theme:verify',
-    info: 'theme:info',
-    delete: 'theme:delete',
-    publish: 'theme:publish'
+    list: `${THEME_TOPIC_NAME}:list`,
+    pull: `${THEME_TOPIC_NAME}:pull`,
+    init: `${THEME_TOPIC_NAME}:init`,
+    push: `${THEME_TOPIC_NAME}:push`,
+    verify: `${THEME_TOPIC_NAME}:verify`,
+    info: `${THEME_TOPIC_NAME}:info`,
+    delete: `${THEME_TOPIC_NAME}:delete`,
+    publish: `${THEME_TOPIC_NAME}:publish`
 };

package/build/theme/commands/theme_verify_command.js

@@ -1,44 +1,85 @@
 import { BaseThemeCommand } from '../class/base_theme_command.js';
 import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
-import { mapToPermissionsTree } from '../utils/directory_validator/directory_validator_utils.js';
-import { mapChecksumToTree } from '../../utils/checksums/checksums_utils.js';
 import { ThemeFilesStructureUtils } from '../features/theme/utils/files_structure/theme_files_structure_utils.js';
 import { ThemeChecksums } from '../class/checksums/theme_checksums.js';
+import { THEME_VERIFY_API_NAME } from '../features/theme/verify/theme_verify_constants.js';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../features/theme/actions/theme_actions_constants.js';
+import { ThemeFilesUpload } from '../class/files_upload/theme_files_upload.js';
+import { ThemeFilesUploadHttpApi } from '../class/files_upload/theme_files_upload_http_api.js';
+import { HTTP_REQUESTER_API_NAME } from '@dreamcommerce/star_core';
+import { renderOnce } from '../../ui/ui_utils.js';
+import { MissingThemeFiles } from './ui/missing_theme_files.js';
+import { SHOPER_THEME_METADATA_DIR } from '../constants/directory_contstants.js';
+import { THEME_FILES_STRUCTURE_FILE_NAME } from '../features/theme/theme_constants.js';
+import React from 'react';
+import { Success } from '../../ui/message_box/success.js';
+import { MissingCredentialsError } from '../../cli/commands/auth/ui/missing_credentials_error.js';
+import { OutsideOfThemeDirectoryContextError } from './ui/ouside_of_theme_directory_context_error.js';
+import ora from 'ora';
+import { ThemeError } from './ui/theme_error.js';
 export class ThemeVerifyCommand extends BaseThemeCommand {
     static description = 'Verify theme files structure';
-    static hidden = true;
     async run() {
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
-        if (!credentials)
-            this.error('Credentials not found. Please authorize first.');
+        if (!credentials) {
+            renderOnce(React.createElement(MissingCredentialsError, null));
+            return;
+        }
         const executionContext = await executionContextApi.getExecutionContext();
-        if (executionContext.type !== EXECUTION_CONTEXTS.theme)
-            this.error('You cannot run this command outside theme context.');
+        if (executionContext.type !== EXECUTION_CONTEXTS.theme) {
+            renderOnce(React.createElement(OutsideOfThemeDirectoryContextError, null));
+            return;
+        }
         const themeChecksums = new ThemeChecksums(executionContext.themeRootDir);
         const permissions = await ThemeFilesStructureUtils.getFilesPermissions(executionContext.themeRootDir);
         if (!themeChecksums || !permissions)
             this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');
+        let spinner;
         try {
-            const validationResult = await ThemeFilesStructureUtils.validateThemeDirectoryStructure({
-                checksums: mapChecksumToTree(await themeChecksums.getInitialChecksums()),
-                permissions: mapToPermissionsTree(permissions),
-                rootDirectory: executionContext.themeRootDir
+            const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+            const themeVerifyApi = this.getApi(THEME_VERIFY_API_NAME);
+            const themeFilesUploadApi = new ThemeFilesUpload({
+                themeRootDir: executionContext.themeRootDir,
+                credentials,
+                themeFilesUploadHttpApi: new ThemeFilesUploadHttpApi(this.getApi(HTTP_REQUESTER_API_NAME))
+            });
+            const verifyAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.verify,
+                themeId: executionContext.themeId,
+                credentials
+            });
+            const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(executionContext.themeRootDir);
+            if (!filesStructure) {
+                renderOnce(React.createElement(MissingThemeFiles, { files: `${SHOPER_THEME_METADATA_DIR}/${THEME_FILES_STRUCTURE_FILE_NAME}` }));
+                return;
+            }
+            spinner = ora('Verifying theme...').start();
+            const { isSuccess, messages } = await themeVerifyApi.verifyTheme({
+                verifyAction,
+                filesStructure,
+                executionContext,
+                credentials,
+                themeChecksums,
+                themeFilesUploadApi
             });
-            if (validationResult.isValid) {
-                this.log('Theme structure is valid.');
+            spinner.stop();
+            if (isSuccess) {
+                renderOnce(React.createElement(Success, { header: `Success: Theme verified!` }));
             }
             else {
-                this.log('Verification failed.\n');
-                validationResult.unpermittedActions.forEach((action) => {
-                    this.log(`Unpermitted action: ${action.type} path: ${action.path}`);
-                });
+                renderOnce(React.createElement(ThemeError, { err: {
+                        massages: messages
+                    }, executionContext: executionContext }));
             }
+            // await promptConfirmation('jolo');
         }
         catch (err) {
-            this.error(`Error during theme verification: ${err instanceof Error ? err.message : String(err)}`);
+            spinner?.stop();
+            // await promptConfirmation('jolo');
+            renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
     }
 }

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

@@ -0,0 +1,29 @@
+import { THEME_ACTION_NOT_FOUND_ERROR_CODE } from '../../features/theme/actions/theme_actions_constants.js';
+import { UnpermittedCommandError } from './unpermitted_command_error.js';
+import { THEME_ARCHIVE_UPLOAD_ERROR, THEME_FILES_UPLOAD_ERROR } from '../../features/theme/push/theme_push_constants.js';
+import { ValidationErrors } from '../../../ui/validation_errors/validation_errors.js';
+import { THEME_WORK_URL_MISMATCH_ERROR } from '../../features/theme/utils/meta_data/theme_meta_data_constants.js';
+import { Error } from '../../../ui/message_box/error.js';
+import { Text } from '../../../ui/text.js';
+import React from 'react';
+import { ThemeWorkUrlMismatch } from './theme_work_url_mismatch.js';
+import { EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+export const ThemeError = ({ err, executionContext }) => {
+    if (err?.code === THEME_ACTION_NOT_FOUND_ERROR_CODE && executionContext.type === EXECUTION_CONTEXTS.theme) {
+        return (React.createElement(UnpermittedCommandError, { themeId: executionContext.themeId, commandName: "verify" }));
+    }
+    if (err?.code === THEME_ARCHIVE_UPLOAD_ERROR) {
+        return React.createElement(ValidationErrors, { errors: err?.details });
+    }
+    if (err?.code === THEME_WORK_URL_MISMATCH_ERROR) {
+        return React.createElement(ThemeWorkUrlMismatch, { command: "verify" });
+    }
+    if (err?.code === THEME_FILES_UPLOAD_ERROR) {
+        return (React.createElement(Error, { header: "Uploading theme files to the shop failed.\n" },
+            React.createElement(Text, null, "The rejected files have been removed locally. Please ensure that the files are not corrupted and that the file extensions are supported.")));
+    }
+    if (err?.message) {
+        return React.createElement(ValidationErrors, { errors: err.message });
+    }
+    return String(err);
+};

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

@@ -7,7 +7,8 @@ export const THEME_ACTIONS_TYPES = {
     pull: 'pull',
     delete: 'delete',
     publishForm: 'publish_form',
-    publish: 'publish'
+    publish: 'publish',
+    verify: 'verify'
 };
 export const THEME_ACTION_DATA_TYPE = {
     file: 'file',

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

@@ -1,5 +1,8 @@
 import { THEME_ALL_ACTIONS_NAME } from './service/theme_actions_service_constants.js';
-import { toUnixPath } from '../../../../utils/path_utils.js';
+import { basename, looksLikeDirectory, toUnixPath } from '../../../../utils/path_utils.js';
+import { THEME_ACTION_DATA_TYPE } from './theme_actions_constants.js';
+import globs from 'fast-glob';
+import { THEME_PUSH_WILDCARD_GLOBS_FOR_FILES } from '../push/service/theme_push_service_constants.js';
 export class ThemeActionsUtils {
     static getFilesGlobsThatMatchesActionName({ filesStructure, actionValue, actionType }) {
         return Object.entries(filesStructure).reduce((acc, [filePath, fileStructureItem]) => {
@@ -9,6 +12,43 @@ export class ThemeActionsUtils {
             return acc;
         }, []);
     }
+    static async getFilesRecordsFromActionData({ themeRootDir, themeAction, filesStructure }) {
+        const filesRecords = [];
+        for (const [actionKey, actionData] of Object.entries(themeAction.data)) {
+            if (actionData.type === THEME_ACTION_DATA_TYPE.file) {
+                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                    //TODO remove when backend fixed
+                    actionType: 'push',
+                    // actionType: themeAction.actionType,
+                    actionValue: actionKey,
+                    filesStructure
+                });
+                for (const fileGlob of filesGlobs) {
+                    const files = await globs(fileGlob, {
+                        suppressErrors: true,
+                        onlyFiles: true,
+                        cwd: themeRootDir
+                    });
+                    let processedFileGlob = fileGlob;
+                    if (looksLikeDirectory(fileGlob)) {
+                        processedFileGlob = fileGlob.endsWith(THEME_PUSH_WILDCARD_GLOBS_FOR_FILES)
+                            ? fileGlob.slice(0, fileGlob.length - 2)
+                            : fileGlob;
+                    }
+                    for (const filePath of files) {
+                        filesRecords.push({
+                            actionData,
+                            actionKey,
+                            path: filePath,
+                            fileName: basename(filePath),
+                            fileGlob: processedFileGlob
+                        });
+                    }
+                }
+            }
+        }
+        return filesRecords;
+    }
     static _doesActionValueMatch(currentActionValue, valuesToMatch) {
         if (typeof valuesToMatch === 'string') {
             return currentActionValue === valuesToMatch || valuesToMatch === THEME_ALL_ACTIONS_NAME;

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

@@ -1,11 +1,11 @@
-import { AsyncFeatureInitializer, FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME } from '@dreamcommerce/star_core';
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { ThemeInitHttpApi } from './http/theme_init_http_api.js';
 import { ThemeInitApi } from './api/theme_init_api.js';
 import { ThemeInitService } from './service/theme_init_service.js';
 import { THEME_INIT_FEATURE_NAME } from './theme_init_constants.js';
-export class ThemeInitInitializer extends AsyncFeatureInitializer {
+export class ThemeInitInitializer extends SyncFeatureInitializer {
     static featureName = THEME_INIT_FEATURE_NAME;
-    async init() {
+    init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
         const service = new ThemeInitService({
             httpApi: new ThemeInitHttpApi(httpApi)

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

@@ -1,67 +1,59 @@
 import tmp from 'tmp-promise';
-import { THEME_ACTION_DATA_TYPE, THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { createZip } from '../../../../../utils/zip/create_zip_utils.js';
-import { basename, dirname, extname, join, looksLikeDirectory, toUnixPath } from '../../../../../utils/path_utils.js';
-import { createReadStream } from 'node:fs';
+import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
+import { join } from '../../../../../utils/path_utils.js';
 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 { 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 { 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 { formatJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { removeFile, writeJSONFile } from '../../../../../utils/fs/fs_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';
+import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
+import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemePushService {
-    #themePushHttpApi;
     #themeFetchApi;
-    constructor({ themePushHttpApi, themeFetchApi }) {
-        this.#themePushHttpApi = themePushHttpApi;
+    constructor({ themeFetchApi }) {
         this.#themeFetchApi = themeFetchApi;
     }
-    async push({ pushAction, filesStructure, credentials, executionContext, themeChecksums }) {
+    async push({ pushAction, credentials, filesStructure, executionContext, themeChecksums, 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 {
-            const { uploadData, localFiles } = await this._getActionDataForFilesToUpload({
-                pushAction,
-                filesStructure,
-                executionContext,
-                themeChecksums
+            //TODO to do api?
+            const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
+                themeRootDir,
+                themeAction: pushAction,
+                filesStructure
             });
-            if (uploadData.length) {
-                const { newFiles } = await this._uploadThemeFiles({
-                    filesToUpload: uploadData,
+            const filesToUpload = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenCreated(path)) || (await themeChecksums.hasThemeFileBeenModified(path)));
+            if (filesToUpload.length) {
+                const { localFileNameToUploaded } = await this._uploadThemeFiles({
+                    filesToUpload,
                     credentials,
-                    localFiles,
-                    themeRootDir
+                    themeRootDir,
+                    themeFilesUploadApi
                 });
-                await this._createAFilesListFile(themeRootDir, newFiles);
+                await this._createFilesList(themeRootDir, filesRecords, localFileNameToUploaded);
             }
             else {
-                await this._createAFilesListFile(themeRootDir, localFiles);
+                await this._createFilesList(themeRootDir, filesRecords);
             }
             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
-                }),
+            await new ThemeArchive(themeRootDir).createFullArchive({
                 dist: themeArchivePath,
-                credentials
+                actionValue: THEME_WILDCARD_ACTION_NAME,
+                actionType: THEME_ACTIONS_TYPES.push
             });
-            const { resources, modules } = await this._uploadThemeArchive({
+            const { resources, modules } = await themeFilesUploadApi.uploadArchive({
+                action: pushAction,
                 themeArchivePath,
-                credentials,
-                pushAction
+                credentials
             });
             if (modules)
                 await this._updateDataForNewCreatedModules({ modules, themeRootDir });
@@ -72,58 +64,24 @@ export class ThemePushService {
             await themeChecksums.updateAllChecksums();
         }
         finally {
-            await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
+            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
         }
     }
-    async _createThemeArchive({ themeRootDir, filesToArchive, dist, credentials }) {
+    async _uploadThemeFiles({ filesToUpload, themeRootDir, credentials, themeFilesUploadApi }) {
         try {
-            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);
-        }
-    }
-    async _uploadThemeArchive({ themeArchivePath, credentials, pushAction }) {
-        try {
-            const request = this.#themePushHttpApi.pushThemeData({
-                actionData: pushAction.data[THEME_WILDCARD_ACTION_NAME],
-                stream: createReadStream(themeArchivePath),
-                shopUrl: credentials.shopUrl
-            });
-            const response = await request.response;
-            if (response.status !== 200 || !response.data.isSuccess)
-                throw response;
-            return response.data;
-        }
-        catch (err) {
-            throw ThemePushErrorsFactory.createErrorWhileUploadingTheme(credentials.shopUrl, err.response.data.messages);
-        }
-    }
-    async _formatJsonFiles(themeRootDir, filesToUpload) {
-        await Promise.all(filesToUpload
-            .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, rejectedImageData } = await this._uploadFiles(filesToUpload, credentials);
-            const newFilesList = ThemeImagesUtils.updateOriginalFilenameToUploadedFilename(localFiles, uploadedImageData);
+            const { uploadedImageData, rejectedImageData } = await themeFilesUploadApi.uploadFiles(filesToUpload);
             if (uploadedImageData.length)
                 await ThemeImagesUtils.removeUploadedOriginalFiles(themeRootDir, uploadedImageData);
             if (rejectedImageData.length)
                 await this._removeUploadedThemeFiles(rejectedImageData, themeRootDir);
-            return { newFiles: newFilesList };
+            return {
+                localFileNameToUploaded: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
+                    return {
+                        ...acc,
+                        [originalFilename]: uploadedFilename ?? originalFilename
+                    };
+                }, {})
+            };
         }
         catch (err) {
             throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl, err);
@@ -132,92 +90,12 @@ export class ThemePushService {
     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,
-            stream: createReadStream(path),
-            shopUrl: credentials.shopUrl
-        })
-            .response.then((response) => {
-            uploadedImageData.push({
-                location: dirname(path),
-                originalFilename: basename(path),
-                uploadedFilename: response.data.imageId
-            });
-        })
-            .catch(() => {
-            rejectedImageData.push({
-                location: dirname(path),
-                originalFilename: basename(path)
-            });
-        })));
-        return {
-            uploadedImageData,
-            rejectedImageData
-        };
-    }
-    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 = ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
-                    actionType: THEME_ACTIONS_TYPES.push,
-                    actionValue: actionKey,
-                    filesStructure
-                });
-                for (const fileGlob of filesGlobs) {
-                    const files = await globs(fileGlob, {
-                        suppressErrors: true,
-                        onlyFiles: true,
-                        cwd: executionContext.themeRootDir
-                    });
-                    if (looksLikeDirectory(fileGlob)) {
-                        const processedFileGlob = fileGlob.endsWith(THEME_PUSH_WILDCARD_GLOBS_FOR_FILES)
-                            ? fileGlob.slice(0, fileGlob.length - 2)
-                            : fileGlob;
-                        localFiles[processedFileGlob] = files.length ? files.map((filePath) => basename(filePath)) : [];
-                    }
-                    else {
-                        localFiles[fileGlob] = files.length ? basename(files[0]) : null;
-                    }
-                    for (const filePath of files) {
-                        if ((await themeChecksums.hasThemeFileBeenCreated(filePath)) ||
-                            (await themeChecksums.hasThemeFileBeenModified(filePath))) {
-                            uploadData.push({
-                                actionData,
-                                actionKey,
-                                path: filePath
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            uploadData,
-            localFiles
-        };
-    }
     async _updateDataForNewCreatedModules({ modules, themeRootDir }) {
         for (const [moduleDirectoryName, metaData] of Object.entries(modules)) {
             await writeJSONFile(join(themeRootDir, MODULES_DIRECTORY_NAME, moduleDirectoryName, THEME_MODULE_SETTINGS_FILE_NAME), JSON.parse(metaData[THEME_MODULE_SETTINGS_FILE_NAME]));
         }
     }
-    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);
+    async _createFilesList(themeRootDir, filesRecords, localFileNameToUploaded = {}) {
+        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded));
     }
 }

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

@@ -1,15 +1,12 @@
-import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 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_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 service = new ThemePushService({
-            themePushHttpApi: new ThemePushHttpApi(httpApi),
             themeFetchApi: this.getApiSync(THEME_FETCH_API_NAME)
         });
         return {

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'
+        });
+    }
+}