@shoper/cli 0.1.0-7 → 0.1.0-9

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

@@ -0,0 +1,35 @@
+import { join } from '../../../utils/path_utils.js';
+import { RESOURCES_FILE_NAME } from './fetch_resources_constants.js';
+import { SHOPER_THEME_METADATA_DIR } from '../../constants/directory_contstants.js';
+import { fileExists, readJSONFile } from '../../../utils/fs/fs_utils.js';
+export const isResourceObject = (resource) => {
+    return typeof resource === 'object' && resource !== null && 'url' in resource && typeof resource.url === 'string';
+};
+export const getResourcesPath = (root) => {
+    return join(root, SHOPER_THEME_METADATA_DIR, RESOURCES_FILE_NAME);
+};
+export const getResources = async (root) => {
+    const resourcesPath = getResourcesPath(root);
+    if (!(await fileExists(resourcesPath))) {
+        return {};
+    }
+    return await readJSONFile(resourcesPath);
+};
+export const mapResourcesToTree = (resources, separator = '/') => {
+    const tree = {};
+    Object.entries(resources).forEach(([path, value]) => {
+        const parts = path.split(separator).filter(Boolean);
+        let currentLevel = tree;
+        parts.filter(Boolean).forEach((part, index) => {
+            if (index === parts.length - 1) {
+                currentLevel[part] = value;
+            }
+            else {
+                if (!currentLevel[part])
+                    currentLevel[part] = {};
+                currentLevel = currentLevel[part];
+            }
+        });
+    });
+    return tree;
+};

package/build/theme/commands/theme_commands_constants.js

@@ -0,0 +1,8 @@
+export const THEME_COMMANDS_NAME = {
+    list: 'theme:list',
+    pull: 'theme:pull',
+    init: 'theme:init',
+    push: 'theme:push',
+    showChanges: 'theme:show-changes',
+    verify: 'theme:verify'
+};

package/build/theme/commands/theme_init_command.js

@@ -0,0 +1,53 @@
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { Args } from '@oclif/core';
+import { THEME_INIT_API_NAME } from '../features/theme/init/theme_init_constants.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+import ora from 'ora';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../features/theme/actions/theme_actions_constants.js';
+export class ThemeInitCommand extends BaseThemeCommand {
+    static description = 'Clone a theme with provided ID from the shop';
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            required: true,
+            type: 'string'
+        })
+    };
+    async run() {
+        const data = await this.parse(ThemeInitCommand);
+        const { args } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themeInitApi = this.getApi(THEME_INIT_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const copyAction = themeActionsApi.getThemeAction({
+            actionType: THEME_ACTIONS_TYPES.copy,
+            themeId,
+            credentials
+        });
+        if (!copyAction)
+            this.error(`You cannot init theme with id ${themeId}`);
+        const executionContext = await executionContextApi.getExecutionContext();
+        if (executionContext.type === EXECUTION_CONTEXTS.theme)
+            this.error('You cannot run this command in the theme execution context');
+        const spinner = ora('Creating theme...').start();
+        try {
+            await themeInitApi.initTheme({ action: copyAction, credentials });
+            spinner.stopAndPersist({
+                symbol: '\u2713',
+                text: 'Theme successfully created!'
+            });
+        }
+        catch (err) {
+            // TODO handle error
+            spinner.clear();
+            this.error(String(err));
+        }
+    }
+}

package/build/theme/commands/theme_list_command.js

@@ -0,0 +1,16 @@
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { THEMES_LIST_API_NAME } from '../features/themes/list/themes_list_constants.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+export class ThemeListCommand extends BaseThemeCommand {
+    static description = 'List all shop themes';
+    async run() {
+        const ThemesListApi = this.getApi(THEMES_LIST_API_NAME);
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const themes = await ThemesListApi.getThemes(credentials);
+        //TODO UI
+        this.log('themes', themes);
+    }
+}

