sfcc-metadata-cli 0.0.1 → 1.0.0

package/commands/custom-object.js

@@ -0,0 +1,426 @@
+/**
+ * Custom Object Command
+ * Creates custom object type 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 { generateCustomObjectDefinition } = require('../lib/templates');
+
+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' },
+];
+
+const STORAGE_SCOPES = [
+    { name: 'Site (per-site data)', value: 'site' },
+    { name: 'Organization (shared across sites)', value: 'organization' },
+];
+
+const STAGING_MODES = [
+    { name: 'Source to Target', value: 'source-to-target' },
+    { name: 'No Staging', value: 'no-staging' },
+];
+
+module.exports = {
+    command: 'custom-object',
+    aliases: ['co', 'customobject'],
+    desc: 'Create a custom object type definition',
+    builder: (yargs) => {
+        return yargs
+            .option('migration', {
+                alias: 'm',
+                type: 'string',
+                description:
+                    'Target migration folder (uses latest if not specified)',
+            })
+            .option('type-id', {
+                alias: 't',
+                type: 'string',
+                description: 'Custom object type ID',
+            })
+            .option('display-name', {
+                type: 'string',
+                description: 'Display name for the custom object',
+            })
+            .option('description', {
+                alias: 'd',
+                type: 'string',
+                description: 'Description for the custom object',
+            })
+            .option('storage-scope', {
+                type: 'string',
+                choices: ['site', 'organization'],
+                default: 'site',
+                description: 'Storage scope',
+            })
+            .option('staging-mode', {
+                type: 'string',
+                choices: ['source-to-target', 'no-staging'],
+                default: 'source-to-target',
+                description: 'Staging mode',
+            })
+            .option('key-id', {
+                type: 'string',
+                description: 'Key attribute ID',
+            })
+            .option('key-type', {
+                type: 'string',
+                choices: ['string', 'int'],
+                default: 'string',
+                description: 'Key attribute type',
+            })
+            .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 = {
+                typeId: argv.typeId,
+                displayName: argv.displayName,
+                description: argv.description,
+                storageScope: argv.storageScope,
+                stagingMode: argv.stagingMode,
+                keyDefinition: argv.keyId
+                    ? {
+                          id: argv.keyId,
+                          type: argv.keyType || 'string',
+                      }
+                    : null,
+                attributes: [],
+            };
+
+            let targetMigration =
+                argv.migration || getLatestMigration(migrationsDir);
+
+            if (argv.interactive) {
+                console.log(chalk.cyan('\n=== Custom Object 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;
+                }
+
+                // Basic info
+                const basicInfo = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'typeId',
+                        message: 'Custom object type ID:',
+                        validate: (input) =>
+                            input ? true : 'Type ID is required',
+                        when: !config.typeId,
+                    },
+                    {
+                        type: 'input',
+                        name: 'displayName',
+                        message: 'Display name:',
+                        default: (answers) => answers.typeId || config.typeId,
+                        when: !config.displayName,
+                    },
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: 'Description (optional):',
+                        when: !config.description,
+                    },
+                    {
+                        type: 'list',
+                        name: 'storageScope',
+                        message: 'Storage scope:',
+                        choices: STORAGE_SCOPES,
+                        default: config.storageScope,
+                    },
+                    {
+                        type: 'list',
+                        name: 'stagingMode',
+                        message: 'Staging mode:',
+                        choices: STAGING_MODES,
+                        default: config.stagingMode,
+                    },
+                ]);
+
+                config = { ...config, ...basicInfo };
+
+                // Key definition
+                console.log(chalk.cyan('\n--- Key Definition ---'));
+                const keyInfo = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'keyId',
+                        message: 'Key attribute ID:',
+                        default: 'key',
+                        validate: (input) =>
+                            input ? true : 'Key ID is required',
+                    },
+                    {
+                        type: 'input',
+                        name: 'keyDisplayName',
+                        message: 'Key display name:',
+                        default: (answers) => answers.keyId,
+                    },
+                    {
+                        type: 'input',
+                        name: 'keyDescription',
+                        message: 'Key description (optional):',
+                    },
+                    {
+                        type: 'list',
+                        name: 'keyType',
+                        message: 'Key type:',
+                        choices: [
+                            { name: 'String', value: 'string' },
+                            { name: 'Integer', value: 'int' },
+                        ],
+                        default: 'string',
+                    },
+                ]);
+
+                config.keyDefinition = {
+                    id: keyInfo.keyId,
+                    displayName: keyInfo.keyDisplayName,
+                    description: keyInfo.keyDescription,
+                    type: keyInfo.keyType,
+                    minLength: 0,
+                };
+
+                // Attributes
+                console.log(chalk.cyan('\n--- Attributes ---'));
+                let addMoreAttributes = true;
+
+                while (addMoreAttributes) {
+                    const attrAnswer = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'addAttribute',
+                            message:
+                                config.attributes.length === 0
+                                    ? 'Add an attribute?'
+                                    : 'Add another attribute?',
+                            default: config.attributes.length === 0,
+                        },
+                    ]);
+
+                    if (!attrAnswer.addAttribute) {
+                        addMoreAttributes = false;
+                        continue;
+                    }
+
+                    const attr = await promptForAttribute();
+                    config.attributes.push(attr);
+                    console.log(chalk.green(`  ✓ Added attribute: ${attr.id}`));
+                }
+            }
+
+            // Generate XML
+            const xml = generateCustomObjectDefinition(config);
+
+            // Write to file
+            const metaPath = path.join(migrationsDir, targetMigration, 'meta');
+            const filePath = path.join(
+                metaPath,
+                'custom-objecttype-definitions.xml',
+            );
+
+            ensureDir(metaPath);
+
+            // Check if file exists
+            if (fs.existsSync(filePath)) {
+                const { overwrite } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: `${chalk.yellow('custom-objecttype-definitions.xml already exists.')} Overwrite?`,
+                        default: false,
+                    },
+                ]);
+
+                if (!overwrite) {
+                    console.log(chalk.yellow('\nOperation cancelled.'));
+                    console.log(chalk.gray('Generated XML:\n'));
+                    console.log(xml);
+                    return;
+                }
+            }
+
+            writeFile(filePath, xml);
+
+            console.log(
+                chalk.green(
+                    `\n✓ Created custom object definition: ${config.typeId}`,
+                ),
+            );
+            console.log(chalk.cyan(`  File: ${filePath}`));
+        } catch (error) {
+            console.error(chalk.red(`\nError: ${error.message}`));
+            process.exit(1);
+        }
+    },
+};
+
+/**
+ * Prompts for attribute configuration
+ * @returns {Promise<Object>} Attribute configuration
+ */
+async function promptForAttribute() {
+    const attr = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'id',
+            message: '  Attribute ID:',
+            validate: (input) => (input ? true : 'Attribute ID is required'),
+        },
+        {
+            type: 'input',
+            name: 'displayName',
+            message: '  Display name:',
+            default: (answers) => answers.id,
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: '  Description (optional):',
+        },
+        {
+            type: 'list',
+            name: 'type',
+            message: '  Type:',
+            choices: ATTRIBUTE_TYPES,
+            default: 'string',
+        },
+        {
+            type: 'confirm',
+            name: 'localizable',
+            message: '  Localizable?',
+            default: false,
+        },
+        {
+            type: 'confirm',
+            name: 'mandatory',
+            message: '  Mandatory?',
+            default: false,
+        },
+    ]);
+
+    // Type-specific prompts
+    if (attr.type === 'enum-of-string' || attr.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);
+                },
+            },
+        ]);
+        attr.multiSelect = enumConfig.multiSelect;
+        attr.enumValues = enumConfig.enumValues;
+    }
+
+    if (attr.type === 'string' || attr.type === 'text') {
+        const stringConfig = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'defaultValue',
+                message: '  Default value (optional):',
+            },
+        ]);
+        attr.defaultValue = stringConfig.defaultValue || null;
+    }
+
+    if (attr.type === 'boolean') {
+        const boolConfig = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'defaultValue',
+                message: '  Default value:',
+                choices: [
+                    { name: 'None', value: null },
+                    { name: 'True', value: 'true' },
+                    { name: 'False', value: 'false' },
+                ],
+            },
+        ]);
+        attr.defaultValue = boolConfig.defaultValue;
+    }
+
+    return attr;
+}