@shoper/cli 0.1.0-7 → 0.1.0-9

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

@@ -0,0 +1,200 @@
+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 { 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 { 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 { MODULES_DIRECTORY_NAME } from '../../theme_constants.js';
+export class ThemePushService {
+    #themePushHttpApi;
+    #themeMergeApi;
+    #themeFetchApi;
+    constructor({ themePushHttpApi, themeMergeApi, themeFetchApi }) {
+        this.#themePushHttpApi = themePushHttpApi;
+        this.#themeMergeApi = themeMergeApi;
+        this.#themeFetchApi = themeFetchApi;
+    }
+    async push({ pushAction, filesStructure, credentials, executionContext }) {
+        const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        if (await this.#themeMergeApi.hasFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(executionContext.themeRootDir), executionContext))
+            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
+            });
+        }
+        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 response = await request.response;
+            if (response.status !== 200 || !response.data.isSuccess)
+                throw response;
+            return response.data;
+        }
+        catch (err) {
+            console.log('error', err.response.data.messages);
+            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))));
+    }
+    async _uploadThemeFiles({ filesToUpload, themeRootDir, localFiles, credentials }) {
+        try {
+            const uploadedImageData = await this._uploadFiles(filesToUpload, credentials);
+            const newFilesList = ThemeImagesUtils.updateOriginalFilenameToUploadedFilename(localFiles, uploadedImageData);
+            if (uploadedImageData.length)
+                await ThemeImagesUtils.removeUploadedOriginalFiles(themeRootDir, uploadedImageData);
+            await this._createAFilesListFile(themeRootDir, newFilesList);
+        }
+        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 _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);
+    }
+}

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

@@ -0,0 +1 @@
+export const THEME_PUSH_WILDCARD_GLOBS_FOR_FILES = '*';

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

@@ -0,0 +1,4 @@
+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';

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

@@ -0,0 +1,41 @@
+import { AppError } from '../../../../cli/class/errors/app_error/app_error.js';
+export class ThemePushErrorsFactory {
+    static createErrorWhileUploadingThemeFiles(shopUrl, messages) {
+        return new AppError({
+            code: 'theme.push.error_uploading_theme_files',
+            message: `Error while uploading theme files to shop "${shopUrl}"`,
+            level: 'error',
+            details: messages
+        });
+    }
+    static createErrorWhileCreatingThemeArchive(shopUrl, error) {
+        return new AppError({
+            code: 'theme.push.error_creating_theme_archive',
+            message: `Error while creating theme archive for shop "${shopUrl}"`,
+            level: 'error',
+            stack: error.stack
+        });
+    }
+    static createErrorWhilePushingUnpublishedThemeWithSkinstoreData(shopUrl) {
+        return new AppError({
+            code: 'theme.push.error_pushing_unpublished_theme_with_skinstore_data',
+            message: `Error while pushing unpublished theme with skinstore data to shop "${shopUrl}"`,
+            level: 'error'
+        });
+    }
+    static createGeneralError() {
+        return new AppError({
+            code: 'theme.push.general_error',
+            message: 'Something went wrong while pushing theme, try again later. ',
+            level: 'error'
+        });
+    }
+    static createErrorWhileUploadingTheme(shopUrl, messages) {
+        return new AppError({
+            code: 'theme.push.error_uploading_theme',
+            message: `Error while uploading theme to shop "${shopUrl}"`,
+            level: 'error',
+            details: messages
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, 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 {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemePushApi(service)
+                }
+            ]
+        };
+    }
+}

package/build/theme/features/theme/theme_constants.js

@@ -0,0 +1,6 @@
+export const THEME_CURRENT_CHECKSUMS_FILE_NAME = 'current_checksum.json';
+export const THEME_INITIAL_CHECKSUMS_FILE_NAME = 'initial_checksum.json';
+export const THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME = 'current_checksums_verify.json';
+export const THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME = 'initial_checksums_verify.json';
+export const THEME_FILES_STRUCTURE_FILE_NAME = 'filesStructure.json';
+export const MODULES_DIRECTORY_NAME = 'modules';

package/build/theme/features/theme/utils/checksums/theme_checksums_error_factory.js

@@ -0,0 +1,10 @@
+import { AppError } from '../../../../../cli/class/errors/app_error/app_error.js';
+export class ThemeChecksumsErrorFactory {
+    static createThemeChecksumError(stack) {
+        return new AppError({
+            message: 'Theme checksum error',
+            code: 'theme_checksum_error',
+            stack
+        });
+    }
+}

package/build/theme/features/theme/utils/checksums/theme_checksums_utils.js

