@shoper/cli 0.5.2-5 → 0.5.2-7

package/build/cli/utilities/features/logger/logger_initializer.js

@@ -0,0 +1,44 @@
+import { AsyncFeatureInitializer, FEATURE_CORES_TYPES } from '@dreamcommerce/star_core';
+import { LoggerService } from './service/logger_service.js';
+import { LoggerApi } from './api/logger_api.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../features/execution_context/execution_context_constants.js';
+import { LOGGER_DEBUG_MODES, LOGGER_FEATURE_NAME } from './logger_constants.js';
+import { CLI_VERSION_API_NAME } from '../../../features/version/cli_version_constants.js';
+import { join } from '../../../../utils/path_utils.js';
+export class LoggerInitializer extends AsyncFeatureInitializer {
+    static featureName = LOGGER_FEATURE_NAME;
+    async init() {
+        const executionContextApi = this.getApiSync(EXECUTION_CONTEXT_API_NAME);
+        const cliVersionApi = this.getApiSync(CLI_VERSION_API_NAME);
+        const executionContext = await executionContextApi.getExecutionContext();
+        const service = new LoggerService({
+            executionContext,
+            cliVersion: await cliVersionApi.getGloballyInstalledVersion(),
+            debugMode: this._getDebugMode(executionContext.command),
+            logFile: this.getLogFilePath(executionContext)
+        });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new LoggerApi(service)
+                }
+            ]
+        };
+    }
+    _getDebugMode(command) {
+        if (command.includes('--vv'))
+            return LOGGER_DEBUG_MODES.detailed;
+        if (command.includes('--v'))
+            return LOGGER_DEBUG_MODES.standard;
+        return LOGGER_DEBUG_MODES.none;
+    }
+    getLogFilePath(executionContext) {
+        const logFileName = 'shoper_cli_debug_log.json';
+        if (executionContext.command.includes('--log-file')) {
+            return executionContext.type === EXECUTION_CONTEXTS.theme
+                ? join(executionContext.themeRootDir, logFileName)
+                : join(process.cwd(), logFileName);
+        }
+    }
+}

package/build/cli/utilities/features/logger/logs/app_error.js

@@ -0,0 +1,14 @@
+import { AppLog } from './app_log.js';
+import { APP_LOGS_TYPES } from './app_logs_constants.js';
+export class AppError extends AppLog {
+    constructor({ details, message, level = APP_LOGS_TYPES.error, tags, error, code }) {
+        super({ message, level, tags, details });
+        this.tags = {
+            ...tags,
+            code
+        };
+        this.level = level;
+        if (error?.stack)
+            this.stacktrace = error.stack;
+    }
+}

package/build/cli/utilities/features/logger/logs/app_log.js

@@ -0,0 +1,40 @@
+export class AppLog {
+    level;
+    message;
+    user;
+    /**
+     * Example:
+     * {
+     *     userId: 123,
+     *     shopId: 456,
+     * }
+     */
+    stacktrace;
+    // jakie wartosci dopuszczamy w value tagu?
+    tags;
+    /**
+     * Example:
+     * {
+     *     // always added tags:
+     *     environment: 'MacOS',
+     *     appVersion: '1.0.0',
+     *     nodeVersion: 'v16.0.0',
+     *     traceId: 'unique-trace-id',
+     *     command: 'theme init 2'
+     *     // other tags not always added, spefic to the log, EXAMPLE ONLY added quickly:
+     *     errorCode: 'E_THEME_NOT_FOUND',
+     *     filePath: '/path/to/file',
+     *     responseTimeMs: 250,
+     * }
+     */
+    details;
+    // user timestamp in ISO format or server timestamp added when proxied to elastic?
+    timestamp = new Date().toISOString();
+    constructor({ details, message, level, tags, stacktrace }) {
+        this.details = details;
+        this.message = message;
+        this.level = level;
+        this.tags = tags;
+        this.stacktrace = stacktrace;
+    }
+}

package/build/cli/{class/errors/app/app_error_constants.js → utilities/features/logger/logs/app_logs_constants.js}

