sfcc-metadata-cli 0.0.1 → 1.0.0

package/commands/site-preference.js

@@ -0,0 +1,503 @@
+/**
+ * Site Preference Command
+ * Creates site preference attribute definitions in migrations
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const {
+    listMigrations,
+    getLatestMigration,
+    ensureDir,
+    writeFile,
+} = require('../lib/utils');
+const { generateSitePreference } = require('../lib/templates');
+const { mergeSystemObjectExtension } = require('../lib/merge');
+
+const ATTRIBUTE_TYPES = [
+    { name: 'String', value: 'string' },
+    { name: 'Text (multi-line)', value: 'text' },
+    { name: 'HTML', value: 'html' },
+    { name: 'Integer', value: 'int' },
+    { name: 'Double/Decimal', value: 'double' },
+    { name: 'Boolean', value: 'boolean' },
+    { name: 'Date', value: 'date' },
+    { name: 'Date & Time', value: 'datetime' },
+    { name: 'Enum (String)', value: 'enum-of-string' },
+    { name: 'Enum (Integer)', value: 'enum-of-int' },
+    { name: 'Set of Strings', value: 'set-of-string' },
+    { name: 'Image', value: 'image' },
+    { name: 'Password', value: 'password' },
+];
+
+// Base group choices (project groups will be detected from existing migrations)
+const BASE_GROUP_CHOICES = [{ name: '+ Create new group', value: '__new__' }];
+
+module.exports = {
+    command: 'site-preference',
+    aliases: ['sp', 'sitepref', 'preference'],
+    desc: 'Create a site preference attribute',
+    builder: (yargs) => {
+        return yargs
+            .option('migration', {
+                alias: 'm',
+                type: 'string',
+                description:
+                    'Target migration folder (uses latest if not specified)',
+            })
+            .option('attribute-id', {
+                alias: 'a',
+                type: 'string',
+                description: 'Attribute ID (e.g., myPreference)',
+            })
+            .option('display-name', {
+                type: 'string',
+                description: 'Display name for the attribute',
+            })
+            .option('description', {
+                alias: 'd',
+                type: 'string',
+                description: 'Description for the attribute',
+            })
+            .option('type', {
+                alias: 't',
+                type: 'string',
+                choices: [
+                    'string',
+                    'text',
+                    'html',
+                    'int',
+                    'double',
+                    'boolean',
+                    'date',
+                    'datetime',
+                    'enum-of-string',
+                    'set-of-string',
+                ],
+                default: 'string',
+                description: 'Attribute type',
+            })
+            .option('group', {
+                alias: 'g',
+                type: 'string',
+                description: 'Attribute group ID',
+            })
+            .option('default-value', {
+                type: 'string',
+                description: 'Default value',
+            })
+            .option('mandatory', {
+                type: 'boolean',
+                default: false,
+                description: 'Is mandatory',
+            })
+            .option('interactive', {
+                alias: 'i',
+                type: 'boolean',
+                default: true,
+                description: 'Interactive mode with prompts',
+            });
+    },
+    handler: async (argv) => {
+        const migrationsDir = path.resolve(argv.migrationsDir);
+
+        try {
+            const existingMigrations = listMigrations(migrationsDir);
+
+            if (existingMigrations.length === 0) {
+                console.log(
+                    chalk.yellow(
+                        '\nNo migrations found. Creating a new migration first...',
+                    ),
+                );
+                const createCmd = require('./create-migration');
+                await createCmd.handler({ ...argv, interactive: true });
+                return;
+            }
+
+            let config = {
+                attributeId: argv.attributeId,
+                displayName: argv.displayName,
+                description: argv.description,
+                type: argv.type,
+                groupId: argv.group,
+                defaultValue: argv.defaultValue,
+                mandatory: argv.mandatory,
+                existingGroupAttributes: [],
+            };
+
+            let targetMigration =
+                argv.migration || getLatestMigration(migrationsDir);
+
+            if (argv.interactive) {
+                console.log(
+                    chalk.cyan('\n=== Site Preference Definition ===\n'),
+                );
+
+                // Select target migration
+                const migrationAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'migration',
+                        message: 'Select target migration:',
+                        choices: [
+                            ...existingMigrations.slice(-10).reverse(),
+                            new inquirer.Separator(),
+                            {
+                                name: '+ Create new migration',
+                                value: '__new__',
+                            },
+                        ],
+                        default: targetMigration,
+                    },
+                ]);
+
+                if (migrationAnswer.migration === '__new__') {
+                    const createCmd = require('./create-migration');
+                    await createCmd.handler({ ...argv, interactive: true });
+                    targetMigration = getLatestMigration(migrationsDir);
+                } else {
+                    targetMigration = migrationAnswer.migration;
+                }
+
+                // Parse existing group attributes from migrations
+                const existingGroups = await parseExistingGroups(migrationsDir);
+
+                // Basic info
+                const basicInfo = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'attributeId',
+                        message: 'Attribute ID (e.g., myPreference):',
+                        validate: (input) => {
+                            if (!input) return 'Attribute ID is required';
+                            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input)) {
+                                return 'Invalid attribute ID format';
+                            }
+                            return true;
+                        },
+                        when: !config.attributeId,
+                    },
+                    {
+                        type: 'input',
+                        name: 'displayName',
+                        message: 'Display name:',
+                        default: (answers) => {
+                            const id =
+                                answers.attributeId || config.attributeId;
+                            // Convert myPreference to "My Preference"
+                            return id
+                                .replace(/_/g, ' ')
+                                .replace(/([A-Z])/g, ' $1')
+                                .trim()
+                                .split(' ')
+                                .map(
+                                    (w) =>
+                                        w.charAt(0).toUpperCase() + w.slice(1),
+                                )
+                                .join(' ');
+                        },
+                        when: !config.displayName,
+                    },
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: 'Description (optional):',
+                        when: !config.description,
+                    },
+                    {
+                        type: 'list',
+                        name: 'type',
+                        message: 'Attribute type:',
+                        choices: ATTRIBUTE_TYPES,
+                        default: config.type || 'string',
+                    },
+                ]);
+
+                config = { ...config, ...basicInfo };
+
+                // Type-specific prompts
+                if (
+                    config.type === 'enum-of-string' ||
+                    config.type === 'enum-of-int'
+                ) {
+                    const enumConfig = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'multiSelect',
+                            message: 'Allow multiple selections?',
+                            default: false,
+                        },
+                        {
+                            type: 'input',
+                            name: 'enumValues',
+                            message:
+                                'Enum values (comma-separated, format: value:display or just value):',
+                            filter: (input) => {
+                                return input
+                                    .split(',')
+                                    .map((v) => {
+                                        const parts = v.trim().split(':');
+                                        return {
+                                            value: parts[0].trim(),
+                                            display: parts[1]
+                                                ? parts[1].trim()
+                                                : parts[0].trim(),
+                                        };
+                                    })
+                                    .filter((v) => v.value);
+                            },
+                        },
+                    ]);
+                    config.multiSelect = enumConfig.multiSelect;
+                    config.enumValues = enumConfig.enumValues;
+                }
+
+                // Default value
+                const defaultPrompt = await inquirer.prompt([
+                    {
+                        type: config.type === 'boolean' ? 'list' : 'input',
+                        name: 'defaultValue',
+                        message: 'Default value:',
+                        choices:
+                            config.type === 'boolean'
+                                ? [
+                                      { name: 'None', value: null },
+                                      { name: 'True', value: 'true' },
+                                      { name: 'False', value: 'false' },
+                                  ]
+                                : undefined,
+                        when: config.defaultValue === undefined,
+                    },
+                    {
+                        type: 'confirm',
+                        name: 'mandatory',
+                        message: 'Is mandatory?',
+                        default: false,
+                        when: config.mandatory === undefined,
+                    },
+                ]);
+
+                config.defaultValue =
+                    defaultPrompt.defaultValue || config.defaultValue || null;
+                config.mandatory =
+                    defaultPrompt.mandatory !== undefined
+                        ? defaultPrompt.mandatory
+                        : config.mandatory;
+
+                // Group selection
+                const existingGroupIds = Object.keys(existingGroups);
+                const groupChoices = [
+                    ...existingGroupIds.map((g) => ({ name: g, value: g })),
+                    ...BASE_GROUP_CHOICES,
+                ];
+
+                const groupAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'groupId',
+                        message: 'Select attribute group:',
+                        choices: groupChoices,
+                        default: existingGroupIds[0] || '__new__',
+                    },
+                    {
+                        type: 'input',
+                        name: 'newGroupId',
+                        message: 'New group ID:',
+                        when: (answers) => answers.groupId === '__new__',
+                        validate: (input) =>
+                            input ? true : 'Group ID is required',
+                    },
+                    {
+                        type: 'input',
+                        name: 'newGroupDisplayName',
+                        message: 'New group display name:',
+                        when: (answers) => answers.groupId === '__new__',
+                        default: (answers) => answers.newGroupId,
+                    },
+                ]);
+
+                if (groupAnswer.groupId === '__new__') {
+                    config.groupId = groupAnswer.newGroupId;
+                    config.groupDisplayName = groupAnswer.newGroupDisplayName;
+                    config.existingGroupAttributes = [];
+                } else {
+                    config.groupId = groupAnswer.groupId;
+                    config.groupDisplayName = groupAnswer.groupId;
+                    config.existingGroupAttributes =
+                        existingGroups[groupAnswer.groupId] || [];
+                }
+            }
+
+            // Generate XML
+            const xml = generateSitePreference(config);
+
+            // Write to file
+            const metaPath = path.join(migrationsDir, targetMigration, 'meta');
+            const filePath = path.join(
+                metaPath,
+                'system-objecttype-extensions.xml',
+            );
+
+            ensureDir(metaPath);
+
+            // Check if file exists
+            if (fs.existsSync(filePath)) {
+                console.log(
+                    chalk.yellow(
+                        `\nNote: ${chalk.bold('system-objecttype-extensions.xml')} already exists.`,
+                    ),
+                );
+
+                const { action } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'action',
+                        message: 'What would you like to do?',
+                        choices: [
+                            {
+                                name: 'Merge into existing file',
+                                value: 'merge',
+                            },
+                            {
+                                name: 'Show generated XML (copy manually)',
+                                value: 'show',
+                            },
+                            { name: 'Overwrite file', value: 'overwrite' },
+                            { name: 'Cancel', value: 'cancel' },
+                        ],
+                        default: 'merge',
+                    },
+                ]);
+
+                if (action === 'cancel') {
+                    console.log(chalk.yellow('\nOperation cancelled.'));
+                    return;
+                }
+
+                if (action === 'show') {
+                    console.log(chalk.cyan('\n--- Generated XML ---\n'));
+                    console.log(xml);
+                    console.log(chalk.cyan('\n--- End XML ---\n'));
+                    console.log(chalk.gray(`Manually add to: ${filePath}`));
+                    return;
+                }
+
+                if (action === 'merge') {
+                    const existingXml = fs.readFileSync(filePath, 'utf8');
+                    const mergedXml = mergeSystemObjectExtension(existingXml, {
+                        objectTypeId: 'SitePreferences',
+                        attributeId: config.attributeId,
+                        displayName: config.displayName,
+                        description: config.description,
+                        type: config.type,
+                        mandatory: config.mandatory,
+                        externallyManaged: false,
+                        defaultValue: config.defaultValue,
+                        groupId: config.groupId,
+                        groupDisplayName: config.groupDisplayName,
+                        enumValues: config.enumValues,
+                        multiSelect: config.multiSelect,
+                        minLength: config.minLength || 0,
+                    });
+                    writeFile(filePath, result.xml);
+                    console.log(
+                        chalk.green(
+                            `\n✓ Merged site preference: ${config.attributeId}`,
+                        ),
+                    );
+                    console.log(chalk.cyan(`  File: ${filePath}`));
+                    console.log(chalk.gray(`  Group: ${config.groupId}`));
+
+                    if (result.groupExisted) {
+                        console.log(
+                            chalk.yellow(
+                                `\n⚠ Warning: Group "${config.groupId}" already existed in this file.`,
+                            ),
+                        );
+                        console.log(
+                            chalk.yellow(
+                                '  Review the group-definitions to ensure all attributes are listed.',
+                            ),
+                        );
+                        console.log(
+                            chalk.gray(
+                                '  The merge only adds the new attribute reference, existing ones are preserved.',
+                            ),
+                        );
+                    }
+                    return;
+                }
+            }
+
+            writeFile(filePath, xml);
+
+            console.log(
+                chalk.green(
+                    `\n✓ Created site preference: ${config.attributeId}`,
+                ),
+            );
+            console.log(chalk.cyan(`  File: ${filePath}`));
+            console.log(chalk.gray(`  Group: ${config.groupId}`));
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    },
+};
+
+/**
+ * Parses existing group attributes from migration files
+ * @param {string} migrationsDir - Migrations directory
+ * @returns {Promise<Object>} Map of group IDs to attribute arrays
+ */
+async function parseExistingGroups(migrationsDir) {
+    const groups = {};
+    const migrations = fs.readdirSync(migrationsDir);
+
+    for (const migration of migrations) {
+        const filePath = path.join(
+            migrationsDir,
+            migration,
+            'meta',
+            'system-objecttype-extensions.xml',
+        );
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf8');
+
+            // Extract SitePreferences groups
+            const sitePrefsMatch = content.match(
+                /<type-extension type-id="SitePreferences">([\s\S]*?)<\/type-extension>/g,
+            );
+            if (sitePrefsMatch) {
+                for (const match of sitePrefsMatch) {
+                    // Extract group definitions
+                    const groupMatches = match.matchAll(
+                        /<attribute-group group-id="([^"]+)">([\s\S]*?)<\/attribute-group>/g,
+                    );
+                    for (const groupMatch of groupMatches) {
+                        const groupId = groupMatch[1];
+                        const groupContent = groupMatch[2];
+
+                        // Extract attribute IDs
+                        const attrMatches = groupContent.matchAll(
+                            /<attribute attribute-id="([^"]+)"\/>/g,
+                        );
+                        if (!groups[groupId]) {
+                            groups[groupId] = [];
+                        }
+                        for (const attrMatch of attrMatches) {
+                            if (!groups[groupId].includes(attrMatch[1])) {
+                                groups[groupId].push(attrMatch[1]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return groups;
+}