@@ -0,0 +1,94 @@
+import { join } from '../../../../../utils/path_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 { createWriteStream } from 'fs';
+import { copyFile, readJSONFile, removeFile } from '../../../../../utils/fs/fs_utils.js';
+import { ThemeChecksumsErrorFactory } from './theme_checksums_error_factory.js';
+import { ThemeDirectoryUtils } from '../../directory/theme_directory_utils.js';
+import { computeFileChecksum } from '../../../../../utils/checksums/checksums_utils.js';
+import { JSON_FILE_INDENT } from '../../../../../cli/cli_constants.js';
+export class ThemeChecksumsUtils {
+    static getCurrentThemeChecksumsFilePath(themeDir) {
+        return join(ThemeDirectoryUtils.getThemeMetaDataDirPath(themeDir), THEME_CURRENT_CHECKSUMS_FILE_NAME);
+    }
+    static getInitialThemeChecksumsFilePath(themeDir) {
+        return join(ThemeDirectoryUtils.getThemeMetaDataDirPath(themeDir), THEME_INITIAL_CHECKSUMS_FILE_NAME);
+    }
+    static getCurrentThemeChecksumsVerificationFilePath(themeDir) {
+        return join(ThemeDirectoryUtils.getThemeMetaDataDirPath(themeDir), THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME);
+    }
+    static getInitialThemeChecksumsVerificationFilePath(themeDir) {
+        return join(ThemeDirectoryUtils.getThemeMetaDataDirPath(themeDir), THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME);
+    }
+    static async createThemeChecksumsFiles(themeDir, checksums) {
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.getCurrentThemeChecksumsFilePath(themeDir);
+            const initialChecksumFilePath = this.getInitialThemeChecksumsFilePath(themeDir);
+            const checksumStream = createWriteStream(initialChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const initialChecksumVerifyFilePath = this.getInitialThemeChecksumsVerificationFilePath(themeDir);
+                const currentChecksumVerifyFilePath = this.getCurrentThemeChecksumsVerificationFilePath(themeDir);
+                await this.createThemeChecksumVerifyFile(initialChecksumFilePath, initialChecksumVerifyFilePath);
+                await copyFile(initialChecksumFilePath, currentChecksumFilePath);
+                await copyFile(initialChecksumVerifyFilePath, currentChecksumVerifyFilePath);
+                resolve();
+            })
+                .on('error', async (err) => {
+                await removeFile(initialChecksumFilePath, { force: true });
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+            });
+        });
+    }
+    static async createThemeCurrentChecksumsFile(themeDir, checksums) {
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.getCurrentThemeChecksumsFilePath(themeDir);
+            const checksumStream = createWriteStream(currentChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const currentChecksumVerifyFilePath = this.getCurrentThemeChecksumsVerificationFilePath(themeDir);
+                await this.createThemeChecksumVerifyFile(currentChecksumFilePath, currentChecksumVerifyFilePath);
+                resolve();
+            })
+                .on('error', async (err) => {
+                await removeFile(currentChecksumFilePath, { force: true });
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+            });
+        });
+    }
+    static async createThemeChecksumVerifyFile(checksumFilePath, checksumVerifyFullPath) {
+        const checksumVerifyStream = createWriteStream(checksumVerifyFullPath);
+        const checksumVerify = await computeFileChecksum(checksumFilePath);
+        checksumVerifyStream
+            .on('error', async (err) => {
+            await removeFile(checksumFilePath, { force: true });
+            throw ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack);
+        })
+            .write(JSON.stringify(checksumVerify));
+        checksumVerifyStream.end();
+    }
+    static async getThemeCurrentChecksums(themeDir) {
+        const checksumFilePath = this.getCurrentThemeChecksumsFilePath(themeDir);
+        return await readJSONFile(checksumFilePath);
+    }
+    static async getThemeInitialChecksums(themeDir) {
+        const checksumFilePath = this.getInitialThemeChecksumsFilePath(themeDir);
+        return await readJSONFile(checksumFilePath);
+    }
+    static async verifyThemeChecksums(themeDir) {
+        const initialChecksumFilePath = this.getInitialThemeChecksumsFilePath(themeDir);
+        const initialChecksumVerifyFilePath = this.getInitialThemeChecksumsVerificationFilePath(themeDir);
+        const initialChecksum = await computeFileChecksum(initialChecksumFilePath);
+        const initialChecksumVerify = await readJSONFile(initialChecksumVerifyFilePath);
+        return initialChecksum === initialChecksumVerify;
+    }
+    static async getThemeCurrentChecksumsVerification(themeDir) {
+        return await readJSONFile(this.getCurrentThemeChecksumsVerificationFilePath(themeDir));
+    }
+    static async getInitialChecksumsVerification(themeDir) {
+        return await readJSONFile(this.getInitialThemeChecksumsVerificationFilePath(themeDir));
+    }
+}