@@ -1,4 +1,4 @@
-export const APP_ERRORS_LEVELS = {
+export const APP_LOGS_TYPES = {
     fatal: 'fatal',
     error: 'error',
     warn: 'warn',

package/build/cli/utilities/features/logger/service/logger_service.js

@@ -0,0 +1,108 @@
+import pino from 'pino';
+import os from 'node:os';
+import { v4 as uuid } from 'uuid';
+import { LOGGER_DEBUG_MODES } from '../logger_constants.js';
+export class LoggerService {
+    #logger;
+    #transport;
+    #traceId = uuid();
+    #executionContext;
+    #cliVersion;
+    constructor({ executionContext, cliVersion, debugMode, logFile }) {
+        this.#executionContext = executionContext;
+        this.#cliVersion = cliVersion;
+        const { logger, transport } = this._getLoggerInstance(debugMode, logFile);
+        this.#logger = logger;
+        this.#transport = transport;
+    }
+    _getLoggerInstance(debugMode, logFile) {
+        const targets = [];
+        if (logFile) {
+            targets.push({
+                target: 'pino/file',
+                level: 'debug',
+                options: {
+                    destination: logFile,
+                    mkdir: true,
+                    append: false
+                }
+            });
+        }
+        const prettyTransport = {
+            target: 'pino-pretty',
+            options: {
+                messageKey: 'message',
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: debugMode === LOGGER_DEBUG_MODES.standard
+                    ? 'pid,hostname,message,traceId,cliVersion,nodeVersion,environment,command,details'
+                    : ''
+            }
+        };
+        /*
+         * To bd potem zastąpine customowym transportem który wysyła logi do backendu
+         */
+        // const logObjectMapTransport = {
+        //     target: '../transports/log_object_map_transport.js',
+        //     options: {
+        //         traceId: this.#traceId
+        //     }
+        // };
+        // TODO docelowo logObjectMapTransport bd wysyłał logi do serwera jezeli bedzie gdzies error a apce
+        // targets: debugMode !== LOGGER_DEBUG_MODES.none ? [prettyTransport, logObjectMapTransport] : [logObjectMapTransport]
+        if (debugMode !== LOGGER_DEBUG_MODES.none) {
+            targets.push(prettyTransport);
+        }
+        const transport = targets.length
+            ? pino.transport({
+                targets
+            })
+            : undefined;
+        /**
+         * Przy dodawaniu logowania na backend trzeba to usunac
+         */
+        if (!transport)
+            return {};
+        const logger = pino({
+            level: 'debug',
+            base: {
+                pid: process.pid,
+                hostname: os.hostname(),
+                cliVersion: this.#cliVersion,
+                nodeVersion: process.version,
+                environment: os.type(),
+                command: this.#executionContext.command.slice(2).join(' '),
+                traceId: this.#traceId
+            },
+            timestamp: pino.stdTimeFunctions.isoTime,
+            messageKey: 'message'
+        }, transport);
+        return { logger, transport };
+    }
+    debug(message, props) {
+        this.#logger?.debug(props || {}, message);
+    }
+    info(message, props) {
+        this.#logger?.info(props || {}, message);
+    }
+    warn(message, props) {
+        this.#logger?.warn(props || {}, message);
+    }
+    error(message, props) {
+        this.#logger?.error(props || {}, message);
+    }
+    fatal(message, props) {
+        this.#logger?.fatal(props || {}, message);
+    }
+    async flush() {
+        if (!this.#transport || this.#transport?.destroyed) {
+            return;
+        }
+        return new Promise((resolve) => {
+            // The 'close' event is emitted when the stream has been fully closed.
+            this.#transport?.on('close', resolve);
+            this.#logger?.flush(); // Synchronously flush buffered logs
+            this.#transport?.end(); // End the stream, which will trigger 'close'
+        });
+    }
+}

package/build/cli/utilities/features/logger/transports/log_object_map_transport.js

@@ -1,22 +1,15 @@
-// import { Writable } from 'node:stream';
-//
-// export default async function (opts) {
-//     console.log('opts', opts);
-//
-//     return new Writable({
-//         objectMode: true,
-//         write(chunk, enc, cb) {
-//             const mapped = mapLog(chunk);
-//
-//             cb();
-//
-//             return mapped;
-//         }
-//     });
-// }
-//
-// function mapLog(obj) {
-//     //TODO map for backend structure
-//     return obj;
-// }
-export {};
+import { Writable } from 'node:stream';
+export default async function (opts) {
+    return new Writable({
+        objectMode: true,
+        write(chunk, enc, cb) {
+            const mapped = mapLog(chunk);
+            cb();
+            return mapped;
+        }
+    });
+}
+function mapLog(obj) {
+    //TODO map for backend structure
+    return obj;
+}

package/build/index.js

@@ -9,6 +9,8 @@ import { CliAuthRemoveTokenCommand } from './cli/commands/auth/cli_auth_remove_t
 import { CliAuthSwitchTokenCommand } from './cli/commands/auth/cli_auth_switch_token_command.js';
 import { CliUIDumpCommand } from './cli/commands/cli_ui_dump_command.js';
 import { CliAuthLogoutCommand } from './cli/commands/auth/cli_auth_logout_command.js';
+import { getApiSync } from './utils/get_api.js';
+import { LOGGER_API_NAME } from './cli/utilities/features/logger/logger_constants.js';
 //TODO
 //@ts-ignore
 if (typeof global.crypto !== 'object') {
@@ -24,12 +26,21 @@ function getRandomValues(array) {
     return crypto.webcrypto.getRandomValues(array);
 }
 process.on('uncaughtException', (err) => {
-    //TODO handle error
     console.error('Uncaught Exception:', err);
+    const loggerApi = getApiSync(LOGGER_API_NAME);
+    if (loggerApi)
+        loggerApi.fatal('Uncaught Exception', { error: err });
     process.exit(1);
 });
-process.on('unhandledRejection', (reason, promise) => {
+process.on('unhandledRejection', (reason) => {
     console.error('Unhandled Rejection:', reason);
+    const loggerApi = getApiSync(LOGGER_API_NAME);
+    if (loggerApi)
+        loggerApi.fatal('Unhandled Rejection', {
+            details: {
+                reason
+            }
+        });
     process.exit(1);
 });
 const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];

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

@@ -0,0 +1,45 @@
+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, logger }) {
+        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,
+                logger,
+                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/{features/theme/utils/archive/theme_archive_utils_errors_factory.js → class/archive/theme_archive_errors_factory.js}

@@ -1,11 +1,11 @@
-import { AppError } from '../../../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../cli/utilities/features/logger/logs/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
+            error
         });
     }
 }

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

