@shoper/cli 0.9.4-7 → 0.9.6-0

package/build/cli/features/controls/ui/controls_mappers.js

@@ -56,7 +56,44 @@ export const toInquirerControl = (control) => {
     }
 };
 export const toInquirerValidate = (validators) => {
+    if (!validators || validators.length === 0)
+        return undefined;
     return (value) => {
-        return validators?.find((v) => !v.isValid(value))?.getErrorMessage() ?? true;
+        for (const v of validators) {
+            if (typeof v?.isValid === 'function') {
+                if (!v.isValid(value)) {
+                    return typeof v.getErrorMessage === 'function' ? v.getErrorMessage() : 'Validation failed';
+                }
+                continue;
+            }
+            switch (v?.type) {
+                case 'length': {
+                    const strValue = String(value ?? '');
+                    const { min, max } = v.options ?? {};
+                    if (typeof min === 'number' && strValue.length < min) {
+                        return `Minimum length is ${min} characters`;
+                    }
+                    if (typeof max === 'number' && strValue.length > max) {
+                        return `Maximum length is ${max} characters`;
+                    }
+                    break;
+                }
+                case 'greaterEqThan': {
+                    const numValue = Number(value);
+                    const { min } = v.options ?? {};
+                    if (typeof min === 'number' && (isNaN(numValue) || numValue < min)) {
+                        return `Value must be greater than or equal to ${min}`;
+                    }
+                    break;
+                }
+                case 'required': {
+                    if (value === null || value === undefined || String(value).trim() === '') {
+                        return 'This field is required';
+                    }
+                    break;
+                }
+            }
+        }
+        return true;
     };
 };

package/build/cli/features/controls/ui/form.js

@@ -1,4 +1,4 @@
 import inquirer from 'inquirer';
 export const Form = ({ controls, onSubmit }) => {
-    inquirer.prompt(controls).then(onSubmit);
+    return inquirer.prompt(controls).then(onSubmit);
 };

package/build/theme/commands/publish/theme_publish_command.js

@@ -1,4 +1,4 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { BaseThemeCommand } from '../../class/base_theme_command.js';
 import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
 import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../../features/theme/actions/theme_actions_constants.js';
@@ -7,20 +7,41 @@ import { renderOnce } from '../../../ui/ui_utils.js';
 import { MissingCredentialsError } from '../../../cli/commands/auth/ui/missing_credentials_error.js';
 import React from 'react';
 import { MissingThemeIdError } from '../ui/missing_theme_id_error.js';
-import { THEME_SKINSTORE_API_NAME } from '../../features/theme/skinstore/theme_publish_constants.js';
+import { THEME_SKINSTORE_API_NAME, RELEASE_TYPE_TEST, RELEASE_TYPE_STABLE, IMAGE_MAX_SIZE, IMAGE_ALLOWED_EXTENSIONS } from '../../features/theme/skinstore/theme_publish_constants.js';
 import { Form } from '../../../cli/features/controls/ui/form.js';
+import { toInquirerControls } from '../../../cli/features/controls/ui/controls_mappers.js';
 import { ThemeError } from '../ui/theme_error.js';
 import { LOGGER_API_NAME } from '../../../cli/utilities/features/logger/logger_constants.js';
+import { Text } from '../../../ui/text.js';
+import { Box } from '../../../ui/box.js';
+import { Success } from '../../../ui/message_box/success.js';
+import { Info } from '../../../ui/message_box/info.js';
+import { Error as ErrorBox } from '../../../ui/message_box/error.js';
+import { UnpermittedCommandError } from '../ui/unpermitted_command_error.js';
+import { promptConfirmation } from '../../../ui/prompts/prompt_confirmation.js';
+import fs from 'fs';
+import path from 'path';
 export class ThemePublishCommand 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).';
