@shoper/cli 0.1.0-9 → 0.2.1-0

package/build/cli/features/controls/ui/controls_mappers.js

@@ -0,0 +1,62 @@
+import { CONTROLS_TYPES } from '../controls_constants.js';
+const toTextControl = ({ validators, label, isRequired, defaultValue, name }) => {
+    return {
+        type: 'input',
+        name,
+        message: isRequired ? `${label} (required)` : label,
+        default: defaultValue,
+        validate: toInquirerValidate(validators)
+    };
+};
+const toNumberControl = ({ validators, label, isRequired, defaultValue, name }) => {
+    return {
+        type: 'number',
+        name,
+        message: isRequired ? `${label} (required)` : label,
+        default: defaultValue,
+        validate: toInquirerValidate(validators)
+    };
+};
+const toSelectControl = ({ validators, label, isRequired, defaultValue, name, options }) => {
+    return {
+        type: 'list',
+        name,
+        message: isRequired ? `${label} (required)` : label,
+        choices: options,
+        default: defaultValue,
+        validate: toInquirerValidate(validators)
+    };
+};
+const toMultiSelectControl = ({ validators, label, isRequired, defaultValue, name, options }) => {
+    //TODO multiple checkboxes
+    return {
+        type: 'checkbox',
+        name,
+        message: isRequired ? `${label} (required)` : label,
+        choices: options,
+        default: defaultValue,
+        validate: toInquirerValidate(validators)
+    };
+};
+export const toInquirerControls = (controls) => {
+    return controls.map(toInquirerControl);
+};
+export const toInquirerControl = (control) => {
+    switch (control.type) {
+        case CONTROLS_TYPES.text:
+            return toTextControl(control);
+        case CONTROLS_TYPES.number:
+            return toNumberControl(control);
+        case CONTROLS_TYPES.select:
+            return toSelectControl(control);
+        case CONTROLS_TYPES.multiSelect:
+            return toMultiSelectControl(control);
+        default:
+            throw new Error(`Unknown control type`);
+    }
+};
+export const toInquirerValidate = (validators) => {
+    return (value) => {
+        return validators?.find((v) => !v.isValid(value))?.getErrorMessage() ?? true;
+    };
+};

package/build/cli/features/controls/ui/form.js

@@ -0,0 +1,4 @@
+import inquirer from 'inquirer';
+export const Form = ({ controls, onSubmit }) => {
+    inquirer.prompt(controls).then(onSubmit);
+};

package/build/cli/features/controls/ui/form_constants.js

@@ -0,0 +1,7 @@
+export {};
+// export const CONTROL_TYPE_TO_MAPPERS: Record<TControlType, Function> = {
+//     [CONTROLS_TYPES.text]: toTextControl,
+//     [CONTROLS_TYPES.number]: toNumberControl,
+//     [CONTROLS_TYPES.select]: toSelectControl,
+//     [CONTROLS_TYPES.multiSelect]: toMultiSelectControl
+// };

package/build/cli/features/controls/validators/greater_eq_than_validator.js

@@ -0,0 +1,5 @@
+export class GreaterEqThanValidator {
+    isValid(value, { min }) {
+        return value >= min;
+    }
+}

package/build/cli/features/controls/validators/length_validator.js

@@ -0,0 +1,6 @@
+export class LengthValidator {
+    isValid(value, { min, max }) {
+        const length = value.length;
+        return length >= min && length <= max;
+    }
+}

package/build/cli/features/controls/validators/required_validator.js

@@ -0,0 +1,5 @@
+export class RequiredValidator {
+    isValid(value) {
+        return value !== null && value !== undefined && value !== '';
+    }
+}

package/build/cli/features/controls/validators/validator_constants.js

