@shoper/cli 0.1.0-9 → 0.2.1-0

package/build/theme/features/theme/delete/theme_delete_constants.js

@@ -0,0 +1,2 @@
+export const THEME_DELETE_FEATURE_NAME = 'ThemeDelete';
+export const THEME_DELETE_API_NAME = 'ThemeDeleteApi';

package/build/theme/features/theme/delete/theme_delete_initalizer.js

@@ -0,0 +1,20 @@
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { ThemeDeleteApi } from './api/theme_delete_api.js';
+import { ThemeDeleteService } from './service/theme_delete_service.js';
+import { ThemeDeleteHttpApi } from './http/theme_delete_http_api.js';
+import { THEME_DELETE_FEATURE_NAME } from './theme_delete_constants.js';
+export class ThemeDeleteInitializer extends SyncFeatureInitializer {
+    static featureName = THEME_DELETE_FEATURE_NAME;
+    init() {
+        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const service = new ThemeDeleteService(new ThemeDeleteHttpApi(httpApi));
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeDeleteApi(service)
+                }
+            ]
+        };
+    }
+}

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

@@ -4,17 +4,18 @@ import { downloadFile } from '../../../../../utils/download_file/download_file_u
 import { extractZip } from '../../../../../utils/zip/extract_zip_utils.js';
 import { join } from '../../../../../utils/path_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
-import { getResources, mapResourcesToTree } from '../../../../class/fetch_resources/fetch_resources_utils.js';
+import { getResources, mapResourcesToTree, removeOldResources } from '../../../../class/fetch_resources/fetch_resources_utils.js';
 import { FetchResources } from '../../../../class/fetch_resources/fetch_resources.js';
 import { jsonIndentTransform } from '../../../../../utils/stream_transforms/json_indent_transform.js';
-import { ThemeDirectoryUtils } from '../../directory/theme_directory_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 { THEME_FILES_LIST_FILE_NAME } from '../../push/theme_push_constants.js';
 import { JSON_FILE_INDENT } from '../../../../../cli/cli_constants.js';
-import { computeChecksumsFromSource } from '../../../../../utils/checksums/checksums_utils.js';
-import { ThemeChecksumsUtils } from '../../utils/checksums/theme_checksums_utils.js';
 import { createWriteStream } from 'node:fs';
-import { AppError } from '../../../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
+import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class ThemeFetchService {
     #themeHttpApi;
     #httpApi;
@@ -53,14 +54,17 @@ export class ThemeFetchService {
             });
         }
         await this._createGitIgnoreFile(themeDir);
-        const checksums = await computeChecksumsFromSource(themeDir);
-        await ThemeChecksumsUtils.createThemeChecksumsFiles(themeDir, checksums);
+        await this._updateMetadataFileWithWorkUrl(themeDir, credentials.shopUrl);
+        /**
+         * moze to nie powinno lezec tutaj :?
+         */
+        await new ThemeChecksums(themeDir).updateAllChecksums();
         return {
             name: basename
         };
     }
     async _updateFilesStructure(themeDir) {
-        const fileStructure = await ThemeDirectoryUtils.getThemeFilesStructure(themeDir);
+        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
         const checksumsFiles = [
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_FILE_NAME}`,
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME}`,
@@ -76,7 +80,15 @@ export class ThemeFetchService {
                 }
             };
         });