+    static summary = 'Publish theme to SkinStore.';
+    static description = 'Publishes a theme to the Shoper SkinStore marketplace.\n\nFor first-time publication, you will be prompted to fill in theme details.\nFor already published themes, this performs an upgrade (new version).';
     static examples = [
         {
-            description: 'This will delete the theme with ID 123 permanently from your store. Make sure you have a backup if needed.',
+            description: 'Publish current theme (from theme directory)',
+            command: '<%= config.bin %> <%= command.id %>'
+        },
+        {
+            description: 'Publish specific theme by ID',
             command: '<%= config.bin %> <%= command.id %> 123'
+        },
+        {
+            description: 'Publish as test release',
+            command: '<%= config.bin %> <%= command.id %> --release test'
+        },
+        {
+            description: 'Publish with screenshots from directory',
+            command: '<%= config.bin %> <%= command.id %> --images ./screenshots'
         }
     ];
-    static hidden = true;
     static args = {
         id: Args.string({
             description: 'Theme id',
@@ -29,6 +50,18 @@ export class ThemePublishCommand extends BaseThemeCommand {
             type: 'string'
         })
     };
+    static flags = {
+        release: Flags.string({
+            char: 'r',
+            description: 'Release type',
+            options: ['test', 'stable'],
+            default: 'stable'
+        }),
+        images: Flags.string({
+            char: 'i',
+            description: 'Path to directory with screenshots'
+        })
+    };
     async run() {
         const themeId = this.args.id;
         const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
@@ -43,38 +76,192 @@ export class ThemePublishCommand extends BaseThemeCommand {
         try {
             let _themeId = themeId;
             if (executionContext.type !== EXECUTION_CONTEXTS.theme && !_themeId) {
+                renderOnce(React.createElement(MissingThemeIdError, null,
+                    React.createElement(Box, { flexDirection: "column", gap: 1 },
+                        React.createElement(Text, null, "Usage: shoper theme publish [ID]"),
+                        React.createElement(Text, null, "Please run this command inside a theme directory or provide a theme ID."))));
                 return;
             }
-            if (executionContext.type === EXECUTION_CONTEXTS.theme) {
+            if (executionContext.type === EXECUTION_CONTEXTS.theme)
                 _themeId = _themeId ?? executionContext.themeId;
-            }
             if (!_themeId) {
                 renderOnce(React.createElement(MissingThemeIdError, null));
                 return;
             }
             const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
             const themeSkinstoreApi = this.getApi(THEME_SKINSTORE_API_NAME);
-            const pushAction = themeActionsApi.getThemeAction({
-                actionType: THEME_ACTIONS_TYPES.publishForm,
+            const publishAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.publish,
                 themeId: _themeId,
                 credentials
             });
-            const controls = await themeSkinstoreApi.getPublishFormData({
-                actionData: pushAction.data,
+            if (!publishAction) {
+                renderOnce(React.createElement(UnpermittedCommandError, { themeId: _themeId, commandName: "publish" }));
+                return;
+            }
+            const publishFormAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.publishForm,
+                themeId: _themeId,
                 credentials
             });
-            Form({
-                controls,
-                onSubmit: (formData) => {
-                    console.log('formData', formData);
-                }
-            });
+            const releaseType = this.flags.release === 'test' ? RELEASE_TYPE_TEST : RELEASE_TYPE_STABLE;
+            const isUpgrade = !publishFormAction;
+            if (isUpgrade) {
+                await this.#handleUpgrade({
+                    themeSkinstoreApi,
+                    themeActionsApi,
+                    publishAction,
+                    credentials,
+                    releaseType,
+                    themeId: _themeId,
+                    loggerApi
+                });
+            }
+            else {
+                await this.#handleFirstPublish({
+                    themeSkinstoreApi,
+                    themeActionsApi,
+                    publishFormAction,
+                    publishAction,
+                    credentials,
+                    releaseType,
+                    themeId: _themeId,
+                    loggerApi
+                });
+            }
         }
         catch (err) {
+            if (err?.name === 'ExitPromptError') {
+                renderOnce(React.createElement(Info, { header: "Theme publish was cancelled." }));
+                return;
+            }
             loggerApi.error('Theme publish command error:', {
                 error: err
             });
             renderOnce(React.createElement(ThemeError, { err: err, executionContext: executionContext }));
         }
     }