package/build/theme/commands/theme_pull_command.js

@@ -0,0 +1,126 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { THEME_FETCH_API_NAME, THEME_FETCH_TYPES } from '../features/theme/fetch/theme_fetch_constants.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { THEME_MERGE_API_NAME } from '../features/theme/merge/theme_merge_constants.js';
+import tmp from 'tmp-promise';
+import { join } from '../../utils/path_utils.js';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../features/theme/actions/theme_actions_constants.js';
+import process from 'node:process';
+import { ThemeResourcesWithIdDirectoryUtils } from '../features/theme/utils/directories/theme_resources_with_id_directory_utils.js';
+export class ThemePullCommand extends BaseThemeCommand {
+    static description = 'Pull theme from shop';
+    static args = {
+        id: Args.string({
+            description: 'Theme id',
+            name: 'id',
+            type: 'string'
+        })
+    };
+    static flags = {
+        type: Flags.string({
+            default: THEME_FETCH_TYPES.full,
+            description: 'Type of theme to pull',
+            options: Object.values(THEME_FETCH_TYPES)
+        })
+    };
+    async run() {
+        const data = await this.parse(ThemePullCommand);
+        const { args, flags } = data;
+        const themeId = args.id;
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themeFetchApi = this.getApi(THEME_FETCH_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const executionContext = await executionContextApi.getExecutionContext();
+        const spinner = ora('Pulling theme...').start();
+        try {
+            if (executionContext.type !== EXECUTION_CONTEXTS.theme) {
+                if (themeId === undefined)
+                    this.error('To run this command outside theme context you must provide theme id.');
+                const pullAction = themeActionsApi.getThemeAction({
+                    actionType: THEME_ACTIONS_TYPES.pull,
+                    themeId: themeId,
+                    credentials
+                });
+                await themeFetchApi.fetchTheme({
+                    credentials,
+                    action: pullAction,
+                    config: {
+                        dist: process.cwd(),
+                        fetchType: flags.type
+                    }
+                });
+                spinner.stopAndPersist({
+                    symbol: '\u2713',
+                    text: 'Theme successfully pulled!'
+                });
+                return;
+            }
+            const _themeId = themeId ? themeId : executionContext.themeId;
+            const pullAction = themeActionsApi.getThemeAction({
+                actionType: THEME_ACTIONS_TYPES.pull,
+                themeId: _themeId,
+                credentials
+            });
+            if (executionContext.themeId !== _themeId) {
+                this.error('You cannot pull a theme in the theme execution context that is not the current theme.');
+            }
+            const themeMergeApi = this.getApi(THEME_MERGE_API_NAME);
+            const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+            const { name } = await themeFetchApi.fetchTheme({
+                credentials,
+                action: pullAction,
+                config: {
+                    fetchType: flags.type,
+                    dist: tmpDir
+                }
+            });
+            await ThemeResourcesWithIdDirectoryUtils.updateDirectoryNamesOfResourcesWithIdAccordingToLocalThemeNames(join(executionContext.themeRootDir, 'modules'), executionContext.themeRootDir, join(tmpDir, name, 'modules'), join(tmpDir, name));
+            spinner.stopAndPersist({
+                symbol: '\u2713',
+                text: 'Theme successfully pulled!'
+            });
+            this.log('\n');
+            const changes = await themeMergeApi.getChangesBetweenThemes(join(tmpDir, name), executionContext.themeRootDir);
+            console.log('changes', changes);
+            console.log('is modified', await themeMergeApi.hasThemeBeenModified(executionContext.themeRootDir));
+            if (await themeMergeApi.hasThemeBeenModified(executionContext.themeRootDir)) {
+                console.log('changes', changes);
+                this.log('You have unpublished changes in your theme...\n');
+                this.log('The following files will be changed:\n');
+                changes.forEach(([action, name]) => {
+                    console.log(name, ' - ', action);
+                });
+                console.log('\n');
+                const { proceed } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'proceed',
+                        message: 'Do you want to continue and overwrite local changes?',
+                        default: true
+                    }
+                ]);
+                if (!proceed)
+                    this.log('Pull operation cancelled. Your local changes are safe.');
+            }
+            try {
+                await themeMergeApi.applyChanges(join(tmpDir, name), executionContext.themeRootDir, changes);
+            }
+            catch (err) {
+                console.log('err', err);
+            }
+        }
+        catch (err) {
+            // TODO handle error
+            spinner.clear();
+            this.error(String(err));
+        }
+    }
+}

