@shoper/cli 0.1.0-7 → 0.1.0-9

package/build/cli/commands/files_diff_command.js

@@ -0,0 +1,174 @@
+//@ts-nocheck
+import { BaseCliCommand } from '../class/base_cli_command.js';
+import * as readline from 'node:readline/promises';
+import * as fs from 'node:fs';
+import { Args } from '@oclif/core';
+import process from 'node:process';
+import * as path from 'node:path';
+import { diffWords } from 'diff';
+export class CliFilesDiffCommand extends BaseCliCommand {
+    static summary = 'Differentiate between two files';
+    static args = {
+        file1: Args.string({
+            name: 'file1',
+            required: true,
+            description: 'First file to compare',
+            type: 'string'
+        }),
+        file2: Args.string({
+            name: 'file2',
+            required: true,
+            description: 'Second file to compare',
+            type: 'string'
+        })
+    };
+    async run() {
+        const { args } = await this.parse(CliFilesDiffCommand);
+        const inputAPath = args.file1;
+        const inputBPath = args.file2;
+        return new Promise((resolve, reject) => {
+            Promise.all([readLines(inputAPath), readLines(inputBPath)]).then((result) => {
+                const [aLines, bLines] = result;
+                // console.log('aLines', aLines);
+                // console.log('bLines', bLines);
+                merge(aLines, bLines);
+                resolve();
+            });
+            // aStream.on('line', (input) => {
+            //     console.log('aStream line: ', input);
+            // });
+            //
+            // bStream.on('line', (input) => {
+            //     console.log('bStream line: ', input);
+            // });
+        });
+    }
+}
+const readLines = async (filePath) => {
+    return new Promise((resolve, reject) => {
+        const lines = [];
+        const inputStream = readline.createInterface({
+            input: fs.createReadStream(path.resolve(process.cwd(), filePath)),
+            crlfDelay: Infinity
+        });
+        inputStream.on('line', (line) => {
+            lines.push(line);
+        });
+        inputStream.on('close', () => {
+            resolve(lines);
+        });
+        inputStream.on('error', (err) => {
+            reject(err);
+        });
+    });
+};
+const merge = (aLines, bLines) => {
+    let hasConflict = false;
+    const maxLength = Math.max(aLines.length, bLines.length);
+    const outputPath = path.resolve(process.cwd(), 'merge.txt');
+    const outStream = fs.createWriteStream(outputPath, { encoding: 'utf8' });
+    for (let i = 0; i < maxLength; i++) {
+        const a = aLines[i] ?? '';
+        const b = bLines[i] ?? '';
+        if (a === b) {
+            outStream.write(a + '\n');
+        }
+        else {
+            hasConflict = true;
+            console.log('⚠️ Conflict detected:');
+            console.log('a:', a);
+            console.log('b:', b);
+            const { aFormatted, bFormatted } = formatWordDiff(a, b);
+            console.log('aFormatted', aFormatted);
+            console.log('bFormatted', bFormatted);
+            outStream.write('<<<<<<< mine\n');
+            outStream.write(aFormatted + '\n');
+            outStream.write('=======\n');
+            outStream.write(bFormatted + '\n');
+            outStream.write('>>>>>>> theirs\n');
+        }
+    }
+    outStream.end();
+    outStream.on('finish', () => {
+        if (hasConflict) {
+            console.log('⚠️ Conflicts detected. Check', outputPath);
+        }
+        else {
+            console.log('✅ Merged with no conflicts. Output written to', outputPath);
+        }
+    });
+};
+function formatWordDiff(aLine, bLine) {
+    const changes = diffWords(aLine, bLine);
+    const aFormatted = changes.map((part) => (part.added ? '' : part.value)).join('');
+    const bFormatted = changes.map((part) => (part.removed ? '' : part.value)).join('');
+    return {
+        aFormatted: aFormatted.trimEnd(),
+        bFormatted: bFormatted.trimEnd()
+    };
+}
+// const fs = require('fs');
+// const path = require('path');
+// const readline = require('readline');
+// const Diff = require('diff');
+//
+// async function mergeWithCommentsStream(fileAPath, fileBPath, outputPath) {
+//     const textA = await fs.promises.readFile(fileAPath, 'utf8');
+//     const textB = await fs.promises.readFile(fileBPath, 'utf8');
+//
+//     const diffs = Diff.diffLines(textA, textB);
+//     const outputStream = fs.createWriteStream(outputPath, { encoding: 'utf8' });
+//
+//     let currentState = 'equal'; // 'equal' | 'added' | 'removed'
+//
+//     for (const part of diffs) {
+//         const lines = part.value.endsWith('\n') ? part.value.slice(0, -1).split('\n') : part.value.split('\n');
+//
+//         if (part.added) {
+//             if (currentState !== 'added') {
+//                 outputStream.write('added >>>>>\n');
+//                 currentState = 'added';
+//             }
+//             for (const line of lines) {
+//                 outputStream.write(line + '\n');
+//             }
+//         } else if (part.removed) {
+//             if (currentState !== 'removed') {
+//                 outputStream.write('removed >>>>>\n');
+//                 currentState = 'removed';
+//             }
+//             for (const line of lines) {
+//                 outputStream.write(line + '\n');
+//             }
+//         } else {
+//             // Close any previous block
+//             if (currentState === 'added') {
+//                 outputStream.write('end-added >>>\n');
+//             } else if (currentState === 'removed') {
+//                 outputStream.write('end-removed >>>\n');
+//             }
+//             currentState = 'equal';
+//
+//             for (const line of lines) {
+//                 outputStream.write(line + '\n');
+//             }
+//         }
+//     }
+//
+//     // Final cleanup in case the last block was added/removed
+//     if (currentState === 'added') {
+//         outputStream.write('end-added >>>\n');
+//     } else if (currentState === 'removed') {
+//         outputStream.write('end-removed >>>\n');
+//     }
+//
+//     outputStream.end();
+//     console.log(`✅ Merge complete. Output written to: ${outputPath}`);
+// }
+//
+// // Example usage
+// const fileA = path.resolve('versionA.txt');
+// const fileB = path.resolve('versionB.txt');
+// const outputFile = path.resolve('mergedWithComments.txt');
+//
+// mergeWithCommentsStream(fileA, fileB, outputFile);