+    async #handleUpgrade({ themeSkinstoreApi, themeActionsApi, publishAction, credentials, releaseType, themeId, loggerApi }) {
+        renderOnce(React.createElement(Info, { header: `Upgrading published theme (ID: ${themeId})` },
+            React.createElement(Text, null,
+                "Release type: ",
+                this.flags.release)));
+        const { proceed } = await promptConfirmation('Proceed with upgrade?');
+        if (!proceed) {
+            renderOnce(React.createElement(Info, { header: "Theme publish was cancelled." }));
+            return;
+        }
+        const result = await themeSkinstoreApi.publishTheme({
+            actionData: publishAction.data,
+            credentials,
+            payload: { release: releaseType }
+        });
+        if (result?.isSuccess) {
+            themeActionsApi.removeThemeActions({ themeId, credentials });
+            renderOnce(React.createElement(Success, { header: "Theme upgraded successfully!" },
+                React.createElement(Text, null,
+                    "Release type: ",
+                    this.flags.release)));
+        }
+        else {
+            this.#renderPublishErrors(result?.messages);
+        }
+    }
+    async #handleFirstPublish({ themeSkinstoreApi, themeActionsApi, publishFormAction, publishAction, credentials, releaseType, themeId, loggerApi }) {
+        const controls = await themeSkinstoreApi.getPublishFormData({
+            actionData: publishFormAction.data,
+            credentials
+        });
+        if (!controls || controls.length === 0) {
+            renderOnce(React.createElement(ErrorBox, { header: "Could not fetch publish form." },
+                React.createElement(Text, null, "Check if SkinStore SDK feature is enabled for your store.")));
+            return;
+        }
+        const inquirerControls = toInquirerControls(controls.filter((c) => c.name !== 'release'));
+        const formData = await new Promise((resolve, reject) => {
+            Form({
+                controls: inquirerControls,
+                onSubmit: resolve
+            }).catch(reject);
+        });
+        let uploadedImageIds = [];
+        if (this.flags.images) {
+            uploadedImageIds = await this.#uploadImages({
+                themeSkinstoreApi,
+                credentials,
+                imagesDir: this.flags.images,
+                skinId: themeId,
+                loggerApi
+            });
+        }
+        const payload = {
+            name: formData.name,
+            desc: formData.desc ?? '',
+            description: formData.description,
+            categories: Array.isArray(formData.categories) ? formData.categories : [formData.categories],
+            colors: Array.isArray(formData.colors) ? formData.colors : [formData.colors],
+            price: Number(formData.price) || 0,
+            release: releaseType,
+            ...(uploadedImageIds.length > 0 ? { filesList: uploadedImageIds } : {})
+        };
+        const result = await themeSkinstoreApi.publishTheme({
+            actionData: publishAction.data,
+            credentials,
+            payload
+        });
+        if (result?.isSuccess) {
+            themeActionsApi.removeThemeActions({ themeId, credentials });
+            renderOnce(React.createElement(Success, { header: "Theme published successfully!" },
+                React.createElement(Text, null, "Your theme is now available on SkinStore.")));
+        }
+        else {
+            this.#renderPublishErrors(result?.messages);
+        }
+    }
+    async #uploadImages({ themeSkinstoreApi, credentials, imagesDir, skinId, loggerApi }) {
+        const imageIds = [];
+        if (!fs.existsSync(imagesDir)) {
+            renderOnce(React.createElement(ErrorBox, { header: "Images directory not found." },
+                React.createElement(Text, null,
+                    "Path: ",
+                    imagesDir)));
+            return imageIds;
+        }
+        const files = fs.readdirSync(imagesDir).filter((file) => {
+            const ext = path.extname(file).toLowerCase().replace('.', '');
+            return IMAGE_ALLOWED_EXTENSIONS.includes(ext);
+        });
+        for (const file of files) {
+            const filePath = path.join(imagesDir, file);
+            const stat = fs.statSync(filePath);
+            if (stat.size > IMAGE_MAX_SIZE) {
+                loggerApi.warn(`Skipping ${file}: exceeds ${IMAGE_MAX_SIZE} bytes limit`);
+                continue;
+            }
+            const uploadUrl = `/webapi/cli/themes/${skinId}/skinstore/files`;
+            const result = await themeSkinstoreApi.uploadImage({
+                credentials,
+                uploadUrl,
+                imagePath: filePath
+            });
+            if (result?.isSuccess && result?.imageId) {
+                imageIds.push(result.imageId);
+            }
+            else {
+                loggerApi.warn(`Failed to upload ${file}`, { details: result?.messages });
+            }
+        }
+        return imageIds;
+    }
+    #renderPublishErrors(messages) {
+        if (!messages) {
+            renderOnce(React.createElement(ErrorBox, { header: "Publishing failed." },
+                React.createElement(Text, null, "An unknown error occurred.")));
+            return;
+        }
+        renderOnce(React.createElement(ErrorBox, { header: "Publishing failed. Validation errors:" }, Object.entries(messages).map(([field, msg]) => (React.createElement(Text, { key: field },
+            field,
+            ": ",
+            typeof msg === 'string' ? msg : Object.values(msg).join(', '))))));
+    }
 }