@@ -0,0 +1,13 @@
+import { RequiredValidator } from './required_validator.js';
+import { GreaterEqThanValidator } from './greater_eq_than_validator.js';
+import { LengthValidator } from './length_validator.js';
+export const VALIDATORS_TYPES = {
+    required: 'required',
+    greaterEqThan: 'greaterEqThan',
+    length: 'length'
+};
+export const VALIDATOR_TYPE_TO_VALIDATOR = {
+    [VALIDATORS_TYPES.required]: new RequiredValidator(),
+    [VALIDATORS_TYPES.greaterEqThan]: new GreaterEqThanValidator(),
+    [VALIDATORS_TYPES.length]: new LengthValidator()
+};

package/build/cli/features/execution_context/execution_context_service.js

@@ -1,10 +1,10 @@
 import process from 'node:process';
 import { EXECUTION_CONTEXTS } from './execution_context_constants.js';
-import { ThemeDirectoryUtils } from '../../../theme/features/theme/directory/theme_directory_utils.js';
+import { ThemeMetaDataUtils } from '../../../theme/features/theme/utils/meta_data/theme_meta_data_utils.js';
 export class ExecutionContextService {
     #executionContext;
     async _obtainExecutionContext() {
-        if (await ThemeDirectoryUtils.closestThemeRootDirectory(process.cwd())) {
+        if (await ThemeMetaDataUtils.closestThemeRootDirectory(process.cwd())) {
             return await this.getThemeExecutionContext();
         }
         return await this._getGlobalExecutionContext();
@@ -20,14 +20,14 @@ export class ExecutionContextService {
         return this.#executionContext;
     }
     async getThemeExecutionContext() {
-        const themeRoot = await ThemeDirectoryUtils.closestThemeRootDirectory(process.cwd());
+        const themeRoot = await ThemeMetaDataUtils.closestThemeRootDirectory(process.cwd());
         //TODO errors
         if (!themeRoot)
             throw 'Theme root directory not found';
-        const themeDirectoryMetadata = await ThemeDirectoryUtils.getThemeDirectoryMetadata(themeRoot);
+        const themeMetaData = await ThemeMetaDataUtils.getThemeMetadata(themeRoot);
         return {
             type: EXECUTION_CONTEXTS.theme,
-            themeId: themeDirectoryMetadata.themeId,
+            themeId: themeMetaData.themeId,
             executionDir: process.cwd(),
             themeRootDir: themeRoot
         };

package/build/cli/features/http_requester/http_requester_initializer.js

@@ -1,6 +1,6 @@
 import { CACHE_TYPES, CacheService, DEFAULT_REQUESTER_CACHE_NAMESPACE, FEATURE_CORES_TYPES, HTTP_REQUESTER_FEATURE_NAME, HTTPRequesterApi, HTTPRequesterBalancer, REQUEST_SOURCE, Requester, RequesterCacheServiceKeySerializer, SANITIZER_API_NAME, StrategiesContainer, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { HttpClient } from './http_client.js';
-import { CacheFactory } from '../caches/cache_factory.js';
+import { CacheFactory } from '../../class/caches/cache_factory.js';
 export class HTTPRequesterInitializer extends SyncFeatureInitializer {
     static featureName = HTTP_REQUESTER_FEATURE_NAME;
     init() {

package/build/cli/hooks/authorization/ensure_authorization_hook.js

@@ -1,11 +1,11 @@
-import { COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION } from './ensure_authorization_hook_constants.js';
+import { COMMANDS_THAT_REQUIRE_AUTHORIZATION } from './ensure_authorization_hook_constants.js';
 import { useApi } from '../ensure_cli_initialized_hook.js';
 import { CLI_AUTH_API_NAME } from '../../auth/cli_auth_constants.js';
 import { CLI_AUTH_TOKENS_API_NAME } from '../../auth/tokens/cli_auth_tokens_constants.js';
 import { promptForToken } from '../../commands/utils/prompt_for_token_utils.js';
 import { CliAuthUtils } from '../../auth/cli_auth_utils.js';
 const ensureAuthorizationHook = async ({ Command }) => {
-    if (COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION.includes(Command.id))
+    if (!COMMANDS_THAT_REQUIRE_AUTHORIZATION.includes(Command.id))
         return;
     const cliAuthApi = useApi(CLI_AUTH_API_NAME);
     const cliAuthTokensApi = useApi(CLI_AUTH_TOKENS_API_NAME);

package/build/cli/hooks/authorization/ensure_authorization_hook_constants.js

@@ -1,9 +1,8 @@
-import { CLI_COMMANDS_NAMES } from '../../commands/commands_constants.js';
-export const COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION = [
-    CLI_COMMANDS_NAMES.update,
-    CLI_COMMANDS_NAMES.update,
-    CLI_COMMANDS_NAMES.authAddToken,
-    CLI_COMMANDS_NAMES.authRemoveToken,
-    CLI_COMMANDS_NAMES.authListTokens,
-    CLI_COMMANDS_NAMES.switchToken
+import { THEME_COMMANDS_NAME } from '../../../theme/commands/theme_commands_constants.js';
+export const COMMANDS_THAT_REQUIRE_AUTHORIZATION = [
+    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.pull,
+    THEME_COMMANDS_NAME.list,
+    THEME_COMMANDS_NAME.init,
+    THEME_COMMANDS_NAME.verify
 ];

package/build/index.js

@@ -7,6 +7,7 @@ import { CliAuthListTokensCommand } from './cli/commands/auth/cli_auth_list_toke
 import { CliAuthAddTokenCommand } from './cli/commands/auth/cli_auth_add_token_command.js';
 import { CliAuthRemoveTokenCommand } from './cli/commands/auth/cli_auth_remove_token_command.js';
 import { CliAuthSwitchTokenCommand } from './cli/commands/auth/cli_auth_switch_token_command.js';
+import { CliUIDumpCommand } from './cli/commands/cli_ui_dump_command.js';
 //TODO
 //@ts-ignore
 if (typeof global.crypto !== 'object') {
@@ -42,27 +43,44 @@ export const COMMANDS = {
     [CLI_COMMANDS_NAMES.authAddToken]: CliAuthAddTokenCommand,
     [CLI_COMMANDS_NAMES.authRemoveToken]: CliAuthRemoveTokenCommand,
     [CLI_COMMANDS_NAMES.switchToken]: CliAuthSwitchTokenCommand,
+    [CLI_COMMANDS_NAMES.uiDump]: CliUIDumpCommand,
     ...THEME_COMMANDS
 };
 export { runCLI } from './cli/index.js';
 /**
- * TODO:
- * testy verify
- *  - usuniecie po koleji .shoper, macros, modules, settings, styles...
- *  testy theme show-changes
- *    - macro
- *      - dodawanie, zmienianie i usuwanie makr
- *  testy theme verify
- *    - makro
- *     - dodawanie, zmienianie i usuwanie makr
- * testy pull push
- * - nie skinstore
- *      - push nowego modułu, podmieni sie folder i checksumy przywróćenie foledu bez checksum i push error z permissions
- *      - dodawanie, modzenie i usuwanie customowych makr
- *      - modzenie makr
- *      - dodawanie i usuwanie customowych modułów
- *      - podmiana thumbnail
- * - skinstore
- *      - modzenie danych settingsów skinstore
- *      - dodawanie, usuwanie, podmienianie obrazków
+ * Przetestowane na win
+ * oglne
+ * moduly:
+ *   - stworzony w admince
+ *      - pull w cli - v
+ *      - updejt modulu w adminc i pull w cli - v
+ *      - zmiana nazwy katalogu w cli, modzenie w admince i pull - v
+ *      - kopiowanie stworzonego modulu w admince i push (usuniety id i code) - v
+ *      - zminaa w cli i push - v
+ *   - tworzenie modulu w cli, min plikow i push
+ *      - aktualizowanie js/twig/settings/schema
+ *      - zmiana w adminc i pull
+ *   - usuwanie modulu z cli - v
+ *   - usuwanie modulu z adminki - v
+ *   - dodanie niedozwolonego pliku do folderu modulu
+ *   - dodanie niedozwolonego pliku do folderu modules/
+ *   - translacje - v
+ * macro:
+ *   - dodawanie pliku do macros - v
+ *   - usuniecie macro - v
+ *   - modzneie makro - v
+ *   - dodawanie customowego macro - v
+ *   - push customowego macro - v
+ *   - modzenie w admince i pull - v
+ * settingsy:
+ *   - uzupelniania schemy w admince, pull w cli
+ *   - uzupelnianie wartosci a admince i pull
+ *   - modzenie w cli
+ *   - usuniecie pliku w cli
+ * styles:
+ *   - modzenie stylu w src - niedozwolone - v
+ *   - modzenie custom - v
+ *   - usuniecie custom - v
+ *   - modzenie schema i settings - v
+ * dodanie czegos w .shoper
  */

package/build/theme/class/archive/theme_archive.js

@@ -0,0 +1,44 @@
+import globs from 'fast-glob';
+import { createZip } from '../../../utils/zip/create_zip_utils.js';
+import { ThemeFilesStructureUtils } from '../../features/theme/utils/files_structure/theme_files_structure_utils.js';
+import { extname, join } from '../../../utils/path_utils.js';
+import { formatJSONFile } from '../../../utils/fs/fs_utils.js';
+import { ThemeArchiveErrorsFactory } from './theme_archive_errors_factory.js';
+import { ThemeFileStructureErrorsFactory } from '../../features/theme/utils/files_structure/theme_file_structure_errors_factory.js';
+import { ThemeActionsUtils } from '../../features/theme/actions/theme_actions_utils.js';
+export class ThemeArchive {
+    #themeRootDir;
+    constructor(themeRootDir) {
+        this.#themeRootDir = themeRootDir;
+    }
+    async createFullArchive({ dist, actionValue, actionType }) {
+        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(this.#themeRootDir);
+        if (!filesStructure)
+            throw ThemeFileStructureErrorsFactory.createNoFilesStructureError();
+        try {
+            const filesInThemeDirectory = await globs(ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                actionType,
+                actionValue,
+                filesStructure
+            }), {
+                suppressErrors: true,
+                onlyFiles: true,
+                cwd: this.#themeRootDir
+            });
+            await this._formatJsonFiles(this.#themeRootDir, filesInThemeDirectory);
+            return createZip({
+                files: filesInThemeDirectory,
+                baseDir: this.#themeRootDir,
+                dist
+            });
+        }
+        catch (err) {
+            throw ThemeArchiveErrorsFactory.createErrorWhileCreatingThemeArchive(err);
+        }
+    }
+    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

@@ -0,0 +1,11 @@
+import { AppError } from '../../../cli/class/errors/app/app_error.js';
+export class ThemeArchiveErrorsFactory {
+    static createErrorWhileCreatingThemeArchive(error) {
+        return new AppError({
+            code: 'theme_archive.error_creating_archive',
+            message: `Error while creating theme archive`,
+            level: 'error',
+            stack: error.stack
+        });
+    }
+}

package/build/theme/class/checksums/theme_checksums.js

@@ -0,0 +1,170 @@
+import { copyFile, fileExists, readJSONFile, readJSONFileSync, removeFile } from '../../../utils/fs/fs_utils.js';
+import { ThemeChecksumsUtils } from './theme_checksums_utils.js';
+import { isWindowsOs } from '../../../utils/platform_utils.js';
+import { join, mapKeysPathsToWindowPlatform, toCurrentPlatformPath } from '../../../utils/path_utils.js';
+import { createWriteStream } from 'node:fs';
+import { JSON_FILE_INDENT } from '../../../cli/cli_constants.js';
+import { ThemeChecksumsErrorFactory } from './theme_checksums_error_factory.js';
+import { computeChecksumsFromFilesStructure, computeDirectoriesChecksums, computeFileChecksum } from '../../../utils/checksums/checksums_utils.js';
+import { normalize } from 'node:path';
+import { ThemePushUtils } from '../../features/theme/push/theme_push_utils.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.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 '../../features/theme/theme_constants.js';
+export class ThemeChecksums {
+    #themeDir;
+    #currentChecksumsFilePath;
+    #currentChecksumsVerificationFilePath;
+    #initialChecksumsFilePath;
+    #initialChecksumsVerificationFilePath;
+    #initialChecksums;
+    #currentChecksums;
+    constructor(themeDir) {
+        this.#themeDir = themeDir;
+        this.#currentChecksumsFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsFilePath(themeDir);
+        this.#currentChecksumsVerificationFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsVerificationFilePath(themeDir);
+        this.#initialChecksumsFilePath = ThemeChecksumsUtils.getInitialThemeChecksumsFilePath(themeDir);
+        this.#initialChecksumsVerificationFilePath = ThemeChecksumsUtils.getInitialThemeChecksumsVerificationFilePath(themeDir);
+    }
+    async getInitialChecksums() {
+        if (this.#initialChecksums)
+            return this.#initialChecksums;
+        this.#initialChecksums = await this._getChecksums(this.#initialChecksumsFilePath);
+        return this.#initialChecksums;
+    }
+    getInitialChecksumsSync() {
+        if (this.#initialChecksums)
+            return this.#initialChecksums;
+        this.#initialChecksums = this._getChecksumsSync(this.#initialChecksumsFilePath);
+        return this.#initialChecksums;
+    }
+    async getCurrentChecksums() {
+        if (this.#currentChecksums)
+            return this.#currentChecksums;
+        this.#currentChecksums = await this._getChecksums(this.#currentChecksumsFilePath);
+        return this.#currentChecksums;
+    }
+    getCurrentChecksumsSync() {
+        if (this.#currentChecksums)
+            return this.#currentChecksums;
+        this.#currentChecksums = this._getChecksumsSync(this.#currentChecksumsFilePath);
+        return this.#currentChecksums;
+    }
+    async getCurrentChecksumFromPath(path) {
+        const checksums = await this.getCurrentChecksums();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    getCurrentChecksumFromPathSync(path) {
+        const checksums = this.getCurrentChecksumsSync();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    async getInitialChecksumFromPath(path) {
+        const checksums = await this.getInitialChecksums();
+        return checksums[toCurrentPlatformPath(path)];
+    }
+    async hasThemeBeenModified() {
+        const initialChecksums = await this._getInitialChecksumsVerification();
+        const currentChecksums = await this._getCurrentChecksumsVerification();
+        return !!initialChecksums && !!currentChecksums && initialChecksums !== currentChecksums;
+    }
+    async hasThemeFileBeenCreated(path) {
+        const initialChecksum = await this.getInitialChecksumFromPath(path);
+        return !initialChecksum && (await fileExists(join(this.#themeDir, path)));
+    }
+    async hasThemeFileBeenModified(path) {
+        const currentChecksum = await this.getCurrentChecksumFromPath(path);
+        const initialChecksum = await this.getInitialChecksumFromPath(path);
+        return !!currentChecksum && !!initialChecksum && currentChecksum !== initialChecksum;
+    }
+    async verify() {
+        const initialChecksumFilePath = this.#initialChecksumsFilePath;
+        const initialChecksumVerifyFilePath = this.#initialChecksumsVerificationFilePath;
+        const initialChecksum = await computeFileChecksum(initialChecksumFilePath);
+        const initialChecksumVerify = await readJSONFile(initialChecksumVerifyFilePath);
+        return initialChecksum === initialChecksumVerify;
+    }
+    async updateAllChecksums() {
+        const checksums = await this.computeThemeChecksums();
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.#currentChecksumsFilePath;
+            const initialChecksumFilePath = this.#initialChecksumsFilePath;
+            const checksumStream = createWriteStream(initialChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const initialChecksumVerifyFilePath = this.#initialChecksumsVerificationFilePath;
+                const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
+                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));
+            });
+        });
+    }
+    async updateCurrentChecksums() {
+        const checksums = await this.computeThemeChecksums();
+        return new Promise((resolve, reject) => {
+            const currentChecksumFilePath = this.#currentChecksumsFilePath;
+            const checksumStream = createWriteStream(currentChecksumFilePath);
+            checksumStream.write(JSON.stringify(checksums, null, JSON_FILE_INDENT));
+            checksumStream.end();
+            checksumStream
+                .on('finish', async () => {
+                const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
+                await this._createThemeChecksumVerifyFile(currentChecksumFilePath, currentChecksumVerifyFilePath);
+                resolve();
+            })
+                .on('error', async (err) => {
+                await removeFile(currentChecksumFilePath, { force: true });
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+            });
+        });
+    }
+    async computeThemeChecksums() {
+        const filesToIgnoreInChecksums = [
+            join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_INITIAL_CHECKSUMS_FILE_NAME),
+            join(SHOPER_THEME_METADATA_DIR, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME)
+        ];
+        const filesToComputeChecksums = (await ThemePushUtils.getAllFilesThatAreSendToRemote(this.#themeDir))
+            .filter((path) => !filesToIgnoreInChecksums.some((ignorePath) => normalize(path) === ignorePath))
+            .map((relativePath) => join(this.#themeDir, relativePath));
+        const { filesChecksumsInDirectories, filesChecksums } = await computeChecksumsFromFilesStructure(filesToComputeChecksums, this.#themeDir);
+        const directoriesChecksums = computeDirectoriesChecksums(filesChecksumsInDirectories);
+        return { ...filesChecksums, ...directoriesChecksums };
+    }
+    async _getInitialChecksumsVerification() {
+        return await readJSONFile(this.#initialChecksumsVerificationFilePath);
+    }
+    async _getCurrentChecksumsVerification() {
+        return await readJSONFile(this.#currentChecksumsVerificationFilePath);
+    }
+    async _getChecksums(path) {
+        const checksums = await readJSONFile(path);
+        if (!isWindowsOs())
+            return checksums;
+        return mapKeysPathsToWindowPlatform(checksums);
+    }
+    _getChecksumsSync(path) {
+        const checksums = readJSONFileSync(path);
+        if (!isWindowsOs())
+            return checksums;
+        return mapKeysPathsToWindowPlatform(checksums);
+    }
+    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();
+    }
+}

package/build/theme/{features/theme/utils → class}/checksums/theme_checksums_error_factory.js

@@ -1,4 +1,4 @@
-import { AppError } from '../../../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../cli/class/errors/app/app_error.js';
 export class ThemeChecksumsErrorFactory {
     static createThemeChecksumError(stack) {
         return new AppError({

package/build/theme/class/checksums/theme_checksums_utils.js

@@ -0,0 +1,17 @@
+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 '../../features/theme/theme_constants.js';
+import { HiddenDirectoryUtils } from '../../features/theme/utils/hidden_directory/hidden_directory_utils.js';
+export class ThemeChecksumsUtils {
+    static getCurrentThemeChecksumsFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_CURRENT_CHECKSUMS_FILE_NAME);
+    }
+    static getInitialThemeChecksumsFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_INITIAL_CHECKSUMS_FILE_NAME);
+    }
+    static getCurrentThemeChecksumsVerificationFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME);
+    }
+    static getInitialThemeChecksumsVerificationFilePath(themeDir) {
+        return join(HiddenDirectoryUtils.getThemeHiddenDirectoryPath(themeDir), THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME);
+    }
+}

package/build/theme/class/fetch_resources/fetch_resources.js

@@ -58,6 +58,7 @@ export class FetchResources {
                 });
             }));
         }
+        return;
     }
     async _getResourcesFileContent(resourcePath) {
         return mapResourcesToTree(await readJSONFile(resourcePath));

package/build/theme/class/fetch_resources/fetch_resources_errors_factory.js

@@ -1,4 +1,4 @@
-import { AppError } from '../../../cli/class/errors/app_error/app_error.js';
+import { AppError } from '../../../cli/class/errors/app/app_error.js';
 export class FetchResourcesErrorsFactory {
     static createErrorFetchingResource(shopUrl, messages) {
         return new AppError({

package/build/theme/class/fetch_resources/fetch_resources_utils.js

@@ -1,7 +1,7 @@
 import { join } from '../../../utils/path_utils.js';
 import { RESOURCES_FILE_NAME } from './fetch_resources_constants.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
-import { fileExists, readJSONFile } from '../../../utils/fs/fs_utils.js';
+import { fileExists, readJSONFile, removeFiles } from '../../../utils/fs/fs_utils.js';
 export const isResourceObject = (resource) => {
     return typeof resource === 'object' && resource !== null && 'url' in resource && typeof resource.url === 'string';
 };
@@ -15,6 +15,9 @@ export const getResources = async (root) => {
     }
     return await readJSONFile(resourcesPath);
 };
+export const removeOldResources = async (rootDir, resources) => {
+    await removeFiles(Object.keys(resources).map((path) => join(rootDir, path)));
+};
 export const mapResourcesToTree = (resources, separator = '/') => {
     const tree = {};
     Object.entries(resources).forEach(([path, value]) => {

package/build/theme/class/files_upload/theme_files_upload.js

@@ -0,0 +1,61 @@
+import { basename, dirname } from '../../../utils/path_utils.js';
+import { createReadStream } from 'node:fs';
+import { THEME_WILDCARD_ACTION_NAME } from '../../features/theme/actions/service/theme_actions_service_constants.js';
+import { ThemePushErrorsFactory } from '../../features/theme/push/theme_push_errors_factory.js';
+export class ThemeFilesUpload {
+    #credentials;
+    #themeFilesUploadHttpApi;
+    constructor({ credentials, themeFilesUploadHttpApi }) {
+        this.#themeFilesUploadHttpApi = themeFilesUploadHttpApi;
+        this.#credentials = credentials;
+    }
+    async uploadArchive({ action, themeArchivePath, credentials }) {
+        try {
+            const request = this.#themeFilesUploadHttpApi.uploadFiles({
+                actionData: action.data[THEME_WILDCARD_ACTION_NAME],
+                stream: createReadStream(themeArchivePath),
+                shopUrl: credentials.shopUrl
+            });
+            const response = await request.response;
+            if (response.status !== 200 || !response.data.isSuccess)
+                throw response;
+            return response.data;
+        }
+        catch (err) {
+            throw ThemePushErrorsFactory.createErrorWhileUploadingTheme(credentials.shopUrl, err.response.data.messages);
+        }
+    }
+    async uploadFiles(uploadData) {
+        const uploadedImageData = [];
+        const rejectedImageData = [];
+        await Promise.all(uploadData.map(({ actionData, path }) => this.#themeFilesUploadHttpApi
+            //TODO tajpings
+            .uploadFiles({
+            actionData,
+            stream: createReadStream(path),
+            shopUrl: this.#credentials.shopUrl
+        })
+            .response.then((response) => {
+            const { imageId, messages, isSuccess } = response.data;
+            uploadedImageData.push({
+                isSuccess,
+                messages,
+                location: dirname(path),
+                originalFilename: basename(path),
+                uploadedFilename: imageId
+            });
+        })
+            .catch((err) => {
+            rejectedImageData.push({
+                isSuccess: err?.response?.data?.isSuccess ?? false,
+                messages: err?.response?.data?.messages ?? [],
+                location: dirname(path),
+                originalFilename: basename(path)
+            });
+        })));
+        return {
+            uploadedImageData,
+            rejectedImageData
+        };
+    }
+}

package/build/theme/class/files_upload/theme_files_upload_http_api.js

@@ -0,0 +1,23 @@
+export class ThemeFilesUploadHttpApi {
+    #httpApi;
+    constructor(httpApi) {
+        this.#httpApi = httpApi;
+    }
+    uploadFiles({ actionData, shopUrl, stream }) {
+        const { method, url } = actionData;
+        return this.#httpApi.fetch({
+            url: `${shopUrl}${url}`,
+            method,
+            //TODO Remove after fix
+            // method: 'POST',
+            data: stream,
+            sanitizeOptions: {
+                disable: true
+            },
+            headers: {
+                'Content-Type': 'application/octet-stream'
+            },
+            isPrivate: true
+        });
+    }
+}