-        [THEME_FILES_LIST_FILE_NAME, '.gitignore'].forEach((fileName) => {
+        fileStructure[THEME_FILES_LIST_FILE_NAME] = {
+            permissions: {
+                canAdd: true,
+                canEdit: true,
+                canDelete: true
+            },
+            _links: { [THEME_ACTIONS_TYPES.push]: '*' }
+        };
+        ['.gitignore'].forEach((fileName) => {
             fileStructure[fileName] = {
                 permissions: {
                     canAdd: true,
@@ -85,9 +97,17 @@ export class ThemeFetchService {
                 }
             };
         });
-        await ThemeDirectoryUtils.writeThemeFilesStructure(themeDir, fileStructure);
+        await ThemeFilesStructureUtils.writeThemeFilesStructure(themeDir, fileStructure);
+    }
+    async _updateMetadataFileWithWorkUrl(themeDir, workUrl) {
+        const shopMetadata = await ThemeMetaDataUtils.getThemeMetadata(themeDir);
+        await ThemeMetaDataUtils.updateThemeMetadata(themeDir, {
+            ...shopMetadata,
+            workUrl
+        });
     }
     async fetchResources(shopUrl, dist, resources) {
+        await removeOldResources(dist, resources);
         const resourcesTree = mapResourcesToTree(resources);
         await Promise.all(Object.keys(resourcesTree).map((resource) => new FetchResources(this.#httpApi).fetchResources({
             resourcesPart: resourcesTree[resource],

package/build/theme/features/theme/info/theme_info_utils.js

@@ -0,0 +1,9 @@
+import { readJSONFile } from '../../../../utils/fs/fs_utils.js';
+import { join } from '../../../../utils/path_utils.js';
+export class ThemeInfoUtils {
+    static async getThemeName(themeDir) {
+        //TODO - wziasc z themeList a to wywalic
+        const themeDetails = await readJSONFile(join(themeDir, 'settings', 'details.json'));
+        return themeDetails.name ?? 'Storefront';
+    }
+}

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

@@ -3,8 +3,9 @@ import process from 'process';
 import tmp from 'tmp-promise';
 import { downloadFile } from '../../../../../utils/download_file/download_file_utils.js';
 import { extractZip } from '../../../../../utils/zip/extract_zip_utils.js';
-import { ThemeChecksumsUtils } from '../../utils/checksums/theme_checksums_utils.js';
-import { computeChecksumsFromSource } from '../../../../../utils/checksums/checksums_utils.js';
+import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
+import { ThemeInfoUtils } from '../../info/theme_info_utils.js';
+import { ThemeChecksums } from '../../../../../theme/class/checksums/theme_checksums.js';
 export class ThemeInitService {
     #httpApi;
     constructor({ httpApi }) {
@@ -22,7 +23,11 @@ export class ThemeInitService {
             source: join(tmpDir, filename),
             dist: distDir
         });
-        const checksums = await computeChecksumsFromSource(distDir);
-        await ThemeChecksumsUtils.createThemeChecksumsFiles(join(process.cwd(), basename), checksums);
+        new ThemeChecksums(distDir).updateAllChecksums();
+        const themeMetaData = await ThemeMetaDataUtils.getThemeMetadata(distDir);
+        return {
+            themeId: themeMetaData.themeId,
+            themeName: await ThemeInfoUtils.getThemeName(distDir)
+        };
     }
 }

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/merge/api/theme_merge_api.js

@@ -7,22 +7,10 @@ export class ThemeMergeApi extends FeatureApi {
         super();
         this.#service = service;
     }
-    hasThemeBeenModified(themeRootDir) {
-        return this.#service.hasThemeBeenModified(themeRootDir);
-    }
     getChangesBetweenThemes(theme1, theme2) {
         return this.#service.getChangesBetweenThemes(theme1, theme2);
     }
     applyChanges(fromTheme, toTheme, changes) {
         return this.#service.applyChanges(fromTheme, toTheme, changes);
     }
-    hasFileBeenCreated(path, executionContext) {
-        return this.#service.hasFileBeenCreated(path, executionContext);
-    }
-    hasFileBeenRemoved(path, executionContext) {
-        return this.#service.hasFileBeenRemoved(path, executionContext);
-    }
-    hasFileBeenModified(path, executionContext) {
-        return this.#service.hasFileBeenModified(path, executionContext);
-    }
 }

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

@@ -1,22 +1,21 @@
 import FSTree from 'fs-tree-diff';
-import { join } from '../../../../../utils/path_utils.js';
-import { computeChecksumsFromSource, computeFileChecksum } from '../../../../../utils/checksums/checksums_utils.js';
-import { copyFile, copyFileSync, fileExists } from '../../../../../utils/fs/fs_utils.js';
-import { ThemeChecksumsUtils } from '../../utils/checksums/theme_checksums_utils.js';
+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';
 export class ThemeMergeService {
     async applyChanges(fromTheme, toTheme, changes) {
         FSTree.applyPatch(fromTheme, toTheme, changes, {
             create(inputPath, outputPath) {
-                copyFile(inputPath, outputPath);
+                copyFileSync(inputPath, outputPath);
             },
             change(inputPath, outputPath) {
                 copyFileSync(inputPath, outputPath);
             }
         });
-        const checksums = await computeChecksumsFromSource(toTheme);
-        await ThemeChecksumsUtils.createThemeChecksumsFiles(toTheme, checksums);
+        new ThemeChecksums(toTheme).updateAllChecksums();
     }
     async getChangesBetweenThemes(theme1, theme2) {
         const theme1Tree = new FSTree({
@@ -25,32 +24,25 @@ export class ThemeMergeService {
         const theme2Tree = new FSTree({
             entries: walkSync.entries(theme2)
         });
-        const theme1Checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(theme1);
-        const theme2Checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(theme2);
+        const theme1Checksums = new ThemeChecksums(theme1);
+        const theme2Checksums = new ThemeChecksums(theme2);
+        const userDirectories = await this._getUserRootDirectories(theme2);
         return theme2Tree
             .calculatePatch(theme1Tree, (entryA, entryB) => {
             if (entryA.isDirectory() && entryB.isDirectory())
                 return true;
-            return theme1Checksums[entryA.relativePath] === theme2Checksums[entryB.relativePath];
+            return (theme1Checksums.getCurrentChecksumFromPathSync(entryA.relativePath) ===
+                theme2Checksums.getCurrentChecksumFromPathSync(entryB.relativePath));
         })
-            .filter(([, name]) => !name.startsWith(SHOPER_THEME_METADATA_DIR));
-    }
-    async hasThemeBeenModified(themeRootDir) {
-        const initialChecksums = await ThemeChecksumsUtils.getInitialChecksumsVerification(themeRootDir);
-        const currentChecksums = await ThemeChecksumsUtils.getThemeCurrentChecksumsVerification(themeRootDir);
-        return initialChecksums !== currentChecksums;
-    }
-    async hasFileBeenCreated(path, executionContext) {
-        const checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(executionContext.themeRootDir);
-        return checksums[path] === undefined && (await fileExists(join(executionContext.themeRootDir, path)));
-    }
-    async hasFileBeenRemoved(path, executionContext) {
-        const checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(executionContext.themeRootDir);
-        return !(await fileExists(join(executionContext.themeRootDir, path))) && !!checksums[path];
+            .filter(([_, name]) => {
+            return !name.startsWith(SHOPER_THEME_METADATA_DIR) && !userDirectories.some((userDir) => name.startsWith(userDir));
+        });
     }
-    async hasFileBeenModified(path, executionContext) {
-        const checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(executionContext.themeRootDir);
-        const currentChecksum = await computeFileChecksum(join(executionContext.themeRootDir, path));
-        return !!checksums[path] && checksums[path] !== currentChecksum;
+    async _getUserRootDirectories(themeDir) {
+        const filesStructure = await ThemeFilesStructureUtils.getThemeRootDirectories(themeDir);
+        return (await getAllDirectoriesNamesInside(themeDir, {
+            recursive: false,
+            hidden: true
+        })).filter((directory) => !filesStructure.includes(join(directory, platformSeparator)));
     }
 }

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

@@ -1,200 +1,101 @@
 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 { getFilesGlobsThatMatchesActionName } 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 '../../publish/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 { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
+import { removeFile, 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 { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
+import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemePushService {
-    #themePushHttpApi;
-    #themeMergeApi;
     #themeFetchApi;
-    constructor({ themePushHttpApi, themeMergeApi, themeFetchApi }) {
-        this.#themePushHttpApi = themePushHttpApi;
-        this.#themeMergeApi = themeMergeApi;
+    constructor({ themeFetchApi }) {
         this.#themeFetchApi = themeFetchApi;
     }
-    async push({ pushAction, filesStructure, credentials, executionContext }) {
+    async push({ pushAction, credentials, filesStructure, executionContext, themeChecksums, themeFilesUploadApi }) {
         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],
-                credentials,
-                localFiles,
-                themeRootDir: executionContext.themeRootDir
-            });
-        }
-        else {
-            await this._createAFilesListFile(executionContext.themeRootDir, localFiles);
-        }
-        const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
         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
+            //TODO to do api?
+            const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
+                themeRootDir,
+                themeAction: pushAction,
+                filesStructure
             });
-        }
-        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 {
-            const request = this.#themePushHttpApi.pushThemeData({
-                actionData: pushAction.data[THEME_WILDCARD_ACTION_NAME],
-                stream: createReadStream(themeArchivePath),
-                shopUrl: credentials.shopUrl
+            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,
+                    themeRootDir,
+                    themeFilesUploadApi
+                });
+                await this._createFilesList(themeRootDir, filesRecords, localFileNameToUploaded);
+            }
+            else {
+                await this._createFilesList(themeRootDir, filesRecords);
+            }
+            const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
+            await new ThemeArchive(themeRootDir).createFullArchive({
+                dist: themeArchivePath,
+                actionValue: THEME_WILDCARD_ACTION_NAME,
+                actionType: THEME_ACTIONS_TYPES.push
+            });
+            const { resources, modules } = await themeFilesUploadApi.uploadArchive({
+                action: pushAction,
+                themeArchivePath,
+                credentials
             });
-            const response = await request.response;
-            if (response.status !== 200 || !response.data.isSuccess)
-                throw response;
-            return response.data;
+            if (modules)
+                await this._updateDataForNewCreatedModules({ modules, themeRootDir });
+            if (resources) {
+                await removeOldResources(themeRootDir, resources);
+                await this.#themeFetchApi.fetchResources(credentials.shopUrl, themeRootDir, resources);
+            }
+            await themeChecksums.updateAllChecksums();
         }
-        catch (err) {
-            console.log('error', err.response.data.messages);
-            throw ThemePushErrorsFactory.createErrorWhileUploadingTheme(credentials.shopUrl, err.response.data.messages);
+        finally {
+            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
         }
     }
-    async _formatJsonFiles(themeRootDir, filesToUpload) {
-        await Promise.all(filesToUpload
-            .filter((path) => extname(path).toLowerCase() === '.json')
-            .map((jsonFile) => formatJSONFile(join(themeRootDir, jsonFile))));
-    }
-    async _uploadThemeFiles({ filesToUpload, themeRootDir, localFiles, credentials }) {
+    async _uploadThemeFiles({ filesToUpload, themeRootDir, credentials, themeFilesUploadApi }) {
         try {
-            const uploadedImageData = 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);
-            await this._createAFilesListFile(themeRootDir, newFilesList);
+            if (rejectedImageData.length)
+                await this._removeUploadedThemeFiles(rejectedImageData, themeRootDir);
+            return {
+                localFileNameToUploaded: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
+                    return {
+                        ...acc,
+                        [originalFilename]: uploadedFilename ?? originalFilename
+                    };
+                }, {})
+            };
         }
         catch (err) {
             throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl, err);
         }
     }
-    async _uploadFiles(uploadData, credentials) {
-        const uploadedImageData = [];
-        await Promise.all(uploadData.map(({ actionData, path }) => this.#themePushHttpApi
-            .pushThemeData({
-            actionData,
-            stream: createReadStream(path),
-            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
-            });
-        })));
-        return uploadedImageData;
-    }
-    async _getActionDataForFilesToUpload({ pushAction, filesStructure, executionContext }) {
-        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);
-                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 this.#themeMergeApi.hasFileBeenCreated(filePath, executionContext)) ||
-                            (await this.#themeMergeApi.hasFileBeenModified(filePath, executionContext))) {
-                            uploadData.push({
-                                actionData,
-                                actionKey,
-                                path: filePath
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            uploadData,
-            localFiles
-        };
+    async _removeUploadedThemeFiles(uploadedImageData, themeRootDir) {
+        await Promise.all(uploadedImageData.map(({ location, originalFilename }) => removeFile(join(themeRootDir, location, originalFilename))));
     }
     async _updateDataForNewCreatedModules({ modules, themeRootDir }) {
         for (const [moduleDirectoryName, metaData] of Object.entries(modules)) {
             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, [path, value]) => {
-            const unixPath = toUnixPath(path);
-            const finalPath = looksLikeDirectory(path) ? `${unixPath}/` : 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_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

@@ -1,18 +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_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();
+    }
+}