package/build/theme/commands/theme_push_command.js

@@ -0,0 +1,65 @@
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../features/theme/actions/theme_actions_constants.js';
+import { THEME_PUSH_API_NAME } from '../features/theme/push/theme_push_constants.js';
+import { ThemeDirectoryUtils } from '../features/theme/directory/theme_directory_utils.js';
+import { mapChecksumToTree } from '../../utils/checksums/checksums_utils.js';
+import { mapToPermissionsTree } from '../utils/directory_validator/directory_validator_utils.js';
+import { ThemeChecksumsUtils } from '../features/theme/utils/checksums/theme_checksums_utils.js';
+export class ThemePushCommand extends BaseThemeCommand {
+    static description = 'Upload theme files to the shop';
+    async run() {
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const themePushApi = this.getApi(THEME_PUSH_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const executionContext = await executionContextApi.getExecutionContext();
+        if (executionContext.type !== EXECUTION_CONTEXTS.theme)
+            this.error('You cannot run this command outside theme context.');
+        const pushAction = themeActionsApi.getThemeAction({
+            actionType: THEME_ACTIONS_TYPES.push,
+            themeId: executionContext.themeId,
+            credentials
+        });
+        if (!pushAction)
+            this.error(`You cannot push theme with id ${executionContext.themeId}`);
+        const checksums = await ThemeChecksumsUtils.getThemeCurrentChecksums(executionContext.themeRootDir);
+        const permissions = await ThemeDirectoryUtils.getFilesPermissions(executionContext.themeRootDir);
+        if (!checksums || !permissions)
+            this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');
+        try {
+            const validationResult = await ThemeDirectoryUtils.validateThemeDirectoryStructure({
+                checksums: mapChecksumToTree(checksums),
+                permissions: mapToPermissionsTree(permissions),
+                rootDirectory: executionContext.themeRootDir
+            });
+            //TODO jak wysyla folder z nazwa posiadajaco \ na windows, wychodzimy
+            //TODO validacja folderów przed pushem
+            if (!validationResult.isValid) {
+                validationResult.unpermittedActions.forEach((unpermittedAction) => {
+                    console.log('Unpermitted action:', unpermittedAction.type, unpermittedAction.path);
+                });
+                return;
+            }
+            const filesStructure = await ThemeDirectoryUtils.getThemeFilesStructure(executionContext.themeRootDir);
+            if (!filesStructure)
+                this.error('Theme files structure not found. Please ensure you are in the correct theme directory.');
+            await themePushApi.push({
+                credentials,
+                checksums,
+                filesStructure,
+                pushAction,
+                executionContext
+            });
+            console.log('Theme pushed successfully!');
+        }
+        catch (err) {
+            console.log(err);
+            this.error(`Failed to push theme: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/build/theme/commands/theme_show_changes_command.js

@@ -0,0 +1,60 @@
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+import { THEME_MERGE_API_NAME } from '../features/theme/merge/theme_merge_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import { THEME_FETCH_API_NAME, THEME_FETCH_TYPES } from '../features/theme/fetch/theme_fetch_constants.js';
+import tmp from 'tmp-promise';
+import { THEME_ACTIONS_API_NAME, THEME_ACTIONS_TYPES } from '../features/theme/actions/theme_actions_constants.js';
+import { join } from '../../utils/path_utils.js';
+import ora from 'ora';
+export class ThemeShowChangesCommand extends BaseThemeCommand {
+    static description = 'Show local theme changes';
+    async run() {
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        const themeMergeApi = this.getApi(THEME_MERGE_API_NAME);
+        const themeFetchApi = this.getApi(THEME_FETCH_API_NAME);
+        const themeActionsApi = this.getApi(THEME_ACTIONS_API_NAME);
+        const executionContext = await executionContextApi.getExecutionContext();
+        if (executionContext.type !== EXECUTION_CONTEXTS.theme)
+            this.error('You cannot run this command outside theme context.');
+        const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
+        const pullAction = themeActionsApi.getThemeAction({
+            actionType: THEME_ACTIONS_TYPES.pull,
+            themeId: executionContext.themeId,
+            credentials
+        });
+        const spinner = ora('Pulling theme...').start();
+        try {
+            spinner.stopAndPersist({
+                symbol: '\u2713',
+                text: 'Calculating theme changes...'
+            });
+            const { name } = await themeFetchApi.fetchTheme({
+                credentials,
+                action: pullAction,
+                config: {
+                    fetchType: THEME_FETCH_TYPES.full,
+                    dist: tmpDir
+                }
+            });
+            const changes = await themeMergeApi.getChangesBetweenThemes(executionContext.themeRootDir, join(tmpDir, name));
+            spinner.clear();
+            if (!changes.length) {
+                this.log('No changes found in your theme.');
+                return;
+            }
+            this.log('Changes:\n');
+            changes.forEach(([action, name]) => {
+                console.log(name, ' - ', action);
+            });
+        }
+        catch (err) {
+            //TODO
+            this.error(`Failed to fetch theme changes: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        }
+    }
+}

package/build/theme/commands/theme_verify_command.js

@@ -0,0 +1,43 @@
+import { BaseThemeCommand } from '../class/base_theme_command.js';
+import { CLI_AUTH_API_NAME } from '../../cli/auth/cli_auth_constants.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../cli/features/execution_context/execution_context_constants.js';
+import { ThemeDirectoryUtils } from '../features/theme/directory/theme_directory_utils.js';
+import { mapToPermissionsTree } from '../utils/directory_validator/directory_validator_utils.js';
+import { mapChecksumToTree } from '../../utils/checksums/checksums_utils.js';
+import { ThemeChecksumsUtils } from '../features/theme/utils/checksums/theme_checksums_utils.js';
+export class ThemeVerifyCommand extends BaseThemeCommand {
+    static description = 'Verify theme files structure';
+    async run() {
+        const cliAuthApi = this.getApi(CLI_AUTH_API_NAME);
+        const credentials = cliAuthApi.getCredentials();
+        const executionContextApi = this.getApi(EXECUTION_CONTEXT_API_NAME);
+        if (!credentials)
+            this.error('Credentials not found. Please authorize first.');
+        const executionContext = await executionContextApi.getExecutionContext();
+        if (executionContext.type !== EXECUTION_CONTEXTS.theme)
+            this.error('You cannot run this command outside theme context.');
+        const checksums = await ThemeChecksumsUtils.getThemeInitialChecksums(executionContext.themeRootDir);
+        const permissions = await ThemeDirectoryUtils.getFilesPermissions(executionContext.themeRootDir);
+        if (!checksums || !permissions)
+            this.error('Theme checksums or permissions not found. Please ensure you are in the correct theme directory.');
+        try {
+            const validationResult = await ThemeDirectoryUtils.validateThemeDirectoryStructure({
+                checksums: mapChecksumToTree(checksums),
+                permissions: mapToPermissionsTree(permissions),
+                rootDirectory: executionContext.themeRootDir
+            });
+            if (validationResult.isValid) {
+                this.log('Theme structure is valid.');
+            }
+            else {
+                this.log('Verification failed.\n');
+                validationResult.unpermittedActions.forEach((action) => {
+                    this.log(`Unpermitted action: ${action.type} path: ${action.path}`);
+                });
+            }
+        }
+        catch (err) {
+            this.error(`Error during theme verification: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/build/theme/features/theme/actions/api/theme_actions_api.js

@@ -0,0 +1,19 @@
+import { FeatureApi } from '@dreamcommerce/star_core';
+import { THEME_ACTIONS_API_NAME } from '../theme_actions_constants.js';
+export class ThemeActionsApi extends FeatureApi {
+    moduleName = THEME_ACTIONS_API_NAME;
+    #service;
+    constructor(service) {
+        super();
+        this.#service = service;
+    }
+    getThemeAction(props) {
+        return this.#service.getThemeAction(props);
+    }
+    async ensureThemesActions(props) {
+        return this.#service.ensureThemesActions(props);
+    }
+    clearThemesActions(props) {
+        return this.#service.clearThemesActions(props);
+    }
+}

package/build/theme/features/theme/actions/service/theme_actions_service.js

@@ -0,0 +1,92 @@
+import { STORE_THEMES_ACTIONS_TTL } from './theme_actions_service_constants.js';
+import { AppError } from '../../../../../cli/class/errors/app_error/app_error.js';
+import { getNMinutesFromNow } from '../../../../../utils/date_utils.js';
+import { computeChecksum } from '../../../../../utils/checksums/checksums_utils.js';
+export class ThemeActionsService {
+    #themesListApi;
+    #themesActionsStore;
+    constructor({ themesListApi, themesActionsStore }) {
+        this.#themesListApi = themesListApi;
+        this.#themesActionsStore = themesActionsStore;
+    }
+    getThemeAction({ actionType, themeId, credentials }) {
+        const storeActions = this.#themesActionsStore.get(this._getKey(credentials.shopUrl));
+        if (!storeActions)
+            throw new AppError({
+                code: 'theme_actions_not_found',
+                message: `Theme actions for store ${credentials.shopUrl} not found.`
+            });
+        const actions = storeActions.actions[themeId];
+        if (!actions)
+            throw new AppError({
+                code: 'theme_action_not_found',
+                message: `Theme action for theme ${themeId} not found.`
+            });
+        return actions[actionType];
+    }
+    async ensureThemesActions({ credentials, themeId }) {
+        if (!themeId)
+            return;
+        const actionsData = this.#themesActionsStore.get(this._getKey(credentials.shopUrl));
+        if (actionsData &&
+            this._isValidThemesActions(actionsData) &&
+            actionsData.actions[themeId] &&
+            !this._hasThemesActionsExpired(this._getKey(credentials.shopUrl))) {
+            return Promise.resolve();
+        }
+        this._cleanExpiredActions();
+        const actions = await this._fetchStoreThemesActions(credentials);
+        this.#themesActionsStore.set(this._getKey(credentials.shopUrl), {
+            actions,
+            expires: getNMinutesFromNow(STORE_THEMES_ACTIONS_TTL)
+        });
+    }
+    _hasThemesActionsExpired(key) {
+        const expires = this.#themesActionsStore.get(key)?.expires;
+        if (typeof expires !== 'number')
+            return true;
+        return expires - Date.now() < 0;
+    }
+    _isValidThemesActions(actions) {
+        //TODO schema
+        return true;
+    }
+    async _fetchStoreThemesActions(credentials) {
+        const themes = await this.#themesListApi.getThemes(credentials);
+        if (!Array.isArray(themes))
+            throw new AppError({
+                code: 'invalid_themes_list',
+                message: 'Error while fetching themes list.'
+            });
+        return themes.reduce((acc, theme) => {
+            return {
+                ...acc,
+                [theme.skinId]: Object.entries(theme.links).reduce((acc, [actionType, data]) => {
+                    return {
+                        ...acc,
+                        [actionType]: {
+                            data: data,
+                            actionType
+                        }
+                    };
+                }, {})
+            };
+        }, {});
+    }
+    clearThemesActions({ credentials }) {
+        const key = this._getKey(credentials.shopUrl);
+        this.#themesActionsStore.remove(key);
+    }
+    _getKey(shopUrl) {
+        return computeChecksum(shopUrl);
+    }
+    _cleanExpiredActions() {
+        const keys = this.#themesActionsStore.getKeys();
+        keys.forEach((key) => {
+            const actionsData = this.#themesActionsStore.get(key);
+            if (!actionsData || this._hasThemesActionsExpired(key)) {
+                this.#themesActionsStore.remove(key);
+            }
+        });
+    }
+}

package/build/theme/features/theme/actions/service/theme_actions_service_constants.js

@@ -0,0 +1,2 @@
+export const STORE_THEMES_ACTIONS_TTL = 10;
+export const THEME_WILDCARD_ACTION_NAME = '*';

package/build/theme/features/theme/actions/theme_actions_constants.js

@@ -0,0 +1,15 @@
+export const THEMES_ACTIONS_FILE_NAME = 'themes_actions';
+export const THEME_ACTIONS_FEATURE_NAME = 'ThemeActions';
+export const THEME_ACTIONS_API_NAME = 'ThemeActionsApi';
+export const THEME_ACTIONS_TYPES = {
+    copy: 'copy',
+    push: 'push',
+    pull: 'pull',
+    delete: 'delete',
+    publish_form: 'publish_form',
+    publish: 'publish'
+};
+export const THEME_ACTION_DATA_TYPE = {
+    file: 'file',
+    zip: 'zip'
+};

package/build/theme/features/theme/actions/theme_actions_initializer.js

@@ -0,0 +1,27 @@
+import { AsyncFeatureInitializer, FEATURE_CORES_TYPES } from '@dreamcommerce/star_core';
+import { THEMES_LIST_API_NAME } from '../../themes/list/themes_list_constants.js';
+import { JsonCache } from '../../../../cli/features/caches/json_cache/json_cache.js';
+import { CLI_DATA_DIRECTORY_API_NAME } from '../../../../cli/features/data_directory/cli_data_directory_constants.js';
+import { THEME_ACTIONS_FEATURE_NAME, THEMES_ACTIONS_FILE_NAME } from './theme_actions_constants.js';
+import { ThemeActionsApi } from './api/theme_actions_api.js';
+import { ThemeActionsService } from './service/theme_actions_service.js';
+export class ThemeActionsInitializer extends AsyncFeatureInitializer {
+    static featureName = THEME_ACTIONS_FEATURE_NAME;
+    async init() {
+        const themesListApi = this.getApiSync(THEMES_LIST_API_NAME);
+        const cliDataDirectoryApi = this.getApiSync(CLI_DATA_DIRECTORY_API_NAME);
+        const themesActionsStore = new JsonCache({
+            path: cliDataDirectoryApi.getDataDirectoryFullPath(),
+            configFileMode: 0o600,
+            name: THEMES_ACTIONS_FILE_NAME
+        });
+        return {
+            cores: [
+                {
+                    type: FEATURE_CORES_TYPES.api,
+                    instance: new ThemeActionsApi(new ThemeActionsService({ themesListApi, themesActionsStore }))
+                }
+            ]
+        };
+    }
+}

package/build/theme/features/theme/actions/theme_actions_utils.js

@@ -0,0 +1,8 @@
+export const getFilesGlobsThatMatchesActionName = (actionType, actionValue, filesStructure) => {
+    return Object.entries(filesStructure).reduce((acc, [filePath, fileStructureItem]) => {
+        if (fileStructureItem._links?.[actionType] === actionValue) {
+            return [...acc, filePath];
+        }
+        return acc;
+    }, []);
+};