package/build/theme/features/theme/skinstore/api/theme_skinstore_api.js

@@ -10,10 +10,10 @@ export class ThemeSkinstoreApi extends FeatureApi {
     async getPublishFormData(props) {
         return this.#service.getPublishFormData(props);
     }
-    async publish(themeId) {
-        // return this.#service.publish(themeId);
+    async publishTheme(props) {
+        return this.#service.publishTheme(props);
     }
-    async update() {
-        // return this.#service.update();
+    async uploadImage(props) {
+        return this.#service.uploadImage(props);
     }
 }

package/build/theme/features/theme/skinstore/http/theme_skinstore_http_api.js

@@ -14,4 +14,30 @@ export class ThemeSkinstoreHttpApi {
             isPrivate: true
         });
     }
+    publishTheme({ actionData, shopUrl, payload }) {
+        const { method, url } = actionData;
+        return this.#httpApi.fetch({
+            url: `${shopUrl}${url}`,
+            method,
+            data: payload,
+            sanitizeOptions: {
+                disable: true
+            },
+            isPrivate: true
+        });
+    }
+    uploadImage({ shopUrl, url, imageBuffer }) {
+        return this.#httpApi.fetch({
+            url: `${shopUrl}${url}`,
+            method: 'post',
+            data: imageBuffer,
+            headers: {
+                'Content-Type': 'application/octet-stream'
+            },
+            sanitizeOptions: {
+                disable: true
+            },
+            isPrivate: true
+        });
+    }
 }

package/build/theme/features/theme/skinstore/service/theme_skinstore_service.js

@@ -2,13 +2,18 @@ import { STATUS_CODES } from '@dreamcommerce/star_core';
 import { HttpErrorsFactory } from '../../../../../cli/class/errors/http/http_errors_factory.js';
 import { DownloadFileErrorsFactory } from '../../../../../utils/download_file/download_file_errors_factory.js';
 import { toControls } from '../../../../../cli/features/controls/controls_dto_mappers.js';