package/build/cli/commands/utils/prompt_for_token_utils.js

@@ -0,0 +1,25 @@
+import { CLiAuthTokensUtils } from '../../auth/tokens/cli_auth_tokens_utils.js';
+import inquirer from 'inquirer';
+export const promptForToken = async (cliAuthTokensApi) => {
+    try {
+        const { token } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'token',
+                required: true,
+                message: 'Enter token: '
+            }
+        ]);
+        if (CLiAuthTokensUtils.hasTokenExpired(token)) {
+            console.log('Token is expired');
+            return;
+        }
+        cliAuthTokensApi.addToken(token);
+        cliAuthTokensApi.setDefaultToken(cliAuthTokensApi.getTokensCount());
+        console.log('Token added successfully');
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+};

package/build/cli/core/cli_setup.js

@@ -1,31 +1,44 @@
-import { getOSRootDirectory } from '../../utils/fs.js';
+import { getOSRootDirectory } from '../../utils/fs/fs_utils.js';
 import * as process from 'process';
 import tmp from 'tmp-promise';
-import { SanitizerInitializer, StarCoreSetup } from '@dreamcommerce/star_core';
 import { HTTPRequesterInitializer } from '../features/http_requester/http_requester_initializer.js';
-import { ShoperThemesInitializer } from '../../theme/features/themes/shoper_themes_initalizer.js';
+import { SanitizerInitializer, StarCoreSetup } from '@dreamcommerce/star_core';
+import { CliDataDirectoryInitializer } from '../features/data_directory/cli_data_directory_initializer.js';
 import { ExecutionContextInitializer } from '../features/execution_context/execution_context_initalizer.js';
 import { CliVersionInitializer } from '../features/version/cli_version_initializer.js';
