sfcc-metadata-cli 0.0.1 → 1.0.0

package/commands/system-object.js

@@ -0,0 +1,572 @@
+/**
+ * System Object Extension Command
+ * Creates system object custom 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 { generateSystemObjectExtension } = 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' },
+];
+
+// Common SFCC system objects
+const SYSTEM_OBJECTS = [
+    { name: 'Order', value: 'Order' },
+    { name: 'Product', value: 'Product' },
+    { name: 'Category', value: 'Category' },
+    { name: 'Customer', value: 'Profile' },
+    { name: 'Basket', value: 'Basket' },
+    { name: 'ProductLineItem', value: 'ProductLineItem' },
+    { name: 'ShippingLineItem', value: 'ShippingLineItem' },
+    { name: 'PaymentInstrument', value: 'PaymentInstrument' },
+    { name: 'OrderPaymentInstrument', value: 'OrderPaymentInstrument' },
+    { name: 'Shipment', value: 'Shipment' },
+    { name: 'Store', value: 'Store' },
+    { name: 'Content', value: 'Content' },
+    { name: 'Folder', value: 'Folder' },
+    { name: 'Catalog', value: 'Catalog' },
+    { name: 'PriceBook', value: 'PriceBook' },
+    { name: 'SourceCodeGroup', value: 'SourceCodeGroup' },
+    { name: 'Campaign', value: 'Campaign' },
+    { name: 'Promotion', value: 'Promotion' },
+    { name: 'Coupon', value: 'Coupon' },
+    { name: 'GiftCertificate', value: 'GiftCertificate' },
+    { name: 'SitePreferences', value: 'SitePreferences' },
+    { name: 'OrganizationPreferences', value: 'OrganizationPreferences' },
+    new inquirer.Separator(),
+    { name: '+ Enter custom object type', value: '__custom__' },
+];
+
+module.exports = {
+    command: 'system-object',
+    aliases: ['so', 'sysobj', 'extend'],
+    desc: 'Extend a system object with custom attributes',
+    builder: (yargs) => {
+        return yargs
+            .option('migration', {
+                alias: 'm',
+                type: 'string',
+                description:
+                    'Target migration folder (uses latest if not specified)',
+            })
+            .option('object-type', {
+                alias: 'o',
+                type: 'string',
+                description: 'System object type ID (e.g., Order, Product)',
+            })
+            .option('attribute-id', {
+                alias: 'a',
+                type: 'string',
+                description: 'Attribute ID',
+            })
+            .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('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 = {
+                objectTypeId: argv.objectType,
+                attributeId: argv.attributeId,
+                displayName: argv.displayName,
+                description: argv.description,
+                type: argv.type,
+                groupId: argv.group,
+                existingGroupAttributes: [],
+            };
+
+            let targetMigration =
+                argv.migration || getLatestMigration(migrationsDir);
+
+            if (argv.interactive) {
+                console.log(chalk.cyan('\n=== System Object Extension ===\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 groups from migrations
+                const existingGroups = await parseExistingGroups(migrationsDir);
+
+                // Select system object type
+                const objectAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'objectTypeId',
+                        message: 'Select system object type:',
+                        choices: SYSTEM_OBJECTS,
+                        when: !config.objectTypeId,
+                    },
+                    {
+                        type: 'input',
+                        name: 'customObjectType',
+                        message: 'Enter object type ID:',
+                        when: (answers) =>
+                            answers.objectTypeId === '__custom__',
+                        validate: (input) =>
+                            input ? true : 'Object type ID is required',
+                    },
+                ]);
+
+                config.objectTypeId =
+                    objectAnswer.customObjectType ||
+                    objectAnswer.objectTypeId ||
+                    config.objectTypeId;
+
+                // Basic info
+                const basicInfo = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'attributeId',
+                        message: 'Attribute ID (e.g., customAttribute):',
+                        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;
+                            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',
+                    },
+                    {
+                        type: 'confirm',
+                        name: 'localizable',
+                        message: 'Is localizable?',
+                        default: false,
+                    },
+                    {
+                        type: 'confirm',
+                        name: 'mandatory',
+                        message: 'Is mandatory?',
+                        default: false,
+                    },
+                ]);
+
+                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,
+                    },
+                ]);
+
+                config.defaultValue = defaultPrompt.defaultValue || null;
+
+                // Group selection
+                const objectGroups = existingGroups[config.objectTypeId] || {};
+                const existingObjectGroupIds = Object.keys(objectGroups);
+                const groupChoices = [
+                    {
+                        name: `${config.objectTypeId}_Custom`,
+                        value: `${config.objectTypeId}_Custom`,
+                    },
+                    ...existingObjectGroupIds.map((g) => ({
+                        name: g,
+                        value: g,
+                    })),
+                    new inquirer.Separator(),
+                    { name: '+ Create new group', value: '__new__' },
+                ];
+
+                // Remove duplicates
+                const uniqueChoices = groupChoices.filter(
+                    (choice, index, self) =>
+                        choice.type === 'separator' ||
+                        index ===
+                            self.findIndex((c) => c.value === choice.value),
+                );
+
+                const groupAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'groupId',
+                        message: 'Select attribute group:',
+                        choices: uniqueChoices,
+                        default: `${config.objectTypeId}_Custom`,
+                    },
+                    {
+                        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 =
+                        objectGroups[groupAnswer.groupId] || [];
+                }
+            }
+
+            // Generate XML
+            const xml = generateSystemObjectExtension(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 result = mergeSystemObjectExtension(existingXml, {
+                        objectTypeId: config.objectTypeId,
+                        attributeId: config.attributeId,
+                        displayName: config.displayName,
+                        description: config.description,
+                        type: config.type,
+                        localizable: config.localizable,
+                        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 ${config.objectTypeId} extension: ${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 ${config.objectTypeId} extension: ${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 object types to groups to attribute arrays
+ */
+async function parseExistingGroups(migrationsDir) {
+    const objectGroups = {};
+    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 type extensions
+            const typeMatches = content.matchAll(
+                /<type-extension type-id="([^"]+)">([\s\S]*?)<\/type-extension>/g,
+            );
+            for (const typeMatch of typeMatches) {
+                const typeId = typeMatch[1];
+                const typeContent = typeMatch[2];
+
+                if (!objectGroups[typeId]) {
+                    objectGroups[typeId] = {};
+                }
+
+                // Extract group definitions
+                const groupMatches = typeContent.matchAll(
+                    /<attribute-group group-id="([^"]+)">([\s\S]*?)<\/attribute-group>/g,
+                );
+                for (const groupMatch of groupMatches) {
+                    const groupId = groupMatch[1];
+                    const groupContent = groupMatch[2];
+
+                    if (!objectGroups[typeId][groupId]) {
+                        objectGroups[typeId][groupId] = [];
+                    }
+
+                    // Extract attribute IDs
+                    const attrMatches = groupContent.matchAll(
+                        /<attribute attribute-id="([^"]+)"\/>/g,
+                    );
+                    for (const attrMatch of attrMatches) {
+                        if (
+                            !objectGroups[typeId][groupId].includes(
+                                attrMatch[1],
+                            )
+                        ) {
+                            objectGroups[typeId][groupId].push(attrMatch[1]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return objectGroups;
+}

package/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Migration Helper CLI
+ * Companion tool to b2c-tools for creating SFCC migrations
+ */
+
+const yargs = require('yargs');
+const { hideBin } = require('yargs/helpers');
+
+const createMigrationCommand = require('./commands/create-migration');
+const customObjectCommand = require('./commands/custom-object');
+const sitePreferenceCommand = require('./commands/site-preference');
+const systemObjectCommand = require('./commands/system-object');
+
+yargs(hideBin(process.argv))
+    .scriptName('migration-helper')
+    .usage('$0 <command> [options]')
+    .command(createMigrationCommand)
+    .command(customObjectCommand)
+    .command(sitePreferenceCommand)
+    .command(systemObjectCommand)
+    .demandCommand(1, 'You must specify a command')
+    .option('migrations-dir', {
+        alias: 'm',
+        type: 'string',
+        description: 'Path to migrations directory',
+        default: './migrations',
+    })
+    .help()
+    .alias('h', 'help')
+    .version()
+    .alias('v', 'version')
+    .epilogue('For more information, see the b2c-tools documentation')
+    .parse();