sfcc-metadata-cli 0.0.1 → 1.0.0

package/lib/merge.js

@@ -0,0 +1,271 @@
+/**
+ * XML Merge utilities for SFCC migrations
+ * Handles merging new attributes into existing XML files
+ */
+
+const fs = require('node:fs');
+
+/**
+ * Merges a new attribute definition into an existing system-objecttype-extensions.xml
+ * @param {string} existingXml - Existing XML content
+ * @param {Object} config - New attribute configuration
+ * @returns {{xml: string, groupExisted: boolean, typeExtensionExisted: boolean}} Merged XML content and metadata
+ */
+function mergeSystemObjectExtension(existingXml, config) {
+    const {
+        objectTypeId,
+        attributeId,
+        displayName,
+        description,
+        type,
+        localizable = false,
+        mandatory = false,
+        externallyManaged = false,
+        defaultValue,
+        groupId,
+        groupDisplayName,
+        enumValues = [],
+        multiSelect = false,
+        minLength = 0,
+    } = config;
+
+    let groupExisted = false;
+    let typeExtensionExisted = false;
+
+    // Generate the attribute definition XML
+    const attrDefXml = generateAttributeDefinitionXml({
+        id: attributeId,
+        displayName,
+        description,
+        type,
+        localizable,
+        mandatory,
+        externallyManaged,
+        defaultValue,
+        enumValues,
+        multiSelect,
+        minLength,
+    });
+
+    // Check if type-extension for this object already exists
+    const typeExtRegex = new RegExp(
+        `<type-extension type-id="${objectTypeId}">([\\s\\S]*?)</type-extension>`,
+    );
+    const typeExtMatch = existingXml.match(typeExtRegex);
+
+    if (typeExtMatch) {
+        // Type extension exists - merge into it
+        typeExtensionExisted = true;
+        let typeExtContent = typeExtMatch[1];
+
+        // Add attribute definition
+        const attrDefsEndMatch = typeExtContent.match(
+            /<\/custom-attribute-definitions>/,
+        );
+        if (attrDefsEndMatch) {
+            typeExtContent = typeExtContent.replace(
+                '</custom-attribute-definitions>',
+                `${attrDefXml}\n        </custom-attribute-definitions>`,
+            );
+        } else {
+            // No custom-attribute-definitions section, add it
+            typeExtContent = `
+        <custom-attribute-definitions>
+${attrDefXml}
+        </custom-attribute-definitions>${typeExtContent}`;
+        }
+
+        // Add attribute to group
+        const finalGroupId = groupId || `${objectTypeId}_Custom`;
+        const groupRegex = new RegExp(
+            `<attribute-group group-id="${escapeRegex(finalGroupId)}">([\\s\\S]*?)</attribute-group>`,
+        );
+        const groupMatch = typeExtContent.match(groupRegex);
+
+        if (groupMatch) {
+            // Group exists - add attribute reference
+            groupExisted = true;
+            const groupContent = groupMatch[1];
+            if (!groupContent.includes(`attribute-id="${attributeId}"`)) {
+                typeExtContent = typeExtContent.replace(
+                    '</attribute-group>',
+                    `    <attribute attribute-id="${attributeId}"/>\n            </attribute-group>`,
+                );
+            }
+        } else {
+            // Group doesn't exist - add it
+            const groupDefsEndMatch = typeExtContent.match(
+                /<\/group-definitions>/,
+            );
+            const newGroup = `            <attribute-group group-id="${finalGroupId}">
+                <display-name xml:lang="x-default">${escapeXml(groupDisplayName || finalGroupId)}</display-name>
+                <attribute attribute-id="${attributeId}"/>
+            </attribute-group>`;
+
+            if (groupDefsEndMatch) {
+                typeExtContent = typeExtContent.replace(
+                    '</group-definitions>',
+                    `${newGroup}\n        </group-definitions>`,
+                );
+            } else {
+                // No group-definitions section
+                typeExtContent += `
+        <group-definitions>
+${newGroup}
+        </group-definitions>`;
+            }
+        }
+
+        // Replace the type extension in the original XML
+        const mergedXml = existingXml.replace(
+            typeExtRegex,
+            `<type-extension type-id="${objectTypeId}">${typeExtContent}</type-extension>`,
+        );
+        return { xml: mergedXml, groupExisted, typeExtensionExisted };
+    }
+
+    // Type extension doesn't exist - add it before </metadata>
+    const finalGroupId2 = groupId || `${objectTypeId}_Custom`;
+    const newTypeExt = `    <type-extension type-id="${objectTypeId}">
+        <custom-attribute-definitions>
+${attrDefXml}
+        </custom-attribute-definitions>
+        <group-definitions>
+            <attribute-group group-id="${finalGroupId2}">
+                <display-name xml:lang="x-default">${escapeXml(groupDisplayName || finalGroupId2)}</display-name>
+                <attribute attribute-id="${attributeId}"/>
+            </attribute-group>
+        </group-definitions>
+    </type-extension>`;
+
+    const mergedXml = existingXml.replace(
+        '</metadata>',
+        `${newTypeExt}\n</metadata>`,
+    );
+    return {
+        xml: mergedXml,
+        groupExisted: false,
+        typeExtensionExisted: false,
+    };
+}
+
+/**
+ * Merges a new custom object type into an existing custom-objecttype-definitions.xml
+ * @param {string} existingXml - Existing XML content
+ * @param {string} newTypeXml - New custom type XML (inner content only)
+ * @returns {string} Merged XML content
+ */
+function mergeCustomObjectDefinition(existingXml, newTypeXml) {
+    // Add before </metadata>
+    return existingXml.replace('</metadata>', `${newTypeXml}\n</metadata>`);
+}
+
+/**
+ * Generates attribute definition XML (without wrapper)
+ * @param {Object} attr - Attribute configuration
+ * @returns {string} XML string
+ */
+function generateAttributeDefinitionXml(attr) {
+    const {
+        id,
+        displayName = id,
+        description = '',
+        type = 'string',
+        localizable = false,
+        mandatory = false,
+        externallyManaged = false,
+        defaultValue = null,
+        minLength = 0,
+        enumValues = [],
+        multiSelect = false,
+    } = attr;
+
+    let typeSpecificXml = '';
+
+    switch (type) {
+        case 'string':
+        case 'text':
+        case 'html':
+        case 'password':
+            typeSpecificXml = `
+                <min-length>${minLength}</min-length>`;
+            break;
+        case 'int':
+        case 'double':
+            if (attr.minValue !== undefined) {
+                typeSpecificXml += `
+                <min-value>${attr.minValue}</min-value>`;
+            }
+            if (attr.maxValue !== undefined) {
+                typeSpecificXml += `
+                <max-value>${attr.maxValue}</max-value>`;
+            }
+            break;
+        case 'enum-of-string':
+        case 'enum-of-int':
+            typeSpecificXml = `
+                <select-multiple-flag>${multiSelect}</select-multiple-flag>
+                <value-definitions>
+${enumValues
+    .map(
+        (v) => `                    <value-definition>
+                        <display xml:lang="x-default">${v.display || v.value}</display>
+                        <value>${v.value}</value>
+                    </value-definition>`,
+    )
+    .join('\n')}
+                </value-definitions>`;
+            break;
+    }
+
+    const defaultValueXml =
+        defaultValue !== null
+            ? `
+                <default-value>${defaultValue}</default-value>`
+            : '';
+
+    const descriptionXml = description
+        ? `
+                <description xml:lang="x-default">${escapeXml(description)}</description>`
+        : '';
+
+    return `            <attribute-definition attribute-id="${id}">
+                <display-name xml:lang="x-default">${escapeXml(displayName)}</display-name>${descriptionXml}
+                <type>${type}</type>
+                <localizable-flag>${localizable}</localizable-flag>
+                <mandatory-flag>${mandatory}</mandatory-flag>
+                <externally-managed-flag>${externallyManaged}</externally-managed-flag>${typeSpecificXml}${defaultValueXml}
+            </attribute-definition>`;
+}
+
+/**
+ * Escapes special XML characters
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeXml(str) {
+    if (!str) return '';
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+
+/**
+ * Escapes special regex characters
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+    mergeSystemObjectExtension,
+    mergeCustomObjectDefinition,
+    generateAttributeDefinitionXml,
+    escapeXml,
+    escapeRegex,
+};

package/lib/templates.js

@@ -0,0 +1,315 @@
+/**
+ * XML Templates for SFCC migrations
+ */
+
+const XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>';
+const METADATA_NAMESPACE =
+    'http://www.demandware.com/xml/impex/metadata/2006-10-31';
+
+/**
+ * Wraps content in metadata root element
+ * @param {string} content - Inner XML content
+ * @returns {string} Complete XML document
+ */
+function wrapInMetadata(content) {
+    return `${XML_HEADER}
+<metadata xmlns="${METADATA_NAMESPACE}">
+${content}
+</metadata>
+`;
+}
+
+/**
+ * Generates attribute definition XML based on type
+ * @param {Object} attr - Attribute configuration
+ * @returns {string} XML string
+ */
+function generateAttributeDefinition(attr) {
+    const {
+        id,
+        displayName = id,
+        description = '',
+        type = 'string',
+        localizable = false,
+        mandatory = false,
+        externallyManaged = false,
+        defaultValue = null,
+        minLength = 0,
+        enumValues = [],
+    } = attr;
+
+    let typeSpecificXml = '';
+
+    switch (type) {
+        case 'string':
+        case 'text':
+        case 'html':
+        case 'password':
+            typeSpecificXml = `
+                <min-length>${minLength}</min-length>`;
+            break;
+        case 'int':
+        case 'double':
+            if (attr.minValue !== undefined) {
+                typeSpecificXml += `
+                <min-value>${attr.minValue}</min-value>`;
+            }
+            if (attr.maxValue !== undefined) {
+                typeSpecificXml += `
+                <max-value>${attr.maxValue}</max-value>`;
+            }
+            break;
+        case 'enum-of-string':
+        case 'enum-of-int':
+            typeSpecificXml = `
+                <select-multiple-flag>${attr.multiSelect || false}</select-multiple-flag>
+                <value-definitions>
+${enumValues
+    .map(
+        (v) => `                    <value-definition>
+                        <display xml:lang="x-default">${v.display || v.value}</display>
+                        <value>${v.value}</value>
+                    </value-definition>`,
+    )
+    .join('\n')}
+                </value-definitions>`;
+            break;
+        case 'set-of-string':
+        case 'set-of-int':
+        case 'set-of-double':
+            break;
+        case 'boolean':
+            break;
+        case 'date':
+        case 'datetime':
+            break;
+        case 'image':
+            break;
+    }
+
+    const defaultValueXml =
+        defaultValue !== null
+            ? `
+                <default-value>${defaultValue}</default-value>`
+            : '';
+
+    const descriptionXml = description
+        ? `
+                <description xml:lang="x-default">${escapeXml(description)}</description>`
+        : '';
+
+    return `            <attribute-definition attribute-id="${id}">
+                <display-name xml:lang="x-default">${escapeXml(displayName)}</display-name>${descriptionXml}
+                <type>${type}</type>
+                <localizable-flag>${localizable}</localizable-flag>
+                <mandatory-flag>${mandatory}</mandatory-flag>
+                <externally-managed-flag>${externallyManaged}</externally-managed-flag>${typeSpecificXml}${defaultValueXml}
+            </attribute-definition>`;
+}
+
+/**
+ * Generates custom object type definition XML
+ * @param {Object} config - Custom object configuration
+ * @returns {string} XML document
+ */
+function generateCustomObjectDefinition(config) {
+    const {
+        typeId,
+        displayName = typeId,
+        description = '',
+        stagingMode = 'source-to-target',
+        storageScope = 'site',
+        keyDefinition,
+        attributes = [],
+        groupId = typeId,
+    } = config;
+
+    const keyDef = keyDefinition || {
+        id: 'key',
+        type: 'string',
+        minLength: 0,
+    };
+
+    const keyDescriptionXml = keyDef.description
+        ? `
+            <description xml:lang="x-default">${escapeXml(keyDef.description)}</description>`
+        : '';
+
+    const keyDisplayNameXml = keyDef.displayName
+        ? `
+            <display-name xml:lang="x-default">${escapeXml(keyDef.displayName)}</display-name>`
+        : '';
+
+    const descriptionXml = description
+        ? `
+        <description xml:lang="x-default">${escapeXml(description)}</description>`
+        : '';
+
+    const attributeDefinitions =
+        attributes.length > 0
+            ? `
+        <attribute-definitions>
+${attributes.map((attr) => generateAttributeDefinition(attr)).join('\n')}
+        </attribute-definitions>`
+            : '';
+
+    const allAttributeIds = [keyDef.id, ...attributes.map((a) => a.id)];
+    const groupAttributes = allAttributeIds
+        .map((id) => `                <attribute attribute-id="${id}"/>`)
+        .join('\n');
+
+    return wrapInMetadata(`    <custom-type type-id="${typeId}">
+        <display-name xml:lang="x-default">${escapeXml(displayName)}</display-name>${descriptionXml}
+        <staging-mode>${stagingMode}</staging-mode>
+        <storage-scope>${storageScope}</storage-scope>
+        <key-definition attribute-id="${keyDef.id}">${keyDisplayNameXml}${keyDescriptionXml}
+            <type>${keyDef.type || 'string'}</type>
+            <min-length>${keyDef.minLength || 0}</min-length>
+        </key-definition>${attributeDefinitions}
+        <group-definitions>
+            <attribute-group group-id="${groupId}">
+                <display-name xml:lang="x-default">${escapeXml(displayName)}</display-name>
+${groupAttributes}
+            </attribute-group>
+        </group-definitions>
+    </custom-type>`);
+}
+
+/**
+ * Generates system object type extension XML for site preferences
+ * @param {Object} config - Site preference configuration
+ * @returns {string} XML document
+ */
+function generateSitePreference(config) {
+    const {
+        attributeId,
+        displayName = attributeId,
+        description = '',
+        type = 'string',
+        mandatory = false,
+        externallyManaged = false,
+        defaultValue = null,
+        groupId = 'Custom',
+        groupDisplayName = groupId,
+        existingGroupAttributes = [],
+        enumValues = [],
+        multiSelect = false,
+        minLength = 0,
+    } = config;
+
+    const attr = {
+        id: attributeId,
+        displayName,
+        description,
+        type,
+        localizable: false,
+        mandatory,
+        externallyManaged,
+        defaultValue,
+        enumValues,
+        multiSelect,
+        minLength,
+    };
+
+    const allAttributes = [...existingGroupAttributes, attributeId];
+    const groupAttributes = allAttributes
+        .map((id) => `                <attribute attribute-id="${id}"/>`)
+        .join('\n');
+
+    return wrapInMetadata(`    <type-extension type-id="SitePreferences">
+        <custom-attribute-definitions>
+${generateAttributeDefinition(attr)}
+        </custom-attribute-definitions>
+        <group-definitions>
+            <attribute-group group-id="${groupId}">
+                <display-name xml:lang="x-default">${escapeXml(groupDisplayName)}</display-name>
+${groupAttributes}
+            </attribute-group>
+        </group-definitions>
+    </type-extension>`);
+}
+
+/**
+ * Generates system object extension XML
+ * @param {Object} config - System object extension configuration
+ * @returns {string} XML document
+ */
+function generateSystemObjectExtension(config) {
+    const {
+        objectTypeId,
+        attributeId,
+        displayName = attributeId,
+        description = '',
+        type = 'string',
+        mandatory = false,
+        externallyManaged = false,
+        defaultValue = null,
+        groupId,
+        groupDisplayName,
+        existingGroupAttributes = [],
+        enumValues = [],
+        multiSelect = false,
+        minLength = 0,
+        localizable = false,
+    } = config;
+
+    const attr = {
+        id: attributeId,
+        displayName,
+        description,
+        type,
+        localizable,
+        mandatory,
+        externallyManaged,
+        defaultValue,
+        enumValues,
+        multiSelect,
+        minLength,
+    };
+
+    const allAttributes = [...existingGroupAttributes, attributeId];
+    const groupAttributes = allAttributes
+        .map((id) => `                <attribute attribute-id="${id}"/>`)
+        .join('\n');
+
+    const finalGroupId = groupId || `${objectTypeId}_Custom`;
+    const finalGroupDisplayName = groupDisplayName || finalGroupId;
+
+    return wrapInMetadata(`    <type-extension type-id="${objectTypeId}">
+        <custom-attribute-definitions>
+${generateAttributeDefinition(attr)}
+        </custom-attribute-definitions>
+        <group-definitions>
+            <attribute-group group-id="${finalGroupId}">
+                <display-name xml:lang="x-default">${escapeXml(finalGroupDisplayName)}</display-name>
+${groupAttributes}
+            </attribute-group>
+        </group-definitions>
+    </type-extension>`);
+}
+
+/**
+ * Escapes special XML characters
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeXml(str) {
+    if (!str) return '';
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+
+module.exports = {
+    XML_HEADER,
+    METADATA_NAMESPACE,
+    wrapInMetadata,
+    generateAttributeDefinition,
+    generateCustomObjectDefinition,
+    generateSitePreference,
+    generateSystemObjectExtension,
+    escapeXml,
+};