-import { CliDataDirectoryInitializer } from '../features/data_directory/cli_data_directory_initializer.js';
+import { CliAuthTokensInitializer } from '../auth/tokens/cli_auth_tokens_initalizer.js';
+import { CliAuthInitializer } from '../auth/cli_auth_initializer.js';
+import { ThemesListInitializer } from '../../theme/features/themes/list/themes_list_initializer.js';
+import { ThemeInitInitializer } from '../../theme/features/theme/init/theme_init_initializer.js';
+import { ThemeFetchInitializer } from '../../theme/features/theme/fetch/theme_fetch_initializer.js';
+import { ThemeMergeInitializer } from '../../theme/features/theme/merge/theme_merge_initializer.js';
+import { ThemeActionsInitializer } from '../../theme/features/theme/actions/theme_actions_initializer.js';
+import { ThemePushInitializer } from '../../theme/features/theme/push/theme_push_initializer.js';
 tmp.setGracefulCleanup();
 export const cliSetup = async () => {
     //TODO jakis ładny komuniakt błedu
     if (process.cwd() === getOSRootDirectory())
         throw 'You cannot run this command in the root directory of the os system';
     await StarCoreSetup.setup({
-        //TODO dnamicznie inicjalizowanie ficzurów wykorzystywanych w poszczególnych komendach
         features: [
             SanitizerInitializer,
             HTTPRequesterInitializer,
             CliDataDirectoryInitializer,
             ExecutionContextInitializer,
             CliVersionInitializer,
-            ShoperThemesInitializer
+            CliAuthTokensInitializer,
+            CliAuthInitializer,
+            ThemesListInitializer,
+            ThemeActionsInitializer,
+            //TODO dnamicznie inicjalizowanie ficzurów wykorzystywanych w poszczególnych komendach
+            ThemeInitInitializer,
+            ThemeMergeInitializer,
+            ThemeFetchInitializer,
+            ThemePushInitializer
         ],
         options: {
             featuresTracking: false,
             messageQueue: false
         }
     });
-    //TODO structure validation
 };

package/build/cli/features/caches/json_cache/json_cache.js

