@shoper/cli 0.8.1-3 → 0.8.1-7

package/build/theme/commands/watch/theme_watch_utils.js

@@ -0,0 +1,32 @@
+import { COMMAND_PREFIX, WATCH_COMMANDS_NAMES } from './theme_watch_constants.js';
+import { APP_LOGS_TYPES } from '../../../cli/utilities/features/logger/logs/app_logs_constants.js';
+import { ThemeError } from '../ui/theme_error.js';
+import React from 'react';
+import chalk from 'chalk';
+import { CSS_TEXT_COLORS } from '../../../ui/color_constants.js';
+export class ThemeWatchUtils {
+    static mapAppLogToUiMessage(log) {
+        switch (log.level) {
+            case APP_LOGS_TYPES.success:
+                return this._mapSuccessLogToUiMessage(log);
+            case APP_LOGS_TYPES.info:
+                return this._mapInfoLogToUiMessage(log);
+            case APP_LOGS_TYPES.error:
+                return this._mapErrorLogToUiMessage(log);
+            default:
+                return log.message;
+        }
+    }
+    static _mapInfoLogToUiMessage(log) {
+        if (log.message === 'Browser closed') {
+            return `Browser closed. If you want to open it again, use the ${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.open} command or execute again "shoper theme watch --open".`;
+        }
+        return log.message;
+    }
+    static _mapErrorLogToUiMessage(log) {
+        return React.createElement(ThemeError, { err: log });
+    }
+    static _mapSuccessLogToUiMessage(log) {
+        return chalk.hex(CSS_TEXT_COLORS.success)(log.message);
+    }
+}

package/build/theme/commands/watch/theme_watching_info.js

@@ -0,0 +1,14 @@
+import { Info } from '../../../ui/message_box/info.js';
+import React from 'react';
+import { Text } from '../../../ui/text.js';
+import { CSS_COLOR_TOKENS_VALUES } from '../../../ui/color_constants.js';
+import { COMMAND_PREFIX, WATCH_COMMANDS_NAMES } from './theme_watch_constants.js';
+export const ThemeWatchingInfo = ({ themeId, withPreview }) => {
+    return (React.createElement(Info, { header: `Watching theme (ID: ${themeId}) files for changes... ` },
+        React.createElement(Text, null, "Any modifications will be reflected in real-time."),
+        withPreview ? React.createElement(Text, null, "Live preview opened in your browser.") : null,
+        React.createElement(Text, { color: CSS_COLOR_TOKENS_VALUES.theme4 },
+            "(Press Ctrl+C or type ",
+            `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.quit}`,
+            " to stop watching)")));
+};

package/build/theme/commands/watch/watch.js

