@shoper/cli 0.5.2 → 0.6.0

package/build/ui/hooks/stream_hook.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react';
+/**
+ * A React hook that subscribes to a Readable stream and returns an array of data chunks.
+ * @param stream The readable stream to listen to.
+ * @returns An array of strings received from the stream.
+ */
+export function useStream(stream) {
+    const [data, setData] = useState([]);
+    useEffect(() => {
+        // Do nothing if the stream is not provided
+        if (!stream) {
+            return;
+        }
+        const handleData = (chunk) => {
+            // Append the new data chunk to the state
+            setData((prevData) => [...prevData, chunk.toString()]);
+        };
+        // Subscribe to the 'data' event
+        stream.on('data', handleData);
+        // Return a cleanup function to be called on component unmount
+        return () => {
+            stream.removeListener('data', handleData);
+        };
+    }, [stream]); // Re-run the effect if the stream instance changes
+    return data;
+}

package/build/utils/download_file/download_file_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 DownloadFileErrorsFactory {
     static downloadError(status) {
         return new AppError({

package/build/utils/download_file/download_file_utils.js

@@ -5,8 +5,13 @@ import { basename, extname, join, parse } from '../path_utils.js';
 import { FileSystemErrorsFactory } from '../../cli/class/errors/file_system_errors_factory.js';
 import { HttpErrorsFactory } from '../../cli/class/errors/http/http_errors_factory.js';
 import { DownloadFileErrorsFactory } from './download_file_errors_factory.js';
-export const downloadFile = async ({ dist, request }) => {
+export const downloadFile = async ({ dist, request, logger }) => {
     try {
+        logger.debug('Starting file download', {
+            details: {
+                dist
+            }
+        });
         const resp = (await request);
         if (!resp)
             throw resp;
@@ -17,6 +22,12 @@ export const downloadFile = async ({ dist, request }) => {
         resp.data.pipe(file);
         return new Promise((resolve, reject) => {
             file.on('finish', () => {
+                logger.debug('File download completed', {
+                    details: {
+                        dist,
+                        filename
+                    }
+                });
                 resolve({
                     filename,
                     ext: extname(filename),
@@ -24,6 +35,13 @@ export const downloadFile = async ({ dist, request }) => {
                 });
             });
             file.on('error', (err) => {
+                logger.error('Error downloading file', {
+                    error: err,
+                    details: {
+                        dist,
+                        filename
+                    }
+                });
                 if (err.code === 'ENOSPC')
                     reject(FileSystemErrorsFactory.createDiskFullError());
                 reject(DownloadFileErrorsFactory.downloadError(err.response.status));

package/build/utils/fs/errors/stream_read_error.js

@@ -1,11 +1,13 @@
-import { AppError } from '../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
 export class StreamReadError extends AppError {
-    constructor({ filePath, details, stack }) {
+    constructor({ filePath, error }) {
         super({
             code: 'STREAM_READ_ERROR',
-            message: `Error while reading stream for file: ${filePath}`,
-            details,
-            stack
+            message: `Error while reading stream for file`,
+            details: {
+                filePath
+            },
+            error
         });
     }
 }

package/build/utils/fs/errors/stream_write_error.js

@@ -1,11 +1,13 @@
-import { AppError } from '../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
 export class StreamWriteError extends AppError {
-    constructor({ filePath, details, stack }) {
+    constructor({ filePath, error }) {
         super({
             code: 'STREAM_WRITE_ERROR',
-            message: `Error while writing to stream for file: ${filePath}`,
-            details,
-            stack
+            message: `Error while writing to stream for file`,
+            details: {
+                filePath
+            },
+            error
         });
     }
 }

package/build/utils/get_api.js

@@ -0,0 +1,9 @@
+import { API_RESOLVER_QUERIES, AppError, getStarCoreEnvironment, QueryMessage } from '@dreamcommerce/star_core';
+export const getApiSync = (apiName) => {
+    const { queryBus } = getStarCoreEnvironment();
+    const api = queryBus.executeSync(new QueryMessage(API_RESOLVER_QUERIES.getApiSync, apiName));
+    if (!api) {
+        throw new AppError(`${apiName} hasn't been registered`);
+    }
+    return api;
+};

package/build/utils/use_api.js

@@ -0,0 +1,5 @@
+import { API_RESOLVER_QUERIES, getStarCoreEnvironment, QueryMessage } from '@dreamcommerce/star_core';
+export function useApi(apiName) {
+    const { queryBus } = getStarCoreEnvironment();
+    return queryBus.executeSync(new QueryMessage(API_RESOLVER_QUERIES.getApiSync, apiName));
+}

package/build/utils/zip/create_zip_utils.js

@@ -6,10 +6,17 @@ import { StreamReadError } from '../fs/errors/stream_read_error.js';
 import { CreateZipError } from './errors/create_zip_error.js';
 import { StreamWriteError } from '../fs/errors/stream_write_error.js';
 import { join } from '../path_utils.js';
-import { AppError } from '../../cli/class/errors/app/app_error.js';
-export const createZip = async ({ files, dist, baseDir = process.cwd() }) => {
+import { AppError } from '../../cli/utilities/features/logger/logs/app_error.js';
+export const createZip = async ({ files, dist, baseDir = process.cwd(), logger }) => {
     const zipfile = new yazl.ZipFile();
     let hasError = false;
+    logger.debug('Starting creation of zip file', {
+        details: {
+            filesCount: files.length,
+            dist,
+            baseDir
+        }
+    });
     try {
         for (let i = 0; i < files.length; ++i) {
             const file = files[i];
@@ -23,56 +30,61 @@ export const createZip = async ({ files, dist, baseDir = process.cwd() }) => {
                     details: { file, baseDir }
                 });
             if (await isDirectory(fullPath)) {
+                logger.debug('Adding empty directory to zip', { details: { directory: file } });
                 zipfile.addEmptyDirectory(file);
             }
             else {
+                logger.debug('Adding file to zip', { details: { file, fullPath } });
                 zipfile.addFile(fullPath, file, {
                     //TODO params
                     compress: true
                 });
             }
         }
+        logger.debug('Finished adding all files to zip object. Finalizing archive.');
         zipfile.end();
     }
-    catch (err) {
+    catch (error) {
         throw new AppError({
             message: 'Error creating zip file',
             code: 'ZIP_CREATION_ERROR',
             details: { files, dist, baseDir },
-            stack: err instanceof Error ? err.stack : undefined
+            error
         });
     }
     return new Promise((resolve, reject) => {
         const zipOutput = createWriteStream(dist);
         zipOutput.on('error', (err) => {
             hasError = true;
+            logger.debug('Write stream error while creating zip file. Cleaning up.', { details: { dist } });
             removeFiles(files).then(() => {
                 reject(new StreamWriteError({
                     filePath: dist,
-                    details: { err },
-                    stack: err.stack
+                    error: err
                 }));
             });
         });
         zipfile.outputStream.pipe(zipOutput).on('close', () => {
             if (hasError) {
+                logger.debug('Zip stream closed with error. Cleaning up.', { details: { dist } });
                 removeFiles(files).then(() => {
                     reject(new CreateZipError({
                         file: dist,
-                        stack: new Error().stack
+                        error: new Error()
                     }));
                 });
                 return;
             }
+            logger.debug('Zip file created successfully.', { details: { dist } });
             resolve();
         });
         zipfile.outputStream.on('error', (err) => {
             hasError = true;
+            logger.debug('Read stream error while creating zip file. Cleaning up.', { details: { dist } });
             removeFiles(files).then(() => {
                 reject(new StreamReadError({
                     filePath: dist,
-                    details: { err },
-                    stack: err.stack
+                    error: err
                 }));
             });
         });

package/build/utils/zip/errors/create_zip_error.js

@@ -1,11 +1,13 @@
-import { AppError } from '../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
 export class CreateZipError extends AppError {
-    constructor({ details, stack, file }) {
+    constructor({ error, file }) {
         super({
             code: 'ZIP_FILE_CREATE_ERROR',
-            message: `Error creating zip file ${file}`,
-            details,
-            stack
+            message: `Error creating zip file`,
+            details: {
+                file
+            },
+            error
         });
     }
 }

package/build/utils/zip/errors/open_zip_error.js

@@ -1,11 +1,13 @@
-import { AppError } from '../../../cli/class/errors/app/app_error.js';
+import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
 export class OpenZipError extends AppError {
-    constructor({ details, stack, file }) {
+    constructor({ error, file }) {
         super({
             code: 'ZIP_FILE_OPEN_ERROR',
-            message: `Error opening zip file ${file}`,
-            details,
-            stack
+            message: `Error opening zip file`,
+            details: {
+                file
+            },
+            error
         });
     }
 }

package/build/utils/zip/extract_zip_utils.js

@@ -6,21 +6,44 @@ import { StreamWriteError } from '../fs/errors/stream_write_error.js';
 import { StreamReadError } from '../fs/errors/stream_read_error.js';
 import { OpenZipError } from './errors/open_zip_error.js';
 import { pipeline } from 'node:stream/promises';
-export const extractZip = async ({ source, dist, getTransforms = () => [] }) => {
+export const extractZip = async ({ source, dist, logger, getTransforms = () => [] }) => {
     let createdDirectory = false;
+    logger.debug('Starting extraction of zip file', {
+        details: {
+            source,
+            dist
+        }
+    });
     if (!(await directoryExists(dist))) {
         createdDirectory = true;
+        logger.debug('Destination directory does not exist. Creating.', {
+            details: {
+                directory: dist
+            }
+        });
         await makeDirectory(dist, { recursive: true });
     }
     return new Promise((resolve, reject) => {
         const processedFilesPath = [];
-        yauzl.open(source, { lazyEntries: true }, (err, zipfile) => {
-            if (err) {
-                createdDirectory && removeDirectorySync(dist, { recursive: true });
+        yauzl.open(source, { lazyEntries: true }, (error, zipfile) => {
+            logger.debug('Zip file opened for extraction', {
+                details: {
+                    source,
+                    dist
+                }
+            });
+            if (error) {
+                if (createdDirectory) {
+                    logger.debug('Removing created directory due to an error.', {
+                        details: {
+                            directory: dist
+                        }
+                    });
+                    removeDirectorySync(dist, { recursive: true });
+                }
                 return reject(new OpenZipError({
                     file: source,
-                    details: { err },
-                    stack: err.stack
+                    error
                 }));
             }
             let activeEntries = 0;
@@ -31,16 +54,26 @@ export const extractZip = async ({ source, dist, getTransforms = () => [] }) =>
                 const filePath = join(dist, entry.fileName);
                 const dirPath = dirname(filePath);
                 processedFilesPath.push(filePath);
+                logger.debug('Extracting zip entry', {
+                    details: {
+                        entryName: entry.fileName,
+                        filePath: filePath
+                    }
+                });
                 if (!filePath.startsWith(dist)) {
                     return reject(new Error(`Invalid entry path: ${entry.fileName}`));
                 }
                 if (looksLikeDirectory(entry.fileName)) {
+                    logger.debug('Entry looks like a directory, skipping file write.', {
+                        details: {
+                            entry: entry.fileName
+                        }
+                    });
                     zipfile.readEntry();
                     return;
                 }
-                if (extractedPaths.has(filePath)) {
+                if (extractedPaths.has(filePath))
                     return reject(new Error(`Duplicate entry path detected: ${filePath}`));
-                }
                 extractedPaths.add(filePath);
                 makeDirectory(dirPath, { recursive: true })
                     .then(() => {
@@ -50,31 +83,58 @@ export const extractZip = async ({ source, dist, getTransforms = () => [] }) =>
                         const writeStream = createWriteStream(filePath);
                         writeStream.on('finish', () => {
                             activeEntries--;
-                            if (activeEntries === 0 && doneReadingEntries)
+                            logger.debug('Finished writing file.', {
+                                details: {
+                                    file: filePath,
+                                    activeEntries
+                                }
+                            });
+                            if (activeEntries === 0 && doneReadingEntries) {
+                                logger.debug('All entries processed and written.');
                                 resolve();
+                            }
                             zipfile.readEntry();
                         });
                         writeStream.on('error', async (err) => {
+                            logger.debug('Write stream error. Removing file.', {
+                                details: {
+                                    file: filePath
+                                }
+                            });
                             await removeFile(filePath);
                             reject(new StreamWriteError({
                                 filePath,
-                                details: { err },
-                                stack: err.stack
+                                error: err
                             }));
                         });
                         readStream.on('error', async (err) => {
+                            logger.debug('Read stream error. Removing file.', {
+                                details: {
+                                    file: filePath
+                                }
+                            });
                             await removeFile(filePath, { force: true });
                             reject(new StreamReadError({
                                 filePath,
-                                details: { err },
-                                stack: err.stack
+                                error: err
                             }));
                         });
                         const transforms = getTransforms(entry.fileName);
                         if (transforms.length) {
+                            logger.debug('Applying transform(s) to entry.', {
+                                details: {
+                                    transformsCount: transforms.length,
+                                    entry: entry.fileName
+                                }
+                            });
                             await pipeline(readStream, ...transforms, writeStream);
                         }
                         else {
+                            logger.debug('No transforms for entry. Piping directly.', {
+                                details: {
+                                    entry: entry.fileName
+                                }
+                            });
                             readStream.pipe(writeStream);
                         }
                     });
@@ -83,19 +143,34 @@ export const extractZip = async ({ source, dist, getTransforms = () => [] }) =>
             });
             zipfile.on('end', () => {
                 doneReadingEntries = true;
-                if (activeEntries === 0)
+                logger.debug('Finished reading all zip entries.');
+                if (activeEntries === 0) {
+                    logger.debug('All entries were processed before zip file "end" event.');
                     resolve();
+                }
             });
             zipfile.on('error', async (err) => {
                 for (const filePath of processedFilesPath) {
                     try {
+                        logger.debug('Cleaning up extracted file due to an error.', {
+                            details: {
+                                file: filePath
+                            }
+                        });
                         await removeFile(filePath, { force: true });
                     }
                     catch (removeErr) {
                         console.error(`Error removing file ${filePath}:`, removeErr);
                     }
                 }
-                createdDirectory && (await removeDirectory(dist, { recursive: true }));
+                if (createdDirectory) {
+                    logger.debug('Cleaning up created directory due to an error.', {
+                        details: {
+                            directory: dist
+                        }
+                    });
+                    await removeDirectory(dist, { recursive: true });
+                }
                 reject(err);
             });
             zipfile.readEntry();

package/oclif.config.js

@@ -3,6 +3,7 @@ export default {
     scope: 'shoper',
     dirname: 'shoper_cli',
     plugins: ['@oclif/plugin-help', '@oclif/plugin-warn-if-update-available', '@oclif/plugin-version'],
+    helpClass: './build/cli/class/cli_help.js',
     'warn-if-update-available': {
         frequency: 1,
         frequencyUnit: 'days',
@@ -21,7 +22,8 @@ export default {
             './build/theme/hooks/ensure_theme_meta_data_untouched_hook.js',
             './build/theme/hooks/theme_checksums/ensure_theme_current_checksums_up_to_date_hook.js',
             './build/theme/hooks/themes_actions/ensure_themes_actions_hook.js'
-        ]
+        ],
+        finally: ['./build/cli/hooks/ensure_logs_flushed_hook.js']
     },
     topicSeparator: ' ',
     topics: {

package/package.json

@@ -2,10 +2,15 @@
     "name": "@shoper/cli",
     "packageManager": "yarn@3.2.0",
     "sideEffects": false,
-    "version": "0.5.2",
+    "version": "0.6.0",
     "description": "CLI tool for Shoper",
     "author": "Joanna Firek",
     "license": "MIT",
+    "keywords": [
+        "shoper",
+        "shoper-cli",
+        "shoper-for-developers"
+    ],
     "bin": {
         "shoper": "./bin/run.js"
     },
@@ -39,7 +44,7 @@
         "@oclif/plugin-help": "6.2.27",
         "@oclif/plugin-version": "2.2.27",
         "@oclif/plugin-warn-if-update-available": "3.1.38",
-        "axios": "1.8.4",
+        "axios": "1.13.1",
         "chalk": "5.4.1",
         "conf": "13.1.0",
         "fast-glob": "3.3.3",
@@ -48,6 +53,7 @@
         "fs-tree-diff": "2.0.1",
         "ink": "6.0.1",
         "ink-link": "4.1.0",
+        "ink-gradient": "3.0.0",
         "inquirer": "12.5.2",
         "inquirer-select-line": "1.1.3",
         "is-hidden-file": "1.1.2",
@@ -57,6 +63,8 @@
         "log-symbols": "7.0.1",
         "memfs": "4.17.0",
         "ora": "8.2.0",
+        "pino": "10.1.0",
+        "pino-pretty": "13.1.2",
         "react": "19.1.0",
         "reflect-metadata": "0.2.2",
         "rxjs": "7.8.2",
@@ -66,7 +74,8 @@
         "uuid": "11.1.0",
         "walk-sync": "3.0.0",
         "yauzl": "3.2.0",
-        "yazl": "3.3.1"
+        "yazl": "3.3.1",
+        "figlet": "1.9.4"
     },
     "devDependencies": {
         "@babel/core": "7.27.1",
@@ -87,7 +96,7 @@
         "@types/yazl": "2.4.6",
         "@typescript-eslint/eslint-plugin": "8.29.1",
         "babel-jest": "29.7.0",
-        "eslint": "9.24.0",
+        "eslint": "9.39.1",
         "eslint-config-prettier": "10.1.1",
         "eslint-plugin-prettier": "5.2.6",
         "jest": "29.7.0",

package/build/cli/class/errors/app/app_error.js

@@ -1,17 +0,0 @@
-import { APP_ERRORS_LEVELS } from './app_error_constants.js';
-//TODO errory do zaprojektownia
-export class AppError extends Error {
-    code;
-    level;
-    tags;
-    details;
-    stack;
-    constructor({ code, details, message, level = APP_ERRORS_LEVELS.error, tags, stack }) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.level = level;
-        this.tags = tags;
-        this.stack = stack;
-    }
-}