+import fs from 'fs';
+const PUBLISH_RESPONSE_STATUSES = [STATUS_CODES.ok, STATUS_CODES.badRequest];
 export class ThemeSkinstoreService {
     #httpApi;
-    constructor(httpApi) {
+    #logger;
+    constructor({ httpApi, logger }) {
         this.#httpApi = httpApi;
+        this.#logger = logger;
     }
     async getPublishFormData({ credentials, actionData }) {
         try {
+            this.#logger.info('Fetching publish form data');
             const { response: request } = this.#httpApi.getPublishFormData({ actionData, shopUrl: credentials.shopUrl });
             const response = await request;
             if (response?.status !== STATUS_CODES.ok)
@@ -16,17 +21,64 @@ export class ThemeSkinstoreService {
             return response?.data ? toControls(response.data) : [];
         }
         catch (err) {
-            //TODO to basic class
-            switch (err.response?.status) {
-                case 403:
-                    throw HttpErrorsFactory.createForbiddenError();
-                case 401:
-                    throw HttpErrorsFactory.createUnauthorizedError();
-                case 404:
-                    throw HttpErrorsFactory.createNotFoundError();
-                default:
-                    throw DownloadFileErrorsFactory.downloadError(err.response.status);
-            }
+            this.#logger.error('Error fetching publish form data', { error: err });
+            this.#handleHttpError(err);
+        }
+    }
+    async publishTheme({ credentials, actionData, payload }) {
+        try {
+            this.#logger.info('Publishing theme', {
+                details: { actionData }
+            });
+            const { response: request } = this.#httpApi.publishTheme({
+                actionData,
+                shopUrl: credentials.shopUrl,
+                payload
+            });
+            const response = await request;
+            if (!PUBLISH_RESPONSE_STATUSES.includes(response?.status))
+                return;
+            this.#logger.info('Successfully published theme');
+            return response?.data;
+        }
+        catch (err) {
+            this.#logger.error('Error publishing theme', { error: err });
+            this.#handleHttpError(err);
+        }
+    }
+    async uploadImage({ credentials, uploadUrl, imagePath }) {
+        try {
+            this.#logger.info('Uploading image', {
+                details: { uploadUrl, imagePath }
+            });
+            const imageBuffer = fs.readFileSync(imagePath);
+            const { response: request } = this.#httpApi.uploadImage({
+                shopUrl: credentials.shopUrl,
+                url: uploadUrl,
+                imageBuffer
+            });
+            const response = await request;
+            if (response?.status !== STATUS_CODES.ok)
+                return;
+            this.#logger.info('Successfully uploaded image');
+            return response?.data;
+        }
+        catch (err) {
+            this.#logger.error('Error uploading image', { error: err });
+            this.#handleHttpError(err);
+        }
+    }
+    #handleHttpError(err) {
+        //TODO to basic class
+        switch (err.response?.status) {
+            case 403:
+                throw HttpErrorsFactory.createForbiddenError();
+            case 401:
+                throw HttpErrorsFactory.createUnauthorizedError();
+            case 404:
+                throw HttpErrorsFactory.createNotFoundError();
+            default:
+                throw DownloadFileErrorsFactory.downloadError(err.response?.status);
         }
     }
 }

package/build/theme/features/theme/skinstore/theme_publish_constants.js

@@ -2,3 +2,7 @@ export const THEME_SKINSTORE_LOCATION = 'skinstore';
 export const THEME_SKINSTORE_SETTINGS_FILE_NAME = 'settings.json';
 export const THEME_SKINSTORE_API_NAME = 'ThemeSkinstoreApi';
 export const THEME_SKINSTORE_FEATURE_NAME = 'ThemeSkinstore';
+export const RELEASE_TYPE_TEST = 0;
+export const RELEASE_TYPE_STABLE = 1;
+export const IMAGE_MAX_SIZE = 5242880;
+export const IMAGE_ALLOWED_EXTENSIONS = ['gif', 'jpeg', 'jpg', 'png', 'webp'];

package/build/theme/features/theme/skinstore/theme_skinstore_initialzier.js

@@ -3,11 +3,16 @@ import { THEME_SKINSTORE_FEATURE_NAME } from './theme_publish_constants.js';
 import { ThemeSkinstoreService } from './service/theme_skinstore_service.js';
 import { ThemeSkinstoreHttpApi } from './http/theme_skinstore_http_api.js';
 import { ThemeSkinstoreApi } from './api/theme_skinstore_api.js';