@@ -0,0 +1,50 @@
+import { FeatureCore } from '@dreamcommerce/star_core';
+import Conf from 'conf';
+export class JsonCache extends FeatureCore {
+    #cache;
+    moduleName = 'JsonCache';
+    constructor({ path, name, configFileMode = 600, ...rest }) {
+        super();
+        this.#cache = new Conf({
+            cwd: path,
+            configName: name,
+            configFileMode,
+            ...rest
+        });
+    }
+    set(key, value) {
+        this.#cache.set(key, value);
+    }
+    get(key) {
+        return this.#cache.get(key) ?? null;
+    }
+    getAll() {
+        return Object.keys(this.#cache.store).map((key) => this.get(key));
+    }
+    getKeys() {
+        return Object.keys(this.#cache.store);
+    }
+    remove(key) {
+        this.#cache.delete(key);
+    }
+    clear() {
+        this.#cache.clear();
+    }
+    has(key) {
+        return this.#cache.has(key);
+    }
+    get size() {
+        return this.#cache.size;
+    }
+    getMultiple(keys) {
+        return keys.map((key) => this.get(key)).filter(Boolean);
+    }
+    setMultiple(storeRecord) {
+        storeRecord.forEach(({ key, value }) => {
+            this.set(key, value);
+        });
+    }
+    removeMultiple(keys) {
+        keys.forEach((key) => this.remove(key));
+    }
+}

package/build/cli/features/caches/memory_cache.js

@@ -14,6 +14,12 @@ export class MemoryCache extends FeatureCore {
     get(key) {
         return this.#cache.get(key) ?? null;
     }
+    getAll() {
+        return Array.from(this.#cache.values());
+    }
+    getKeys() {
+        return Array.from(this.#cache.keys());
+    }
     remove(key) {
         this.#cache.delete(key);
     }

package/build/cli/features/data_directory/cli_data_directory_constants.js

@@ -1,4 +1,3 @@
 export const CLI_DATA_DIRECTORY_API_NAME = 'CliDataDirectoryApi';
 export const CLI_DATA_DIRECTORY_FEATURE_NAME = 'CliDataDirectory';
 export const SHOPER_CLI_DATA_DIRECTORY = '.shoper-cli';
-export const SHOPER_CLI_CACHE_DIRECTORY = '.cache';

package/build/cli/features/data_directory/cli_data_directory_utils.js

@@ -1,11 +1,10 @@
-import { directoryExists, makeDirectory } from '../../../utils/fs.js';
-import { join } from '../../../utils/path.js';
-import { SHOPER_CLI_CACHE_DIRECTORY, SHOPER_CLI_DATA_DIRECTORY } from './cli_data_directory_constants.js';
+import { directoryExists, makeDirectory } from '../../../utils/fs/fs_utils.js';
+import { join } from '../../../utils/path_utils.js';
+import { SHOPER_CLI_DATA_DIRECTORY } from './cli_data_directory_constants.js';
 export class CliDataDirectoryUtils {
     static async createDataDirectory(path) {
         try {
             await makeDirectory(join(path, SHOPER_CLI_DATA_DIRECTORY));
-            await makeDirectory(join(path, SHOPER_CLI_DATA_DIRECTORY, SHOPER_CLI_CACHE_DIRECTORY));
         }
         catch (e) {
             // TODO handle error

package/build/cli/features/data_directory/service/cli_data_directory_service.js

@@ -1,6 +1,6 @@
-import * as os from 'os';
+import * as os from 'node:os';
 import { CliDataDirectoryUtils } from '../cli_data_directory_utils.js';
-import { join } from '../../../../utils/path.js';
+import { join } from '../../../../utils/path_utils.js';
 import { SHOPER_CLI_DATA_DIRECTORY } from '../cli_data_directory_constants.js';
 export class CliDataDirectoryService {
     #dataDirectoryPath = os.homedir();

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

@@ -1,4 +1,4 @@
-import process from 'process';
+import process from 'node:process';
 import { EXECUTION_CONTEXTS } from './execution_context_constants.js';
 import { ThemeDirectoryUtils } from '../../../theme/features/theme/directory/theme_directory_utils.js';
 export class ExecutionContextService {
@@ -11,9 +11,7 @@ export class ExecutionContextService {
     }
     async _getGlobalExecutionContext() {
         return {
-            type: EXECUTION_CONTEXTS.global,
-            //TODO get available themes within process.cwd()
-            availableThemes: []
+            type: EXECUTION_CONTEXTS.global
         };
     }
     async getExecutionContext() {
@@ -31,7 +29,7 @@ export class ExecutionContextService {
             type: EXECUTION_CONTEXTS.theme,
             themeId: themeDirectoryMetadata.themeId,
             executionDir: process.cwd(),
-            themRootDir: themeRoot
+            themeRootDir: themeRoot
         };
     }
 }

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

@@ -1,8 +1,39 @@
 import axios from 'axios';
-export class HttpClient {
+import { FeatureCore } from '@dreamcommerce/star_core';
+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';
+export class HttpClient extends FeatureCore {
     #axios;
     constructor() {
+        super();
         this.#axios = axios;
+        this._setupMiddlewares();
+    }
+    _setupMiddlewares() {
+        this.#axios.interceptors.request.use((config) => {
+            if (config.isPrivate) {
+                const accessToken = this._getAccessToken();
+                if (!accessToken)
+                    throw Error('Unauthorized');
+                config.headers['Authorization'] = `Bearer ${accessToken}`;
+            }
+            return config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+        this.#axios.interceptors.response.use((response) => {
+            return response;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+    }
+    _getAccessToken() {
+        const credentialsApi = this.getApiSync(CLI_AUTH_API_NAME);
+        const credentials = credentialsApi.getCredentials();
+        if (!credentials)
+            return null;
+        const cliAuthTokensApi = this.getApiSync(CLI_AUTH_TOKENS_API_NAME);
+        return cliAuthTokensApi.getDefaultToken();
     }
     fetch(options) {
         const axiosOptions = {

package/build/cli/features/version/service/cli_version_service.js

@@ -1,13 +1,11 @@
 import { exec } from 'child_process';
 import { CLI_NAME } from '../../../cli_constants.js';
-//TODO clean cache command
 export class CliVersionService {
     async update() {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             exec(`npm update -g ${CLI_NAME}`, (error, stdout) => {
-                //TODO error
                 if (error)
-                    throw new Error(Error.name);
+                    reject(error);
                 resolve(stdout);
             });
         });

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

@@ -1,11 +1,16 @@
 import { COMMANDS_THAT_NOT_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 }) => {
-    const isAuthorized = true;
-    if (isAuthorized || COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION.includes(Command.id))
+    if (COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION.includes(Command.id))
         return;
-    // Allow logs or cleanup to flush
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    // Forcefully exit
-    process.exit(1);
+    const cliAuthApi = useApi(CLI_AUTH_API_NAME);
+    const cliAuthTokensApi = useApi(CLI_AUTH_TOKENS_API_NAME);
+    while (!CliAuthUtils.checkCredentials(cliAuthApi, Command)) {
+        await promptForToken(cliAuthTokensApi);
+    }
 };
 export default ensureAuthorizationHook;

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

@@ -1,2 +1,9 @@
 import { CLI_COMMANDS_NAMES } from '../../commands/commands_constants.js';
-export const COMMANDS_THAT_NOT_REQUIRE_AUTHORIZATION = [CLI_COMMANDS_NAMES.update, CLI_COMMANDS_NAMES.update];
+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
+];

package/build/index.js

@@ -3,6 +3,10 @@ import { COMMANDS as THEME_COMMANDS } from './theme/index.js';
 import crypto from 'crypto';
 import { CLI_COMMANDS_NAMES } from './cli/commands/commands_constants.js';
 import { CliUpdateCommand } from './cli/commands/cli_update_command.js';
+import { CliAuthListTokensCommand } from './cli/commands/auth/cli_auth_list_tokens_command.js';
+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';
 //TODO
 //@ts-ignore
 if (typeof global.crypto !== 'object') {
@@ -19,7 +23,11 @@ function getRandomValues(array) {
 }
 process.on('uncaughtException', (err) => {
     //TODO handle error
-    console.log('err', err);
+    console.error('Uncaught Exception:', err);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection:', reason);
     process.exit(1);
 });
 const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
@@ -30,6 +38,31 @@ signals.forEach((signal) => {
 });
 export const COMMANDS = {
     [CLI_COMMANDS_NAMES.update]: CliUpdateCommand,
+    [CLI_COMMANDS_NAMES.authListTokens]: CliAuthListTokensCommand,
+    [CLI_COMMANDS_NAMES.authAddToken]: CliAuthAddTokenCommand,
+    [CLI_COMMANDS_NAMES.authRemoveToken]: CliAuthRemoveTokenCommand,
+    [CLI_COMMANDS_NAMES.switchToken]: CliAuthSwitchTokenCommand,
     ...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
+ */

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

@@ -0,0 +1,127 @@
+import { REQUEST_TYPES } from '@dreamcommerce/star_core';
+import { downloadFile } from '../../../utils/download_file/download_file_utils.js';
+import { extractZip } from '../../../utils/zip/extract_zip_utils.js';
+import { join } from '../../../utils/path_utils.js';
+import tmp from 'tmp-promise';
+import { copyFile, fileExists, readJSONFile } from '../../../utils/fs/fs_utils.js';
+import { getResourcesPath, isResourceObject, mapResourcesToTree } from './fetch_resources_utils.js';
+import { MAX_REQUEST_FOR_RESOURCES } from './fetch_resources_constants.js';
+import { isRelativeUrl } from '../../../utils/url_utils.js';
+import { FetchResourcesErrorsFactory } from './fetch_resources_errors_factory.js';
+import { move } from 'fs-extra';
+export class FetchResources {
+    #urlsAttempts = {};
+    #httpApi;
+    constructor(httpApi) {
+        this.#httpApi = httpApi;
+    }
+    async fetchResources({ dist, resourcesPart, parts, shopUrl }) {
+        if (Array.isArray(resourcesPart)) {
+            for (let i = 0; i < resourcesPart.length; i++) {
+                const resource = resourcesPart[i];
+                if (isResourceObject(resource)) {
+                    await this._fetchResource({
+                        url: isRelativeUrl(resource.url) ? `${shopUrl}${resource.url}` : resource.url,
+                        dist,
+                        parts: [...parts, i],
+                        shopUrl,
+                        isPrivate: resource.isPrivate ?? false
+                    });
+                    continue;
+                }
+                await this.fetchResources({
+                    dist,
+                    resourcesPart: resourcesPart[i],
+                    parts: [...parts, i],
+                    shopUrl
+                });
+            }
+            return;
+        }
+        if (typeof resourcesPart === 'object') {
+            if (isResourceObject(resourcesPart)) {
+                await this._fetchResource({
+                    url: isRelativeUrl(resourcesPart.url) ? `${shopUrl}${resourcesPart.url}` : resourcesPart.url,
+                    dist,
+                    parts,
+                    shopUrl,
+                    isPrivate: resourcesPart.isPrivate ?? false
+                });
+                return;
+            }
+            await Promise.all(Object.keys(resourcesPart).map((key) => {
+                return this.fetchResources({
+                    dist,
+                    resourcesPart: resourcesPart[key],
+                    parts: [...parts, key],
+                    shopUrl
+                });
+            }));
+        }
+    }
+    async _getResourcesFileContent(resourcePath) {
+        return mapResourcesToTree(await readJSONFile(resourcePath));
+    }
+    _getResourcesPart(resources, parts) {
+        return parts.reduce((acc, part) => acc[part] ?? {}, resources);
+    }
+    async _fetchResource({ url, shopUrl, parts, dist, isPrivate }) {
+        this.#urlsAttempts[url] = (this.#urlsAttempts[url] ?? 0) + 1;
+        if (this.#urlsAttempts[url] > MAX_REQUEST_FOR_RESOURCES)
+            throw FetchResourcesErrorsFactory.createErrorFetchingResource(shopUrl, [
+                `Failed to fetch ${url} after 3 attempts, for: ${parts.join('')}`
+            ]);
+        const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true, prefix: 'theme_resources_tmp' });
+        try {
+            const { filename, ext, basename } = await downloadFile({
+                dist: tmpDir,
+                request: this._getRequest({ url, isPrivate }).response
+            });
+            if (ext === '.zip') {
+                await extractZip({
+                    source: join(tmpDir, filename),
+                    dist: join(tmpDir, basename)
+                });
+                if (!(await fileExists(getResourcesPath(join(tmpDir, basename)))))
+                    return;
+                await copyFile(join(tmpDir, basename), dist, {
+                    recursive: true,
+                    force: true
+                });
+                const newResources = await this._getResourcesFileContent(getResourcesPath(join(tmpDir, basename)));
+                await this.fetchResources({
+                    dist,
+                    resourcesPart: this._getResourcesPart(newResources, parts),
+                    parts,
+                    shopUrl
+                });
+            }
+            else {
+                await move(join(tmpDir, filename), join(dist, this._getFilepathFromParts(parts), filename), { overwrite: true });
+            }
+        }
+        catch (err) {
+            throw FetchResourcesErrorsFactory.createErrorFetchingResource(shopUrl, err.message ? [err.message] : ['Unknown error']);
+        }
+    }
+    _getRequest({ url, isPrivate }) {
+        return this.#httpApi.fetch({
+            url,
+            method: REQUEST_TYPES.get,
+            //TODO tajping
+            //@ts-ignore
+            responseType: 'stream',
+            sanitizeOptions: {
+                disable: true
+            },
+            isPrivate
+        });
+    }
+    _getFilepathFromParts(parts) {
+        return parts
+            .filter((part) => typeof part === 'string')
+            .reduce((acc, part) => {
+            return join(acc, part);
+        }, '');
+    }
+}

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

@@ -0,0 +1,2 @@
+export const RESOURCES_FILE_NAME = 'resources.json';
+export const MAX_REQUEST_FOR_RESOURCES = 3;

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

@@ -0,0 +1,11 @@
+import { AppError } from '../../../cli/class/errors/app_error/app_error.js';
+export class FetchResourcesErrorsFactory {
+    static createErrorFetchingResource(shopUrl, messages) {
+        return new AppError({
+            code: 'theme.fetch_resources.error_fetching_resource',
+            message: `Error while fetching resources from shop "${shopUrl}"`,
+            level: 'error',
+            details: messages
+        });
+    }
+}