@@ -0,0 +1,55 @@
+import { ThemeWatchingInfo } from './theme_watching_info.js';
+import { Box } from '../../../ui/box.js';
+import React, { useEffect } from 'react';
+import { CommandInput } from '../../../ui/command_input/command_input.js';
+import { useApp } from 'ink';
+import { COMMAND_PREFIX, MAX_WATCH_LOGS, WATCH_COMMANDS, WATCH_COMMANDS_NAMES } from './theme_watch_constants.js';
+import { useLogs } from '../../../ui/logs/use_logs.js';
+import { LogsList } from '../../../ui/logs/logs_list.js';
+import { ThemeWatchUtils } from './theme_watch_utils.js';
+export const Watch = ({ executionContext, credentials, openBrowser, themeChecksums, themeFilesUploadApi, filesStructure, action, themeWatchApi }) => {
+    const { exit } = useApp();
+    const { logs, addLog, clearLogs } = useLogs(MAX_WATCH_LOGS);
+    useEffect(() => {
+        themeWatchApi.watchTheme({
+            themeChecksums,
+            executionContext,
+            credentials,
+            themeFilesUploadApi,
+            filesStructure,
+            action,
+            openBrowser,
+            onMessage: (log) => {
+                addLog(ThemeWatchUtils.mapAppLogToUiMessage(log));
+            }
+        });
+        return () => {
+            themeWatchApi.stopWatching();
+        };
+    }, []);
+    const handleCommandSubmit = async (value) => {
+        const command = value.trim();
+        addLog(`> ${command}`);
+        switch (command) {
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.open}`: {
+                await themeWatchApi.ensureBrowserTabOpen();
+                break;
+            }
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.quit}`: {
+                await themeWatchApi.stopWatching();
+                exit();
+                break;
+            }
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.clear}`: {
+                clearLogs();
+                break;
+            }
+            default:
+                addLog(`Unknown command: ${command}`);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(ThemeWatchingInfo, { withPreview: openBrowser, themeId: executionContext.themeId }),
+        React.createElement(LogsList, { logs: logs }),
+        React.createElement(CommandInput, { commands: WATCH_COMMANDS, onSubmit: handleCommandSubmit })));
+};

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

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

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

@@ -3,9 +3,10 @@ import { basename, looksLikeDirectory, toUnixPath } from '../../../../utils/path
 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';
-import { filterFiles, loadShoperIgnore } from '../../../utils/shoperignore/shoperignore_utils.js';
+import micromatch from 'micromatch';
+import difference from 'lodash/difference.js';
 export class ThemeActionsUtils {
-    static getFilesGlobsThatMatchesActionName({ filesStructure, actionValue, actionType }) {
+    static getFilesGlobsThatMatchesAction({ filesStructure, actionValue, actionType }) {
         return Object.entries(filesStructure).reduce((acc, [filePath, fileStructureItem]) => {
             if (fileStructureItem._links?.[actionType] && this._doesActionValueMatch(fileStructureItem._links[actionType], actionValue)) {
                 const normalizedPath = this._normalizeFileGlob(toUnixPath(filePath));
@@ -14,13 +15,32 @@ export class ThemeActionsUtils {
             return acc;
         }, []);
     }
-    static async getFilesRecordsFromActionData({ themeRootDir, themeAction, filesStructure }) {
+    static async getFilesThatMatchesAction({ actionType, actionValue, filesStructure, rootDir }) {
+        return await globs(ThemeActionsUtils.getFilesGlobsThatMatchesAction({
+            actionType,
+            actionValue,
+            filesStructure
+        }), {
+            suppressErrors: true,
+            onlyFiles: true,
+            cwd: rootDir
+        });
+    }
+    static async getDeletedFilesThatMatchesAction({ actionType, actionValue, themeChecksums, filesStructure }) {
+        const deletedFiles = await themeChecksums.getDeletedFiles();
+        const globs = ThemeActionsUtils.getFilesGlobsThatMatchesAction({
+            actionType,
+            actionValue,
+            filesStructure
+        });
+        return deletedFiles.filter((path) => !looksLikeDirectory(path) && micromatch.isMatch(path, globs));
+    }
+    static async getFilesRecordsFromActionData({ themeRootDir, themeAction, filesStructure, themeChecksums }) {
         const filesRecords = [];
-        // Load the ignore instance once before the loops to avoid reading .shoperignore multiple times
-        const ignoreInstance = await loadShoperIgnore(themeRootDir);
+        const initialChecksums = await themeChecksums.getInitialChecksums();
         for (const [actionKey, actionData] of Object.entries(themeAction.data)) {
             if (actionData.type === THEME_ACTION_DATA_TYPE.file) {
-                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesAction({
                     //TODO remove when backend fixed
                     actionType: 'push',
                     // actionType: themeAction.actionType,
@@ -28,25 +48,27 @@ export class ThemeActionsUtils {
                     filesStructure
                 });
                 for (const fileGlob of filesGlobs) {
+                    const checksumMatchedFiles = micromatch(Object.keys(initialChecksums), [fileGlob]);
                     const files = await globs(fileGlob, {
                         suppressErrors: true,
                         onlyFiles: true,
                         cwd: themeRootDir
                     });
-                    const filteredFiles = await filterFiles(files, themeRootDir, ignoreInstance);
                     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 filteredFiles) {
+                    const deletedFiles = difference(checksumMatchedFiles, files);
+                    for (const filePath of [...files, ...deletedFiles]) {
                         filesRecords.push({
                             actionData,
                             actionKey,
                             path: filePath,
                             fileName: basename(filePath),
-                            fileGlob: processedFileGlob
+                            fileGlob: processedFileGlob,
+                            state: await themeChecksums.getFileState(filePath)
                         });
                     }
                 }
@@ -54,6 +76,41 @@ export class ThemeActionsUtils {
         }
         return filesRecords;
     }
+    // static async getFilesRecordsFromFiles({
+    //     files,
+    //     themeRootDir,
+    //     themeAction,
+    //     filesStructure,
+    //     themeChecksums
+    // }: {
+    //     files: string[];
+    //     themeRootDir: string;
+    //     themeAction: TThemeAction;
+    //     filesStructure: TThemeFilesStructure;
+    //     themeChecksums: ThemeChecksums;
+    // }): Promise<TFileRecord[]> {
+    //     const fileRecords: TFileRecord[] = [];
+    //
+    //     for (const file of files) {
+    //         const state = await themeChecksums.getFileState(file);
+    //
+    //         if (state) {
+    //             fileRecords.push({
+    //                 path: file,
+    //                 state,
+    //                 action: themeAction
+    //             });
+    //         }
+    //     }
+    //
+    //     return fileRecords;
+    // }
+    static _normalizeFileGlob(fileGlob) {
+        if (fileGlob.endsWith('/')) {
+            return `${fileGlob}${THEME_PUSH_WILDCARD_GLOBS_FOR_FILES}`;
+        }
+        return fileGlob;
+    }
     static _doesActionValueMatch(currentActionValue, valuesToMatch) {
         if (typeof valuesToMatch === 'string') {
             return currentActionValue === valuesToMatch || valuesToMatch === THEME_ALL_ACTIONS_NAME;
@@ -63,10 +120,4 @@ export class ThemeActionsUtils {
         }
         return false;
     }
-    static _normalizeFileGlob(fileGlob) {
-        if (fileGlob.endsWith('/')) {
-            return `${fileGlob}${THEME_PUSH_WILDCARD_GLOBS_FOR_FILES}`;
-        }
-        return fileGlob;
-    }
 }

package/build/theme/features/theme/fetch/service/theme_fetch_service.js

@@ -8,9 +8,9 @@ import { FetchResources } from '../../../../class/fetch_resources/fetch_resource
 import { jsonIndentTransform } from '../../../../../utils/stream_transforms/json_indent_transform.js';
 import { JSON_FILE_INDENT } from '../../../../../cli/cli_constants.js';
 import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeFetchService {
     #themeHttpApi;
     #httpApi;
@@ -55,7 +55,7 @@ export class ThemeFetchService {
         }
         try {
             this.#loggerApi.debug('Updating theme files structure.');
-            await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
+            await ThemeFilesUtils.updateFilesStructure(themeDir);
         }
         catch (error) {
             throw new AppError({
@@ -66,8 +66,6 @@ export class ThemeFetchService {
         }
         this.#loggerApi.debug('Creating .gitignore file.');
         await ThemeMetaDataUtils.createGitIgnoreFile(themeDir);
-        this.#loggerApi.debug('Creating .shoperignore file.');
-        await ThemeMetaDataUtils.createShoperIgnoreFile(themeDir);
         this.#loggerApi.debug('Updating metadata file.');
         await ThemeMetaDataUtils.updateMetadataFileWithWorkUrl(themeDir, credentials.shopUrl);
         this.#loggerApi.debug('Updating theme checksums');

package/build/theme/features/theme/init/service/theme_init_service.js

@@ -6,8 +6,8 @@ import { extractZip } from '../../../../../utils/zip/extract_zip_utils.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
 import { ThemeInfoUtils } from '../../info/theme_info_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeInitService {
     #httpApi;
     #loggerApi;
@@ -41,7 +41,7 @@ export class ThemeInitService {
         this.#loggerApi.info('Theme archive extracted.');
         try {
             this.#loggerApi.debug('Updating theme files structure.');
-            await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
+            await ThemeFilesUtils.updateFilesStructure(themeDir);
         }
         catch (err) {
             throw new AppError({
@@ -52,8 +52,6 @@ export class ThemeInitService {
         }
         this.#loggerApi.debug('Creating .gitignore file.');
         await ThemeMetaDataUtils.createGitIgnoreFile(themeDir);
-        this.#loggerApi.debug('Creating .shoperignore file.');
-        await ThemeMetaDataUtils.createShoperIgnoreFile(themeDir);
         this.#loggerApi.debug('Updating metadata file.');
         await ThemeMetaDataUtils.updateMetadataFileWithWorkUrl(themeDir, credentials.shopUrl);
         this.#loggerApi.debug('Updating theme checksums.');

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

@@ -2,9 +2,9 @@ import FSTree from 'fs-tree-diff';
 import { copyFileSync, getAllDirectoriesNamesInside } from '../../../../../utils/fs/fs_utils.js';
 import walkSync from 'walk-sync';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { join, platformSeparator } from '../../../../../utils/path_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeMergeService {
     #loggerApi;
     constructor({ loggerApi }) {
@@ -73,7 +73,7 @@ export class ThemeMergeService {
         return patch;
     }
     async _getUserRootDirectories(themeDir) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeRootDirectories(themeDir);
+        const filesStructure = await ThemeFilesUtils.getThemeRootDirectories(themeDir);
         return (await getAllDirectoriesNamesInside(themeDir, {
             recursive: false,
             hidden: true

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

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

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,12 +1,11 @@
 import globs from 'fast-glob';
 import { AppError } from '../../../../cli/utilities/features/logger/logs/app_error.js';
 import { toUnixPath } from '../../../../utils/path_utils.js';
-import { ThemeFilesStructureUtils } from '../utils/files_structure/theme_files_structure_utils.js';
-import { filterFiles } from '../../../utils/shoperignore/shoperignore_utils.js';
+import { ThemeFilesUtils } from '../utils/files/theme_files_utils.js';
 import { THEME_PUSH_WILDCARD_GLOBS_FOR_FILES } from './service/theme_push_service_constants.js';
 export class ThemePushUtils {
     static async getAllFilesThatAreSendToRemote(themeDir) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
+        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
         if (!filesStructure)
             throw new AppError({
                 message: `Files structure not found in theme directory: ${themeDir}`,
@@ -18,13 +17,11 @@ export class ThemePushUtils {
             .filter((path) => path !== '*');
         //need unix styles globs
         filesToArchive.push('styles/src/**/*');
-        const allFiles = await globs(filesToArchive, {
+        return await globs(filesToArchive, {
+            suppressErrors: true,
             onlyFiles: true,
-            cwd: themeDir,
-            suppressErrors: true
-        });
-        const filteredFiles = await filterFiles(allFiles, themeDir);
-        return filteredFiles.sort();
+            cwd: themeDir
+        }).then((files) => files.sort());
     }
     static _normalizeFileGlob(fileGlob) {
         if (fileGlob.endsWith('/')) {

package/build/theme/features/theme/utils/archive/theme_archive_utils.js

@@ -0,0 +1,26 @@
+import { createZip } from '../../../../../utils/zip/create_zip_utils.js';
+import { extname, join } from '../../../../../utils/path_utils.js';
+import { formatJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { ThemeArchiveErrorsFactory } from './theme_archive_utils_errors_factory.js';
+export class ThemeArchiveUtils {
+    static async create({ dist, files, rootDir, logger }) {
+        try {
+            // TODO spradzić czy potrzebne, ew po formatowanu sprawdzic czy plik sie zmienił jak nie to nie podmieniac contentu zformatowanego
+            // await this._formatJsonFiles(rootDir, files);
+            return createZip({
+                files,
+                baseDir: rootDir,
+                logger,
+                dist
+            });
+        }
+        catch (err) {
+            throw ThemeArchiveErrorsFactory.createErrorWhileCreatingThemeArchive(err);
+        }
+    }
+    static async _formatJsonFiles(themeRootDir, filesToUpload) {
+        await Promise.all(filesToUpload
+            .filter((path) => extname(path).toLowerCase() === '.json')
+            .map((jsonFile) => formatJSONFile(join(themeRootDir, jsonFile))));
+    }
+}

package/build/theme/{class/archive/theme_archive_errors_factory.js → features/theme/utils/archive/theme_archive_utils_errors_factory.js}

@@ -1,4 +1,4 @@
-import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
 export class ThemeArchiveErrorsFactory {
     static createErrorWhileCreatingThemeArchive(error) {
         return new AppError({

package/build/theme/features/theme/utils/files/them_files_constants.js

@@ -0,0 +1 @@
+export const FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS = 'customModulesIdsToKeep';