+import { LOGGER_API_NAME } from '../../../../cli/utilities/features/logger/logger_constants.js';
 export class ThemeSkinstoreInitializer extends SyncFeatureInitializer {
     static featureName = THEME_SKINSTORE_FEATURE_NAME;
     init() {
         const httpApi = this.getApiSync(HTTP_REQUESTER_API_NAME);
-        const service = new ThemeSkinstoreService(new ThemeSkinstoreHttpApi(httpApi));
+        const loggerApi = this.getApiSync(LOGGER_API_NAME);
+        const service = new ThemeSkinstoreService({
+            httpApi: new ThemeSkinstoreHttpApi(httpApi),
+            logger: loggerApi
+        });
         return {
             cores: [
                 {

package/build/theme/features/theme/utils/files/theme_files_utils.js

@@ -114,6 +114,15 @@ export class ThemeFilesUtils {
             `${SHOPER_THEME_METADATA_DIR}/${THEME_CURRENT_CHECKSUMS_FILE_NAME}`,
             `${SHOPER_THEME_METADATA_DIR}/${THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME}`
         ];
+        if (!fileStructure[`${SHOPER_THEME_METADATA_DIR}/`]) {
+            fileStructure[`${SHOPER_THEME_METADATA_DIR}/`] = {
+                permissions: {
+                    canAdd: true,
+                    canEdit: true,
+                    canDelete: false
+                }
+            };
+        }
         checksumsFiles.forEach((file) => {
             fileStructure[file] = {
                 permissions: {

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

@@ -24,6 +24,8 @@ export class HiddenDirectoryUtils {
             const fileRelativePath = join(SHOPER_THEME_METADATA_DIR, fileName);
             const currentChecksum = await computeFileChecksum(fileFullPath);
             const initialChecksum = await themeChecksums.getInitialChecksumFromPath(fileRelativePath);
+            if (!initialChecksum)
+                continue;
             if (currentChecksum !== initialChecksum) {
                 throw new Error(`File ${fileName} inside theme metadata directory (${themeMetadataPath}) has been modified. You cannot modify files inside .shoper directory`);
             }

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

@@ -4,5 +4,6 @@ export const THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST = [
     THEME_COMMANDS_NAME.init,
     THEME_COMMANDS_NAME.push,
     THEME_COMMANDS_NAME.delete,
+    THEME_COMMANDS_NAME.publish,
     THEME_COMMANDS_NAME.watch
 ];

package/build/theme/index.js

@@ -17,6 +17,7 @@ import { ThemeDeleteInitializer } from './features/theme/delete/theme_delete_ini
 import { ThemeActionsInitializer } from './features/theme/actions/theme_actions_initializer.js';
 import { ThemeWatchCommand } from './commands/watch/theme_watch_command.js';
 import { ThemeWatchInitializer } from './features/theme/watch/theme_watch_initializer.js';
+import { ThemeSkinstoreInitializer } from './features/theme/skinstore/theme_skinstore_initialzier.js';
 export const COMMANDS = {
     [THEME_COMMANDS_NAME.list]: ThemeListCommand,
     [THEME_COMMANDS_NAME.pull]: ThemePullCommand,
@@ -34,6 +35,7 @@ export const COMMAND_TO_FEATURES_MAP = {
     [THEME_COMMANDS_NAME.push]: [ThemeFetchInitializer, ThemePushInitializer],
     [THEME_COMMANDS_NAME.verify]: ThemeVerifyInitializer,
     [THEME_COMMANDS_NAME.delete]: ThemeDeleteInitializer,
+    [THEME_COMMANDS_NAME.publish]: ThemeSkinstoreInitializer,
     [THEME_COMMANDS_NAME.watch]: [ThemeFetchInitializer, ThemePushInitializer, ThemeWatchInitializer]
 };
 export const getThemeInitializersForCommand = (commandName) => {

package/package.json

@@ -2,7 +2,7 @@
     "name": "@shoper/cli",
     "packageManager": "yarn@3.2.0",
     "sideEffects": false,
-    "version": "0.9.4-7",
+    "version": "0.9.6-0",
     "description": "CLI tool for Shoper",
     "author": "Joanna Firek",
     "license": "MIT",