@shoper/cli 0.5.2-4 → 0.5.2-6

package/build/theme/features/theme/utils/{files/theme_files_utils.js → files_structure/theme_files_structure_utils.js}

@@ -1,4 +1,4 @@
-import { fileExists, isDirectory, readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
 import { join, looksLikeDirectory, mapKeysPathsToWindowPlatform, toUnixPath } from '../../../../../utils/path_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_FILES_STRUCTURE_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME } from '../../theme_constants.js';
@@ -7,8 +7,7 @@ import { validateDirectory } from '../../../../utils/directory_validator/directo
 import path from 'node:path';
 import { THEME_FILES_LIST_FILE_NAME } from '../../push/theme_push_constants.js';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
-export class ThemeFilesUtils {
+export class ThemeFilesStructureUtils {
     static async getThemeFilesStructure(themeDirectory) {
         const filesStructure = await readJSONFile(join(themeDirectory, SHOPER_THEME_METADATA_DIR, THEME_FILES_STRUCTURE_FILE_NAME));
         if (!isWindowsOs())
@@ -20,7 +19,7 @@ export class ThemeFilesUtils {
         await writeJSONFile(filePath, filesStructure);
     }
     static async getFilesPermissions(themeDirectory) {
-        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
+        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
         return Object.entries(fileStructure).reduce((acc, [key, value]) => {
             return {
                 ...acc,
@@ -36,25 +35,14 @@ export class ThemeFilesUtils {
         });
     }
     static async getThemeRootDirectories(themeDirectory) {
-        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
+        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
         return Object.keys(filesStructure).filter((path) => {
             return looksLikeDirectory(path);
         });
     }
     static mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded = {}) {
-        let areAllSkinstoreFilesUnchanged = true;
-        const filesList = filesRecords.reduce((acc, { fileGlob, fileName, state, actionKey }) => {
+        const mappedFilesRecords = filesRecords.reduce((acc, { fileGlob, fileName }) => {
             const name = localFileNameToUploaded[fileName] ?? fileName;
-            if (state === FILE_STATES.deleted && actionKey === 'thumbnail') {
-                return {
-                    ...acc,
-                    [fileGlob]: null
-                };
-            }
-            if (actionKey === 'skinstore_files' && state !== FILE_STATES.unchanged)
-                areAllSkinstoreFilesUnchanged = false;
-            if (state === FILE_STATES.deleted || (state === FILE_STATES.unchanged && actionKey !== 'skinstore_files'))
-                return acc;
             if (looksLikeDirectory(fileGlob)) {
                 const existingFiles = acc[fileGlob] || [];
                 return {
@@ -69,31 +57,32 @@ export class ThemeFilesUtils {
                 };
             }
         }, {});
-        if (areAllSkinstoreFilesUnchanged)
-            delete filesList['skinstore/files'];
-        return filesList;
+        /*
+         * Brzydki fix, poprawione w partial push na ładniej
+         */
+        if (!mappedFilesRecords['settings/thumbnail.jpg']) {
+            mappedFilesRecords['settings/thumbnail.jpg'] = null;
+        }
+        return mappedFilesRecords;
     }
     static async createAFilesListFile(themeRootDir, filesList) {
         if (!filesList || !Object.keys(filesList).length)
             return;
-        const toUnixStyleFilesList = {};
-        for (const [filePath, value] of Object.entries(filesList)) {
+        const toUnixStyleFilesList = Object.entries(filesList).reduce((acc, [filePath, value]) => {
             const unixPath = toUnixPath(filePath);
-            const finalPath = (await fileExists(join(themeRootDir, filePath))) && (await isDirectory(join(themeRootDir, filePath)))
-                ? `${unixPath}${path.posix.sep}`
-                : unixPath;
-            toUnixStyleFilesList[finalPath] = value;
-        }
-        await writeJSONFile(this.getFilesListFilePath(themeRootDir), toUnixStyleFilesList);
-    }
-    static getFilesListFilePath(themeRootDir) {
-        return join(themeRootDir, THEME_FILES_LIST_FILE_NAME);
+            const finalPath = looksLikeDirectory(unixPath) ? `${unixPath}${path.posix.sep}` : unixPath;
+            return {
+                ...acc,
+                [finalPath]: value
+            };
+        }, {});
+        await writeJSONFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME), toUnixStyleFilesList);
     }
     static async removeAFilesListFile(themeRootDir) {
-        await removeFile(this.getFilesListFilePath(themeRootDir));
+        await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
     }
     static async updateFilesStructure(themeDir) {
-        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
+        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
         const checksumsFiles = [
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_FILE_NAME}`,
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME}`,
@@ -126,6 +115,6 @@ export class ThemeFilesUtils {
                 }
             };
         });
-        await ThemeFilesUtils.writeThemeFilesStructure(themeDir, fileStructure);
+        await ThemeFilesStructureUtils.writeThemeFilesStructure(themeDir, fileStructure);
     }
 }

package/build/theme/features/theme/utils/hidden_directory/hidden_directory_utils.js

@@ -5,9 +5,12 @@ import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_conts
 import { computeFileChecksum } from '../../../../../utils/checksums/checksums_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class HiddenDirectoryUtils {
-    static async ensureFilesInsideThemeMetaDataDirectoryUntouched(themeDirectory) {
+    static async ensureFilesInsideThemeMetaDataDirectoryUntouched(themeDirectory, logger) {
         const themeMetadataPath = this.getThemeHiddenDirectoryPath(themeDirectory);
-        const themeChecksums = new ThemeChecksums(themeDirectory);
+        const themeChecksums = new ThemeChecksums({
+            themeDir: themeDirectory,
+            loggerApi: logger
+        });
         if (!(await themeChecksums.verify()))
             throw new Error('Theme checksum file is not valid');
         const filesNames = (await getAllFilesNamesInside(themeMetadataPath)).filter((fileName) => fileName !== THEME_CURRENT_CHECKSUMS_FILE_NAME &&

package/build/theme/features/theme/utils/meta_data/theme_meta_data_error_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';
 import { THEME_WORK_URL_MISMATCH_ERROR } from './theme_meta_data_constants.js';
 export class ThemeMetaDataErrorFactory {
     static createThemeWorkUrlMismatchError(executionUrl, themeWorkUrl) {

package/build/theme/features/theme/utils/resources/theme_resources_with_id_directory_utils.js

@@ -5,7 +5,7 @@ import { fileExists, readJSONFile, renameFile } from '../../../../../utils/fs/fs
 import { join } from '../../../../../utils/path_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 export class ThemeResourcesWithIdDirectoryUtils {
-    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, remoteResourcesDir, remoteThemeDir) {
+    static async updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(localResourcesDir, remoteResourcesDir, remoteThemeDir, loggerApi) {
         const localThemeTree = new FSTree({
             entries: walkSync.entries(localResourcesDir, {
                 globs: ['*/'],
@@ -37,7 +37,10 @@ export class ThemeResourcesWithIdDirectoryUtils {
             /**
              * If these become performance bottlenecks, we can consider computing checksums only for the changed directories.
              */
-            await new ThemeChecksums(remoteThemeDir).updateAllChecksums();
+            await new ThemeChecksums({
+                themeDir: remoteThemeDir,
+                loggerApi
+            }).updateAllChecksums();
         }
     }
     static async _getResourceIdToFilePathMap(entries) {

package/build/theme/features/theme/verify/theme_verify_initializer.js

@@ -1,12 +1,13 @@
-import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
+import { FEATURE_CORES_TYPES, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { ThemeVerifyApi } from './api/theme_verify_api.js';
 import { THEME_VERIFY_FEATURE_NAME } from './theme_verify_constants.js';
 import { ThemeVerifyService } from './verify/theme_verify_service.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeVerifyInitializer extends SyncFeatureInitializer {
     static featureName = THEME_VERIFY_FEATURE_NAME;
     init() {
-        const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemeVerifyService();
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemeVerifyService({ loggerApi });
         return {
             cores: [
                 {

package/build/theme/features/theme/verify/verify/theme_verify_service.js

@@ -3,29 +3,40 @@ import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
 import { ThemePushErrorsFactory } from '../../push/theme_push_errors_factory.js';
 import { join } from '../../../../../utils/path_utils.js';
 import { v4 as uuid } from 'uuid';
-import { ThemeArchiveUtils } from '../../utils/archive/theme_archive_utils.js';
-import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
-import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
+import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
 import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
+import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
+import { ArrayUtils } from '@dreamcommerce/utilities';
 export class ThemeVerifyService {
+    #loggerApi;
+    constructor({ loggerApi }) {
+        this.#loggerApi = loggerApi;
+    }
     async verifyTheme({ verifyAction, executionContext, credentials, themeChecksums, filesStructure, themeFilesUploadApi }) {
+        this.#loggerApi.info('Verifying theme.');
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        this.#loggerApi.debug('Temporary directory created.', { details: { path: tmpDir } });
         const themeRootDir = executionContext.themeRootDir;
         if (await themeChecksums.hasThemeFileBeenCreated(ThemePublishUtils.getSkinStoreSettingsFilePath(themeRootDir)))
             throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
         try {
-            //TODO to do api?
+            this.#loggerApi.debug('Getting file records from action data.');
             const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
                 themeRootDir,
                 themeAction: verifyAction,
-                filesStructure,
-                themeChecksums
+                filesStructure
             });
-            const filesToVerify = filesRecords.filter(({ state }) => [FILE_STATES.modified, FILE_STATES.created].includes(state));
+            this.#loggerApi.debug('Filtering for modified or not created files to verify.');
+            const filesToVerify = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenModified(path)) || !(await themeChecksums.hasThemeFileBeenCreated(path)));
+            this.#loggerApi.debug('Files to verify determined.', { details: { count: filesToVerify.length } });
             if (filesToVerify.length) {
+                this.#loggerApi.info(`Verifying ${filesToVerify.length} theme files.`);
                 const { rejectedImageData } = await themeFilesUploadApi.uploadFiles(filesToVerify);
+                this.#loggerApi.debug('Individual files verification finished.', {
+                    details: { rejectedCount: rejectedImageData.length }
+                });
                 if (rejectedImageData.length)
                     return {
                         isSuccess: false,
@@ -34,28 +45,29 @@ export class ThemeVerifyService {
             }
             await this._createFilesList(themeRootDir, filesToVerify);
             const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
-            await ThemeArchiveUtils.create({
+            this.#loggerApi.info('Creating theme archive for verification.');
+            await new ThemeArchive(themeRootDir).createFullArchive({
                 dist: themeArchivePath,
-                rootDir: themeRootDir,
-                files: await ThemeActionsUtils.getFilesThatMatchesAction({
-                    actionValue: THEME_WILDCARD_ACTION_NAME,
-                    actionType: THEME_ACTIONS_TYPES.push,
-                    filesStructure,
-                    rootDir: themeRootDir
-                })
+                actionValue: THEME_WILDCARD_ACTION_NAME,
+                actionType: THEME_ACTIONS_TYPES.push,
+                logger: this.#loggerApi
             });
+            this.#loggerApi.info('Theme archive created.');
             const { isSuccess, messages } = await themeFilesUploadApi.uploadArchive({
                 action: verifyAction,
                 themeArchivePath,
                 credentials
             });
+            this.#loggerApi.info('Theme archive verification finished.');
             return { isSuccess, messages };
         }
         finally {
-            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
+            this.#loggerApi.debug('Cleaning up files list.');
+            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
         }
     }
     async _createFilesList(themeRootDir, filesRecords) {
-        await ThemeFilesUtils.createAFilesListFile(themeRootDir, ThemeFilesUtils.mapFilesRecordsToFilesList(filesRecords));
+        this.#loggerApi.debug('Creating filesList.json for the archive.');
+        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords));
     }
 }

package/build/theme/features/themes/list/services/themes_list_service.js

@@ -4,20 +4,38 @@ import { HttpErrorsFactory } from '../../../../../cli/class/errors/http/http_err
 import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
 export class ThemesListService {
     #httpApi;
-    constructor(httpApi) {
+    #loggerApi;
+    constructor(httpApi, loggerApi) {
         this.#httpApi = httpApi;
+        this.#loggerApi = loggerApi;
     }
     async getThemes({ shopUrl }) {
+        this.#loggerApi.info('Fetching themes list.', {
+            details: {
+                shopUrl
+            }
+        });
         try {
             const { response: request } = this.#httpApi.getThemes(shopUrl);
             const response = await request;
-            if (response?.status !== STATUS_CODES.ok)
+            if (response?.status !== STATUS_CODES.ok) {
+                this.#loggerApi.debug('Failed to fetch themes list.', {
+                    details: {
+                        status: response?.status
+                    }
+                });
                 return;
-            //TODO baseHttpApi + model mapper
-            return response?.data.map(({ _links, ...rest }) => new ThemeMetaData({
+            }
+            const themes = response?.data.map(({ _links, ...rest }) => new ThemeMetaData({
                 ...rest,
                 links: _links
             }));
+            this.#loggerApi.info('Successfully fetched themes list.', {
+                details: {
+                    count: themes.length
+                }
+            });
+            return themes;
         }
         catch (err) {
             switch (err.response?.status) {
@@ -35,9 +53,22 @@ export class ThemesListService {
         }
     }
     async getTheme({ themeId, shopUrl }) {
+        this.#loggerApi.debug('Getting a specific theme from list.', {
+            details: {
+                themeId,
+                shopUrl
+            }
+        });
         const themes = await this.getThemes({ shopUrl });
         if (!themes)
             return;
-        return themes.find((theme) => String(theme.skinId) === themeId);
+        const theme = themes.find((theme) => String(theme.skinId) === themeId);
+        this.#loggerApi.debug(theme ? 'Theme found.' : 'Theme not found.', {
+            details: {
+                themeId,
+                found: !!theme
+            }
+        });
+        return theme;
     }
 }

package/build/theme/features/themes/list/themes_list_initializer.js

@@ -3,11 +3,13 @@ import { ThemesListApi } from './api/themes_list_api.js';
 import { FEATURE_CORES_TYPES, HTTP_REQUESTER_API_NAME, SyncFeatureInitializer } from '@dreamcommerce/star_core';
 import { THEMES_LIST_FEATURE_NAME } from './themes_list_constants.js';
 import { ThemesListHttpApi } from './http/themes_list_http_api.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemesListInitializer extends SyncFeatureInitializer {
     static featureName = THEMES_LIST_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemesListService(new ThemesListHttpApi(httpApi));
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemesListService(new ThemesListHttpApi(httpApi), loggerApi);
         return {
             cores: [
                 {

package/build/theme/hooks/ensure_theme_meta_data_untouched_hook.js

@@ -1,13 +1,15 @@
-import { useApi } from '../../cli/hooks/ensure_cli_initialized_hook.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
 import { HiddenDirectoryUtils } from '../features/theme/utils/hidden_directory/hidden_directory_utils.js';
+import { LOGGER_API_NAME } from '../../cli/utilities/features/logger/logger_constants.js';
+import { useApi } from '../../utils/use_api.js';
 const ensureThemeMetaDataUntouched = async () => {
     const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
     const executionContext = await executionContextApi.getExecutionContext();
     if (executionContext.type !== EXECUTION_CONTEXTS.theme)
         return;
+    const loggerApi = useApi(LOGGER_API_NAME);
     try {
-        await HiddenDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir);
+        await HiddenDirectoryUtils.ensureFilesInsideThemeMetaDataDirectoryUntouched(executionContext.themeRootDir, loggerApi);
     }
     catch (err) {
         console.error(err);

package/build/theme/hooks/theme_checksums/ensure_theme_current_checksums_up_to_date_hook.js

@@ -1,7 +1,8 @@
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
-import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
 import { THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS } from './ensure_theme_current_checksums_up_to_date_constants.js';
 import { ThemeChecksums } from '../../class/checksums/theme_checksums.js';
+import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
+import { useApi } from '../../../utils/use_api.js';
 export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
     if (!THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS.includes(Command.id))
         return;
@@ -9,10 +10,14 @@ export const ensureThemeChecksumsUpToDate = async ({ Command }) => {
     const executionContext = await executionContextApi.getExecutionContext();
     if (executionContext.type !== EXECUTION_CONTEXTS.theme)
         return;
+    const loggerApi = useApi(LOGGER_API_NAME);
     /**
      * Naive solution, recalculate checksums every time a command based on checksums calculation is executed;
      * If performance becomes an issue, we can implement a more sophisticated solution, eg. recalculate checksums only when files in the theme directory have changed.
      */
-    await new ThemeChecksums(executionContext.themeRootDir).updateCurrentChecksums();
+    await new ThemeChecksums({
+        themeDir: executionContext.themeRootDir,
+        loggerApi
+    }).updateCurrentChecksums();
 };
 export default ensureThemeChecksumsUpToDate;

package/build/theme/hooks/themes_actions/ensure_themes_actions_hook.js

@@ -1,10 +1,10 @@
-import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
 import { THEME_ACTIONS_API_NAME } from '../../features/theme/actions/theme_actions_constants.js';
 import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
 import { THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST } from './ensure_themes_actions_hook_constants.js';
 import { CLI_AUTH_TOKENS_API_NAME } from '../../../cli/auth/tokens/cli_auth_tokens_constants.js';
 import { promptForToken } from '../../../cli/commands/utils/prompt_for_token_utils.js';
 import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+import { useApi } from '../../../utils/use_api.js';
 const ensureThemesActionsHook = async ({ Command, argv }) => {
     if (!THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST.includes(Command.id))
         return;
@@ -38,8 +38,7 @@ const ensureThemesActionsHook = async ({ Command, argv }) => {
             });
         }
         else {
-            console.error(err);
-            process.exit(1);
+            throw err;
         }
     }
 };

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/array_utils.js

@@ -4,6 +4,3 @@ export const asyncFilter = async (array, callback) => {
         return array.filter((_v, index) => results[index]);
     });
 };
-export const asyncMap = async (array, callback) => {
-    return Promise.all(array.map(callback));
-};

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/fs/fs_utils.js

@@ -100,7 +100,7 @@ export const getAllFilesAndDirectoriesInside = async (path, options) => {
         withFileTypes
     });
 };
-export const getAllDirectoriesNamesInside = async (path, options = { recursive: false, hidden: false }) => {
+export const getAllDirectoriesNamesInside = async (path, options) => {
     const { recursive = true, hidden = true } = options;
     const files = await fsPromises.readdir(path, {
         recursive,

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));
+}