@@ -10,17 +10,18 @@ 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';
-import { FILE_STATES } from '../../../utils/fs/fs_constants.js';
 export class ThemeChecksums {
     #themeDir;
+    #loggerApi;
     #currentChecksumsFilePath;
     #currentChecksumsVerificationFilePath;
     #initialChecksumsFilePath;
     #initialChecksumsVerificationFilePath;
     #initialChecksums;
     #currentChecksums;
-    constructor(themeDir) {
+    constructor({ loggerApi, themeDir }) {
         this.#themeDir = themeDir;
+        this.#loggerApi = loggerApi;
         this.#currentChecksumsFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsFilePath(themeDir);
         this.#currentChecksumsVerificationFilePath = ThemeChecksumsUtils.getCurrentThemeChecksumsVerificationFilePath(themeDir);
         this.#initialChecksumsFilePath = ThemeChecksumsUtils.getInitialThemeChecksumsFilePath(themeDir);
@@ -32,6 +33,12 @@ export class ThemeChecksums {
         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;
@@ -65,22 +72,10 @@ export class ThemeChecksums {
         const initialChecksum = await this.getInitialChecksumFromPath(path);
         return !initialChecksum && (await fileExists(join(this.#themeDir, path)));
     }
-    async getFileState(path) {
-        const initialChecksum = await this.getInitialChecksumFromPath(path);
+    async hasThemeFileBeenModified(path) {
         const currentChecksum = await this.getCurrentChecksumFromPath(path);
-        const fileExistsInFs = await fileExists(join(this.#themeDir, path));
-        if (!initialChecksum && fileExistsInFs) {
-            return FILE_STATES.created;
-        }
-        else if (initialChecksum && !fileExistsInFs) {
-            return FILE_STATES.deleted;
-        }
-        else if (initialChecksum && currentChecksum && initialChecksum !== currentChecksum) {
-            return FILE_STATES.modified;
-        }
-        else {
-            return FILE_STATES.unchanged;
-        }
+        const initialChecksum = await this.getInitialChecksumFromPath(path);
+        return !!currentChecksum && !!initialChecksum && currentChecksum !== initialChecksum;
     }
     async verify() {
         const initialChecksumFilePath = this.#initialChecksumsFilePath;
@@ -90,6 +85,7 @@ export class ThemeChecksums {
         return initialChecksum === initialChecksumVerify;
     }
     async updateAllChecksums() {
+        this.#loggerApi?.debug('Updating all checksums.');
         const checksums = await this.computeThemeChecksums();
         return new Promise((resolve, reject) => {
             const currentChecksumFilePath = this.#currentChecksumsFilePath;
@@ -99,20 +95,24 @@ export class ThemeChecksums {
             checksumStream.end();
             checksumStream
                 .on('finish', async () => {
+                this.#loggerApi?.debug('Finished writing initial checksums file. Creating verification files.');
                 const initialChecksumVerifyFilePath = this.#initialChecksumsVerificationFilePath;
                 const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
                 await this._createThemeChecksumVerifyFile(initialChecksumFilePath, initialChecksumVerifyFilePath);
                 await copyFile(initialChecksumFilePath, currentChecksumFilePath);
                 await copyFile(initialChecksumVerifyFilePath, currentChecksumVerifyFilePath);
+                this.#loggerApi?.debug('All checksums and verification files updated.');
                 resolve();
             })
                 .on('error', async (err) => {
+                this.#loggerApi?.debug('Error writing checksums file. Cleaning up.', { details: { file: initialChecksumFilePath } });
                 await removeFile(initialChecksumFilePath, { force: true });
-                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err));
             });
         });
     }
     async updateCurrentChecksums() {
+        this.#loggerApi?.debug('Updating current checksums.');
         const checksums = await this.computeThemeChecksums();
         return new Promise((resolve, reject) => {
             const currentChecksumFilePath = this.#currentChecksumsFilePath;
@@ -121,17 +121,23 @@ export class ThemeChecksums {
             checksumStream.end();
             checksumStream
                 .on('finish', async () => {
+                this.#loggerApi?.debug('Finished writing current checksums file. Creating verification file.');
                 const currentChecksumVerifyFilePath = this.#currentChecksumsVerificationFilePath;
                 await this._createThemeChecksumVerifyFile(currentChecksumFilePath, currentChecksumVerifyFilePath);
+                this.#loggerApi?.debug('Current checksums and verification file updated.');
                 resolve();
             })
                 .on('error', async (err) => {
+                this.#loggerApi?.debug('Error writing current checksums file. Cleaning up.', {
+                    details: { file: currentChecksumFilePath }
+                });
                 await removeFile(currentChecksumFilePath, { force: true });
-                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack));
+                reject(ThemeChecksumsErrorFactory.createThemeChecksumError(err));
             });
         });
     }
     async computeThemeChecksums() {
+        this.#loggerApi?.debug('Computing theme checksums.');
         const filesToIgnoreInChecksums = [
             join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_FILE_NAME),
             join(SHOPER_THEME_METADATA_DIR, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME),
@@ -141,40 +147,12 @@ export class ThemeChecksums {
         const filesToComputeChecksums = (await ThemePushUtils.getAllFilesThatAreSendToRemote(this.#themeDir))
             .filter((path) => !filesToIgnoreInChecksums.some((ignorePath) => normalize(path) === ignorePath))
             .map((relativePath) => join(this.#themeDir, relativePath));
+        this.#loggerApi?.debug('Computing checksums from file structure.', { details: { count: filesToComputeChecksums.length } });
         const { filesChecksumsInDirectories, filesChecksums } = await computeChecksumsFromFilesStructure(filesToComputeChecksums, this.#themeDir);
         const directoriesChecksums = computeDirectoriesChecksums(filesChecksumsInDirectories);
-        return { ...filesChecksums, ...directoriesChecksums };
-    }
-    async groupFilesByStatus(files) {
-        const initialChecksums = await this.getInitialChecksums();
-        const currentChecksums = await this.getCurrentChecksums();
-        return files.reduce((acc, filePath) => {
-            const initialChecksum = initialChecksums[toCurrentPlatformPath(filePath)];
-            const currentChecksum = currentChecksums[toCurrentPlatformPath(filePath)];
-            if (!initialChecksum) {
-                acc.created.push(filePath);
-            }
-            else if (currentChecksum && initialChecksum !== currentChecksum) {
-                acc.modified.push(filePath);
-            }
-            else if (initialChecksum && !currentChecksum) {
-                acc.deleted.push(filePath);
-            }
-            else {
-                acc.unchanged.push(filePath);
-            }
-            return acc;
-        }, {
-            created: [],
-            modified: [],
-            unchanged: [],
-            deleted: []
-        });
-    }
-    async getDeletedFiles() {
-        const initialChecksums = await this.getInitialChecksums();
-        const currentChecksums = await this.getCurrentChecksums();
-        return Object.keys(initialChecksums).filter((filePath) => !currentChecksums[filePath]);
+        const allChecksums = { ...filesChecksums, ...directoriesChecksums };
+        this.#loggerApi?.debug('Finished computing theme checksums.', { details: { count: Object.keys(allChecksums).length } });
+        return allChecksums;
     }
     async _getInitialChecksumsVerification() {
         return await readJSONFile(this.#initialChecksumsVerificationFilePath);
@@ -195,12 +173,16 @@ export class ThemeChecksums {
         return mapKeysPathsToWindowPlatform(checksums);
     }
     async _createThemeChecksumVerifyFile(checksumFilePath, checksumVerifyFullPath) {
+        this.#loggerApi?.debug('Creating checksum verification file.', { details: { path: checksumVerifyFullPath } });
         const checksumVerifyStream = createWriteStream(checksumVerifyFullPath);
         const checksumVerify = await computeFileChecksum(checksumFilePath);
         checksumVerifyStream
             .on('error', async (err) => {
+            this.#loggerApi?.debug('Error creating checksum verification file. Cleaning up.', {
+                details: { file: checksumFilePath }
+            });
             await removeFile(checksumFilePath, { force: true });
-            throw ThemeChecksumsErrorFactory.createThemeChecksumError(err.stack);
+            throw ThemeChecksumsErrorFactory.createThemeChecksumError(err);
         })
             .write(JSON.stringify(checksumVerify));
         checksumVerifyStream.end();

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

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

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

@@ -12,16 +12,23 @@ import { move } from 'fs-extra';
 export class FetchResources {
     #urlsAttempts = {};
     #httpApi;
-    constructor(httpApi) {
+    #loggerApi;
+    constructor({ httpApi, loggerApi }) {
         this.#httpApi = httpApi;
+        this.#loggerApi = loggerApi;
     }
     async fetchResources({ dist, resourcesPart, parts, shopUrl }) {
+        this.#loggerApi.debug('Traversing resources part.', { details: { parts } });
         if (Array.isArray(resourcesPart)) {
             for (let i = 0; i < resourcesPart.length; i++) {
                 const resource = resourcesPart[i];
                 if (isResourceObject(resource)) {
+                    const resourceUrl = isRelativeUrl(resource.url) ? `${shopUrl}${resource.url}` : resource.url;
+                    this.#loggerApi.debug('Found resource object. Fetching resource.', {
+                        details: { url: resourceUrl, parts: [...parts, i] }
+                    });
                     await this._fetchResource({
-                        url: isRelativeUrl(resource.url) ? `${shopUrl}${resource.url}` : resource.url,
+                        url: resourceUrl,
                         dist,
                         parts: [...parts, i],
                         shopUrl,
@@ -40,8 +47,12 @@ export class FetchResources {
         }
         if (typeof resourcesPart === 'object') {
             if (isResourceObject(resourcesPart)) {
+                const resourceUrl = isRelativeUrl(resourcesPart.url) ? `${shopUrl}${resourcesPart.url}` : resourcesPart.url;
+                this.#loggerApi.debug('Found resource object. Fetching resource.', {
+                    details: { url: resourceUrl, parts }
+                });
                 await this._fetchResource({
-                    url: isRelativeUrl(resourcesPart.url) ? `${shopUrl}${resourcesPart.url}` : resourcesPart.url,
+                    url: resourceUrl,
                     dist,
                     parts,
                     shopUrl,
@@ -61,6 +72,7 @@ export class FetchResources {
         return;
     }
     async _getResourcesFileContent(resourcePath) {
+        this.#loggerApi.debug('Reading and mapping resources file content.', { details: { resourcePath } });
         return mapResourcesToTree(await readJSONFile(resourcePath));
     }
     _getResourcesPart(resources, parts) {
@@ -68,28 +80,42 @@ export class FetchResources {
     }
     async _fetchResource({ url, shopUrl, parts, dist, isPrivate }) {
         this.#urlsAttempts[url] = (this.#urlsAttempts[url] ?? 0) + 1;
+        this.#loggerApi.debug('Fetching resource.', {
+            details: { url, attempt: this.#urlsAttempts[url], parts, isPrivate }
+        });
         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' });
+        this.#loggerApi.debug('Created temporary directory for resource fetch.', { details: { tmpDir, url } });
         try {
+            this.#loggerApi.debug('Downloading resource file.', { details: { url, dist: tmpDir } });
             const { filename, ext, basename } = await downloadFile({
                 dist: tmpDir,
+                logger: this.#loggerApi,
                 request: this._getRequest({ url, isPrivate }).response
             });
+            this.#loggerApi.debug('Resource file downloaded.', { details: { url, filename } });
             if (ext === '.zip') {
+                this.#loggerApi.debug('Resource is a zip archive. Extracting.', { details: { source: filename, dist: basename } });
                 await extractZip({
+                    logger: this.#loggerApi,
                     source: join(tmpDir, filename),
                     dist: join(tmpDir, basename)
                 });
+                this.#loggerApi.debug('Zip archive extracted.', { details: { filename } });
                 if (!(await fileExists(getResourcesPath(join(tmpDir, basename)))))
                     return;
+                this.#loggerApi.debug('Copying extracted files.', {
+                    details: { from: join(tmpDir, basename), to: dist }
+                });
                 await copyFile(join(tmpDir, basename), dist, {
                     recursive: true,
                     force: true
                 });
                 const newResources = await this._getResourcesFileContent(getResourcesPath(join(tmpDir, basename)));
+                this.#loggerApi.debug('Recursively fetching resources from extracted archive.', { details: { parts } });
                 await this.fetchResources({
                     dist,
                     resourcesPart: this._getResourcesPart(newResources, parts),
@@ -98,7 +124,11 @@ export class FetchResources {
                 });
             }
             else {
-                await move(join(tmpDir, filename), join(dist, this._getFilepathFromParts(parts), filename), { overwrite: true });
+                const destinationPath = join(dist, this._getFilepathFromParts(parts), filename);
+                this.#loggerApi.debug('Moving downloaded file.', {
+                    details: { from: join(tmpDir, filename), to: destinationPath }
+                });
+                await move(join(tmpDir, filename), destinationPath, { overwrite: true });
             }
         }
         catch (err) {

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

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