package/build/theme/features/theme/utils/directories/theme_resources_with_id_directory_utils.js

@@ -0,0 +1,80 @@
+import FSTree from 'fs-tree-diff';
+import walkSync from 'walk-sync';
+import { THEME_FILES_OPERATIONS } from '../../merge/theme_merge_constants.js';
+import { fileExists, readJSONFile, renameFile } from '../../../../../utils/fs/fs_utils.js';
+import { join } from '../../../../../utils/path_utils.js';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import { computeChecksumsFromSource } from '../../../../../utils/checksums/checksums_utils.js';
+import { ThemeChecksumsUtils } from '../checksums/theme_checksums_utils.js';
+export class ThemeResourcesWithIdDirectoryUtils {
+    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, localThemeDir, remoteResourcesDir, remoteThemeDir) {
+        const localThemeTree = new FSTree({
+            entries: walkSync.entries(localResourcesDir, {
+                globs: ['*/'],
+                ignore: ['*/**']
+            })
+        });
+        const remoteThemeTree = new FSTree({
+            entries: walkSync.entries(remoteResourcesDir, {
+                globs: ['*/'],
+                ignore: ['*/**']
+            })
+        });
+        const localResourceIdToPathMap = await this._getFilePathToResourceIdMap(localThemeTree.entries);
+        const remoteResourceIdToPathMap = await this._getResourceIdToFilePathMap(remoteThemeTree.entries);
+        const directoriesCreatedLocally = localThemeTree
+            .calculatePatch(remoteThemeTree)
+            .filter(([operation]) => operation === THEME_FILES_OPERATIONS.rmdir);
+        for (const operation of directoriesCreatedLocally) {
+            const resourceDirectoryRelativePath = operation[1];
+            if (!resourceDirectoryRelativePath)
+                continue;
+            const resourceId = localResourceIdToPathMap.get(resourceDirectoryRelativePath);
+            if (!resourceId)
+                continue;
+            const remoteResourceDirectoryRelativePath = remoteResourceIdToPathMap.get(resourceId);
+            if (!remoteResourceDirectoryRelativePath)
+                continue;
+            await renameFile(join(remoteResourcesDir, remoteResourceDirectoryRelativePath), join(remoteResourcesDir, resourceDirectoryRelativePath));
+            const resultPath = join(remoteResourcesDir, resourceDirectoryRelativePath);
+            const stat = fs.lstatSync(resultPath);
+            console.log('stat', stat.isDirectory());
+            if (stat.isSymbolicLink()) {
+                console.warn(`[WARN] Renamed path became a symlink: ${resultPath}`);
+                console.warn(`Points to: ${await fsPromises.readlink(resultPath)}`);
+            }
+            /**
+             * If these become performance bottlenecks, we can consider computing checksums only for the changed directories.
+             */
+            const checksums = await computeChecksumsFromSource(remoteThemeDir);
+            await ThemeChecksumsUtils.createThemeChecksumsFiles(remoteThemeDir, checksums);
+        }
+    }
+    static async _getResourceIdToFilePathMap(entries) {
+        const map = new Map();
+        for (const entry of entries) {
+            const settingsPaths = join(entry.basePath, entry.relativePath, 'settings.json');
+            if (!(await fileExists(settingsPaths)))
+                continue;
+            const settings = await readJSONFile(settingsPaths);
+            if (settings.id === undefined)
+                continue;
+            map.set(settings.id, entry.relativePath);
+        }
+        return map;
+    }
+    static async _getFilePathToResourceIdMap(entries) {
+        const map = new Map();
+        for (const entry of entries) {
+            const settingsPaths = join(entry.basePath, entry.relativePath, 'settings.json');
+            if (!(await fileExists(settingsPaths)))
+                continue;
+            const settings = await readJSONFile(settingsPaths);
+            if (settings.id === undefined)
+                continue;
+            map.set(entry.relativePath, settings.id);
+        }
+        return map;
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { THEMES_LIST_API_NAME } from '../themes_list_constants.js';
+export class ThemesListApi extends FeatureApi {
+    moduleName = THEMES_LIST_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    async getThemes(credentials) {
+        return this.#service.getThemes(credentials);
+    }
+}

package/build/theme/features/themes/{http/shoper_themes_http_api.js → list/http/themes_list_http_api.js}

@@ -1,5 +1,5 @@
 import { REQUEST_TYPES } from '@dreamcommerce/star_core';
-export class ShoperThemesHttpApi {
+export class ThemesListHttpApi {
     #httpApi;
     constructor(httpApi) {
         this.#httpApi = httpApi;
@@ -10,7 +10,8 @@ export class ShoperThemesHttpApi {
             method: REQUEST_TYPES.get,
             sanitizeOptions: {
                 disable: true
-            }
+            },
+            isPrivate: true
         });
     }
 }

