@shoper/cli 0.5.2 → 0.6.1

package/build/cli/utilities/features/logger/api/logger_api.js

@@ -0,0 +1,28 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { LOGGER_API_NAME } from '../logger_constants.js';
+export class LoggerApi extends FeatureApi {
+    moduleName = LOGGER_API_NAME;
+    #service;
+    constructor(loggerService) {
+        super();
+        this.#service = loggerService;
+    }
+    debug(message, props) {
+        this.#service.debug(message, props);
+    }
+    info(message, props) {
+        this.#service.info(message, props);
+    }
+    warn(message, props) {
+        this.#service.warn(message, props);
+    }
+    error(message, props) {
+        this.#service.error(message, props);
+    }
+    fatal(message, props) {
+        this.#service.fatal(message, props);
+    }
+    async flush() {
+        await this.#service.flush();
+    }
+}

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

@@ -0,0 +1,7 @@
+export const LOGGER_FEATURE_NAME = 'LoggerFeature';
+export const LOGGER_API_NAME = 'LoggerApi';
+export const LOGGER_DEBUG_MODES = {
+    none: 'none',
+    standard: 'standard',
+    detailed: 'detailed'
+};

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

@@ -0,0 +1,15 @@
+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,9 @@ 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';
+import './cli/class/cli_help.js';
 //TODO
 //@ts-ignore
 if (typeof global.crypto !== 'object') {
@@ -24,12 +27,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

@@ -11,7 +11,7 @@ export class ThemeArchive {
     constructor(themeRootDir) {
         this.#themeRootDir = themeRootDir;
     }
-    async createFullArchive({ dist, actionValue, actionType }) {
+    async createFullArchive({ dist, actionValue, actionType, logger }) {
         const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(this.#themeRootDir);
         if (!filesStructure)
             throw ThemeFileStructureErrorsFactory.createNoFilesStructureError();
@@ -28,6 +28,7 @@ export class ThemeArchive {
             await this._formatJsonFiles(this.#themeRootDir, filesInThemeDirectory);
             return createZip({
                 files: filesInThemeDirectory,
+                logger,
                 baseDir: this.#themeRootDir,
                 dist
             });

package/build/theme/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

@@ -12,14 +12,16 @@ import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.
 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;
+    #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);
@@ -83,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;
@@ -92,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;
@@ -114,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),
@@ -134,9 +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 };
+        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);
@@ -157,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({

package/build/theme/commands/delete/theme_delete_command.js

@@ -16,6 +16,7 @@ import { ThemeDeletedSuccessfully } from './ui/theme_deleted_successfully.js';
 import { ThemeDeletionWarning } from './ui/theme_deletion_warning.js';
 import { promptConfirmation } from '../../../ui/prompts/prompt_confirmation.js';
 import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeDeleteCommand extends BaseThemeCommand {
     static summary = 'Permanently deletes the specified theme from your store.';
     static description = 'This action cannot be undone, so make sure you really want to remove this theme.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).';
@@ -37,6 +38,7 @@ export class ThemeDeleteCommand extends BaseThemeCommand {
         const themeId = this.args.id;
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         if (!credentials) {
             renderOnce(React.createElement(MissingCredentialsError, null));
@@ -86,11 +88,10 @@ export class ThemeDeleteCommand extends BaseThemeCommand {
             if (!resp?.isSuccess)
                 return;
             renderOnce(React.createElement(ThemeDeletedSuccessfully, null));
-            return;
         }
         catch (err) {
+            loggerApi.error('Error executing theme delete command', { error: err });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
-            return;
         }
     }
 }

package/build/theme/commands/info/theme_info_command.js

@@ -15,6 +15,7 @@ import { ThemeInfoCommandUtils } from './theme_info_command_utils.js';
 import { InvalidThemeIdError } from '../ui/invalid_theme_id.js';
 import { Box } from '../../../ui/box.js';
 import { ThemeError } from '../ui/theme_error.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeInfoCommand extends BaseThemeCommand {
     static summary = 'View details about the current theme.';
     static description = 'Displays key information about the theme you’re working on — including its ID, name, description (if provided), and status.\n\nYou can run this command from a specific theme directory (ID not needed) or outside any theme directory (theme ID required).';
@@ -36,6 +37,7 @@ export class ThemeInfoCommand extends BaseThemeCommand {
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
         const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
         const themesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const loggerApi = this.getApi(LOGGER_API_NAME);
         const credentials = cliAuthApi.getCredentials();
         if (!credentials) {
             renderOnce(React.createElement(MissingCredentialsError, null));
@@ -70,6 +72,7 @@ export class ThemeInfoCommand extends BaseThemeCommand {
             this._displayThemeInfo(theme);
         }
         catch (err) {
+            loggerApi.error('An error occurred while fetching theme info.', { error: err });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
     }