package/build/theme/features/themes/{model/theme_metadata.js → list/model/theme_list_metadata.js}

@@ -4,11 +4,13 @@ export class ThemeMetaData {
     description;
     isActive;
     canEdit;
-    constructor({ canEdit, skinId, description, isActive, title }) {
+    links;
+    constructor({ canEdit, skinId, description, isActive, title, links }) {
         this.skinId = skinId;
         this.title = title;
         this.description = description;
         this.isActive = isActive;
         this.canEdit = canEdit;
+        this.links = links;
     }
 }

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

@@ -0,0 +1,37 @@
+import { ThemeMetaData } from '../model/theme_list_metadata.js';
+import { STATUS_CODES } from '@dreamcommerce/star_core';
+import { HttpErrorsFactory } from '../../../../../cli/class/errors/http_errors_factory.js';
+import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
+export class ThemesListService {
+    httpApi;
+    constructor(httpApi) {
+        this.httpApi = httpApi;
+    }
+    async getThemes({ shopUrl }) {
+        try {
+            const { response } = this.httpApi.getThemes(shopUrl);
+            const { data, status } = await response;
+            if (status !== STATUS_CODES.ok)
+                return;
+            //TODO baseHttpApi + model mapper
+            return data.map(({ _links, ...rest }) => new ThemeMetaData({
+                ...rest,
+                links: _links
+            }));
+        }
+        catch (err) {
+            switch (err.response?.status) {
+                case 403:
+                    throw HttpErrorsFactory.createForbiddenError();
+                case 401:
+                    throw HttpErrorsFactory.createUnauthorizedError();
+                case 404:
+                    throw HttpErrorsFactory.createNotFoundError();
+                default:
+                    if (err.response?.status !== 200) {
+                        throw DownloadFileErrorsFactory.downloadError(err.response.status);
+                    }
+            }
+        }
+    }
+}

package/build/theme/features/themes/list/themes_list_constants.js

@@ -0,0 +1,2 @@
+export const THEMES_LIST_FEATURE_NAME = 'ThemesList';
+export const THEMES_LIST_API_NAME = 'ThemesListApi';

package/build/theme/features/themes/list/themes_list_initializer.js

@@ -0,0 +1,20 @@
+import { ThemesListService } from './services/themes_list_service.js';
+import { ThemesListApi } from './api/themes_list_api.js';
+import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { THEMES_LIST_FEATURE_NAME } from './themes_list_constants.js';
+import { ThemesListHttpApi } from './http/themes_list_http_api.js';
+export class ThemesListInitializer extends SyncFeatureInitializer {
+    static featureName = THEMES_LIST_FEATURE_NAME;
+    init() {
+        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
+        const service = new ThemesListService(new ThemesListHttpApi(httpApi));
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemesListApi(service)
+                }
+            ]
+        };
+    }
+}

package/build/theme/hooks/ensure_theme_meta_data_untouched.js

@@ -0,0 +1,17 @@
+import { useApi } from '../../cli/hooks/ensure_cli_initialized_hook.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import { ThemeDirectoryUtils } from '../features/theme/directory/theme_directory_utils.js';
+const ensureThemeMetaDataUntouched = async () => {
+    const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
+    const executionContext = await executionContextApi.getExecutionContext();
+    if (executionContext.type !== EXECUTION_CONTEXTS.theme)
+        return;
+    try {
+        await ThemeDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir);
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+};
+export default ensureThemeMetaDataUntouched;

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

@@ -0,0 +1,21 @@
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
+import { ThemeChecksumsUtils } from '../../features/theme/utils/checksums/theme_checksums_utils.js';
+import { computeChecksumsFromSource } from '../../../utils/checksums/checksums_utils.js';
+import { THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS } from './ensure_theme_current_checksums_up_to_date_constants.js';
+export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
+    console.log('Command', Command.id);
+    if (!THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS.includes(Command.id))
+        return;
+    const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
+    const executionContext = await executionContextApi.getExecutionContext();
+    if (executionContext.type !== EXECUTION_CONTEXTS.theme)
+        return;
+    /**
+     * Naive solution, recalculate checksums every time a command based on checksums calculation is executed;
+     * If performance becomes an issue, we can implement a more sophisticated solution, eg. recalculate checksums only when files in the theme directory have changed.
+     */
+    const checksums = await computeChecksumsFromSource(executionContext.themeRootDir);
+    await ThemeChecksumsUtils.createThemeCurrentChecksumsFile(executionContext.themeRootDir, checksums);
+};
+export default ensureThemeChecksumsUpToDate;