sfcc-metadata-cli 0.0.1 → 1.0.0

package/lib/utils.js

@@ -0,0 +1,188 @@
+/**
+ * Utility functions for migration helper
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Generates a migration name using timestamp format: YYYYMMDD_HHMMSS
+ * This ensures unique, sortable migration names without conflicts.
+ * Optionally appends a description: YYYYMMDD_HHMMSS_description
+ * @param {string} migrationsDir - Path to migrations directory (unused, kept for compatibility)
+ * @param {string} [description] - Optional description to append
+ * @returns {string} Migration name
+ */
+function generateMigrationName(migrationsDir, description) {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = (now.getMonth() + 1).toString().padStart(2, '0');
+    const day = now.getDate().toString().padStart(2, '0');
+    const hours = now.getHours().toString().padStart(2, '0');
+    const minutes = now.getMinutes().toString().padStart(2, '0');
+    const seconds = now.getSeconds().toString().padStart(2, '0');
+
+    const timestamp = `${year}${month}${day}_${hours}${minutes}${seconds}`;
+
+    if (description) {
+        // Sanitize description: lowercase, replace spaces with underscores, remove special chars
+        const sanitized = description
+            .toLowerCase()
+            .replace(/\s+/g, '_')
+            .replace(/[^a-z0-9_]/g, '')
+            .substring(0, 50); // Limit length
+        return `${timestamp}_${sanitized}`;
+    }
+
+    return timestamp;
+}
+
+/**
+ * Generates a short migration name using date only: YYYYMMDD_N
+ * Falls back to this format if multiple migrations on same day
+ * @param {string} migrationsDir - Path to migrations directory
+ * @param {string} [description] - Optional description to append
+ * @returns {string} Migration name
+ */
+function generateShortMigrationName(migrationsDir, description) {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = (now.getMonth() + 1).toString().padStart(2, '0');
+    const day = now.getDate().toString().padStart(2, '0');
+    const datePrefix = `${year}${month}${day}`;
+
+    // Find existing migrations for today
+    let todayCount = 0;
+    if (fs.existsSync(migrationsDir)) {
+        todayCount = fs
+            .readdirSync(migrationsDir)
+            .filter((name) => name.startsWith(datePrefix)).length;
+    }
+
+    const sequence = (todayCount + 1).toString().padStart(2, '0');
+    const base = `${datePrefix}_${sequence}`;
+
+    if (description) {
+        const sanitized = description
+            .toLowerCase()
+            .replace(/\s+/g, '_')
+            .replace(/[^a-z0-9_]/g, '')
+            .substring(0, 50);
+        return `${base}_${sanitized}`;
+    }
+
+    return base;
+}
+
+/**
+ * Lists all existing migrations sorted by name (chronological for timestamp format)
+ * @param {string} migrationsDir - Path to migrations directory
+ * @returns {string[]} Array of migration names
+ */
+function listMigrations(migrationsDir) {
+    if (!fs.existsSync(migrationsDir)) {
+        return [];
+    }
+
+    return fs
+        .readdirSync(migrationsDir)
+        .filter((name) => {
+            const fullPath = path.join(migrationsDir, name);
+            // Match both old format (YY.MM.N) and new format (YYYYMMDD_*)
+            return (
+                fs.statSync(fullPath).isDirectory() &&
+                (/^\d{2}\.\d{2}\.\d+/.test(name) || /^\d{8}_/.test(name))
+            );
+        })
+        .sort(compareMigrationVersions);
+}
+
+/**
+ * Compares two migration version strings
+ * Handles both old format (YY.MM.N) and new format (YYYYMMDD_HHMMSS)
+ * @param {string} a - First version
+ * @param {string} b - Second version
+ * @returns {number} Comparison result
+ */
+function compareMigrationVersions(a, b) {
+    // New timestamp format sorts alphabetically correctly
+    // Old format needs special handling
+    const isOldFormatA = /^\d{2}\.\d{2}\.\d+/.test(a);
+    const isOldFormatB = /^\d{2}\.\d{2}\.\d+/.test(b);
+
+    // Old format migrations come before new format
+    if (isOldFormatA && !isOldFormatB) return -1;
+    if (!isOldFormatA && isOldFormatB) return 1;
+
+    // Both old format: compare by parts
+    if (isOldFormatA && isOldFormatB) {
+        const partsA = a.split('.').map((p) => Number.parseInt(p, 10) || 0);
+        const partsB = b.split('.').map((p) => Number.parseInt(p, 10) || 0);
+
+        const maxLength = Math.max(partsA.length, partsB.length);
+        for (let i = 0; i < maxLength; i++) {
+            const numA = partsA[i] || 0;
+            const numB = partsB[i] || 0;
+            if (numA !== numB) {
+                return numA - numB;
+            }
+        }
+        return 0;
+    }
+
+    // Both new format: simple string comparison works
+    return a.localeCompare(b);
+}
+
+/**
+ * Ensures a directory exists, creating it if necessary
+ * @param {string} dirPath - Path to directory
+ */
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+/**
+ * Writes content to a file, creating directories as needed
+ * @param {string} filePath - Path to file
+ * @param {string} content - File content
+ */
+function writeFile(filePath, content) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, content, 'utf8');
+}
+
+/**
+ * Reads and parses an existing XML file or returns null
+ * @param {string} filePath - Path to XML file
+ * @returns {string|null} File content or null
+ */
+function readXmlFile(filePath) {
+    if (fs.existsSync(filePath)) {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    return null;
+}
+
+/**
+ * Gets the latest migration folder
+ * @param {string} migrationsDir - Path to migrations directory
+ * @returns {string|null} Latest migration name or null
+ */
+function getLatestMigration(migrationsDir) {
+    const migrations = listMigrations(migrationsDir);
+    return migrations.length > 0 ? migrations[migrations.length - 1] : null;
+}
+
+module.exports = {
+    generateMigrationName,
+    generateShortMigrationName,
+    listMigrations,
+    compareMigrationVersions,
+    ensureDir,
+    writeFile,
+    readXmlFile,
+    getLatestMigration,
+};

package/package.json

@@ -1,17 +1,26 @@
 {
-  "name": "sfcc-metadata-cli",
-  "version": "0.0.1",
-  "description": "CLI tool for creating SFCC B2C metadata migrations",
-  "main": "index.js",
-  "bin": {
-    "sfcc-metadata": "./index.js"
-  },
-  "scripts": {
-    "start": "node index.js",
-    "test": "node --test",
-    "check": "biome check .",
-    "check:write": "biome check --write ."
-  },
-  "author": "",
-  "license": "AGPL-3.0-or-later"
+    "name": "sfcc-metadata-cli",
+    "version": "1.0.0",
+    "description": "CLI tool for creating SFCC B2C metadata migrations",
+    "main": "index.js",
+    "bin": {
+        "sfcc-metadata": "./index.js"
+    },
+    "scripts": {
+        "start": "node index.js",
+        "test": "node --test",
+        "check": "biome check .",
+        "check:write": "biome check --write ."
+    },
+    "keywords": ["sfcc", "b2c", "migration", "salesforce", "metadata", "cli"],
+    "author": "",
+    "license": "AGPL-3.0-or-later",
+    "dependencies": {
+        "chalk": "^4.1.2",
+        "inquirer": "^8.2.6",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^1.9.4"
+    }
 }

package/test/merge.test.js

@@ -0,0 +1,84 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { mergeSystemObjectExtension } = require('../lib/merge');
+
+const BASE_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<metadata xmlns="http://www.demandware.com/xml/impex/metadata/2006-10-31">
+</metadata>`;
+
+const EXISTING_TYPE_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<metadata xmlns="http://www.demandware.com/xml/impex/metadata/2006-10-31">
+    <type-extension type-id="Order">
+        <custom-attribute-definitions>
+            <attribute-definition attribute-id="existingAttr">
+                <type>string</type>
+            </attribute-definition>
+        </custom-attribute-definitions>
+        <group-definitions>
+            <attribute-group group-id="Order_Custom">
+                <display-name xml:lang="x-default">Order Custom</display-name>
+                <attribute attribute-id="existingAttr"/>
+            </attribute-group>
+        </group-definitions>
+    </type-extension>
+</metadata>`;
+
+describe('mergeSystemObjectExtension', () => {
+    it('should add new type extension to empty metadata', () => {
+        const result = mergeSystemObjectExtension(BASE_XML, {
+            objectTypeId: 'Order',
+            attributeId: 'newAttr',
+            displayName: 'New Attribute',
+            type: 'string',
+            groupId: 'Order_Custom',
+        });
+
+        assert.strictEqual(result.typeExtensionExisted, false);
+        assert.strictEqual(result.groupExisted, false);
+        assert.ok(result.xml.includes('type-extension type-id="Order"'));
+        assert.ok(result.xml.includes('attribute-id="newAttr"'));
+    });
+
+    it('should merge into existing type extension', () => {
+        const result = mergeSystemObjectExtension(EXISTING_TYPE_XML, {
+            objectTypeId: 'Order',
+            attributeId: 'anotherAttr',
+            displayName: 'Another Attribute',
+            type: 'boolean',
+            groupId: 'Order_Custom',
+        });
+
+        assert.strictEqual(result.typeExtensionExisted, true);
+        assert.strictEqual(result.groupExisted, true);
+        assert.ok(result.xml.includes('attribute-id="existingAttr"'));
+        assert.ok(result.xml.includes('attribute-id="anotherAttr"'));
+    });
+
+    it('should create new group if not exists', () => {
+        const result = mergeSystemObjectExtension(EXISTING_TYPE_XML, {
+            objectTypeId: 'Order',
+            attributeId: 'newGroupAttr',
+            displayName: 'New Group Attr',
+            type: 'string',
+            groupId: 'Order_NewGroup',
+            groupDisplayName: 'New Group',
+        });
+
+        assert.strictEqual(result.groupExisted, false);
+        assert.ok(result.xml.includes('group-id="Order_NewGroup"'));
+    });
+
+    it('should add new type extension for different object type', () => {
+        const result = mergeSystemObjectExtension(EXISTING_TYPE_XML, {
+            objectTypeId: 'Product',
+            attributeId: 'productAttr',
+            displayName: 'Product Attribute',
+            type: 'string',
+            groupId: 'Product_Custom',
+        });
+
+        assert.strictEqual(result.typeExtensionExisted, false);
+        assert.ok(result.xml.includes('type-extension type-id="Order"'));
+        assert.ok(result.xml.includes('type-extension type-id="Product"'));
+    });
+});

package/test/templates.test.js

@@ -0,0 +1,133 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const {
+    escapeXml,
+    wrapInMetadata,
+    generateAttributeDefinition,
+    XML_HEADER,
+    METADATA_NAMESPACE,
+} = require('../lib/templates');
+
+describe('escapeXml', () => {
+    it('should escape ampersand', () => {
+        assert.strictEqual(escapeXml('foo & bar'), 'foo & bar');
+    });
+
+    it('should escape less than', () => {
+        assert.strictEqual(escapeXml('a < b'), 'a &lt; b');
+    });
+
+    it('should escape greater than', () => {
+        assert.strictEqual(escapeXml('a > b'), 'a &gt; b');
+    });
+
+    it('should escape quotes', () => {
+        assert.strictEqual(escapeXml('"hello"'), '&quot;hello&quot;');
+    });
+
+    it('should escape apostrophes', () => {
+        assert.strictEqual(escapeXml("it's"), 'it&apos;s');
+    });
+
+    it('should handle empty string', () => {
+        assert.strictEqual(escapeXml(''), '');
+    });
+
+    it('should handle null/undefined', () => {
+        assert.strictEqual(escapeXml(null), '');
+        assert.strictEqual(escapeXml(undefined), '');
+    });
+
+    it('should escape multiple special characters', () => {
+        assert.strictEqual(
+            escapeXml('<tag attr="value">content & more</tag>'),
+            '&lt;tag attr=&quot;value&quot;&gt;content &amp; more&lt;/tag&gt;',
+        );
+    });
+});
+
+describe('wrapInMetadata', () => {
+    it('should wrap content with XML header and metadata element', () => {
+        const content = '    <test>content</test>';
+        const result = wrapInMetadata(content);
+
+        assert.ok(result.startsWith(XML_HEADER));
+        assert.ok(result.includes(`xmlns="${METADATA_NAMESPACE}"`));
+        assert.ok(result.includes(content));
+        assert.ok(result.includes('</metadata>'));
+    });
+});
+
+describe('generateAttributeDefinition', () => {
+    it('should generate string attribute definition', () => {
+        const xml = generateAttributeDefinition({
+            id: 'testAttr',
+            displayName: 'Test Attribute',
+            type: 'string',
+        });
+
+        assert.ok(xml.includes('attribute-id="testAttr"'));
+        assert.ok(xml.includes('<type>string</type>'));
+        assert.ok(
+            xml.includes(
+                '<display-name xml:lang="x-default">Test Attribute</display-name>',
+            ),
+        );
+        assert.ok(xml.includes('<min-length>0</min-length>'));
+    });
+
+    it('should generate boolean attribute definition', () => {
+        const xml = generateAttributeDefinition({
+            id: 'isEnabled',
+            type: 'boolean',
+            defaultValue: 'false',
+        });
+
+        assert.ok(xml.includes('<type>boolean</type>'));
+        assert.ok(xml.includes('<default-value>false</default-value>'));
+    });
+
+    it('should include description when provided', () => {
+        const xml = generateAttributeDefinition({
+            id: 'testAttr',
+            type: 'string',
+            description: 'This is a test',
+        });
+
+        assert.ok(
+            xml.includes(
+                '<description xml:lang="x-default">This is a test</description>',
+            ),
+        );
+    });
+
+    it('should set mandatory flag', () => {
+        const xml = generateAttributeDefinition({
+            id: 'requiredAttr',
+            type: 'string',
+            mandatory: true,
+        });
+
+        assert.ok(xml.includes('<mandatory-flag>true</mandatory-flag>'));
+    });
+
+    it('should generate enum attribute with values', () => {
+        const xml = generateAttributeDefinition({
+            id: 'status',
+            type: 'enum-of-string',
+            enumValues: [
+                { value: 'active', display: 'Active' },
+                { value: 'inactive', display: 'Inactive' },
+            ],
+        });
+
+        assert.ok(xml.includes('<type>enum-of-string</type>'));
+        assert.ok(xml.includes('<value>active</value>'));
+        assert.ok(
+            xml.includes('<display xml:lang="x-default">Active</display>'),
+        );
+        assert.ok(
+            xml.includes('<select-multiple-flag>false</select-multiple-flag>'),
+        );
+    });
+});

package/test/utils.test.js

@@ -0,0 +1,79 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const {
+    compareMigrationVersions,
+    generateMigrationName,
+} = require('../lib/utils');
+
+describe('compareMigrationVersions', () => {
+    it('should sort old format migrations correctly', () => {
+        const migrations = ['24.01.2', '24.01.1', '24.02.1', '23.12.1'];
+        const sorted = migrations.sort(compareMigrationVersions);
+        assert.deepStrictEqual(sorted, [
+            '23.12.1',
+            '24.01.1',
+            '24.01.2',
+            '24.02.1',
+        ]);
+    });
+
+    it('should sort new format migrations correctly', () => {
+        const migrations = [
+            '20251231_143052',
+            '20251231_100000',
+            '20251230_235959',
+        ];
+        const sorted = migrations.sort(compareMigrationVersions);
+        assert.deepStrictEqual(sorted, [
+            '20251230_235959',
+            '20251231_100000',
+            '20251231_143052',
+        ]);
+    });
+
+    it('should place old format before new format', () => {
+        const migrations = ['20251231_143052', '24.01.1'];
+        const sorted = migrations.sort(compareMigrationVersions);
+        assert.deepStrictEqual(sorted, ['24.01.1', '20251231_143052']);
+    });
+
+    it('should handle migrations with descriptions', () => {
+        const migrations = [
+            '20251231_143052_add_fields',
+            '20251231_100000_initial',
+        ];
+        const sorted = migrations.sort(compareMigrationVersions);
+        assert.deepStrictEqual(sorted, [
+            '20251231_100000_initial',
+            '20251231_143052_add_fields',
+        ]);
+    });
+});
+
+describe('generateMigrationName', () => {
+    it('should generate timestamp format without description', () => {
+        const name = generateMigrationName('./migrations');
+        assert.match(name, /^\d{8}_\d{6}$/);
+    });
+
+    it('should append sanitized description', () => {
+        const name = generateMigrationName('./migrations', 'Add Order Fields');
+        assert.match(name, /^\d{8}_\d{6}_add_order_fields$/);
+    });
+
+    it('should remove special characters from description', () => {
+        const name = generateMigrationName(
+            './migrations',
+            'Fix bug #123 (urgent!)',
+        );
+        assert.match(name, /^\d{8}_\d{6}_fix_bug_123_urgent$/);
+    });
+
+    it('should truncate long descriptions to 50 characters', () => {
+        const longDesc =
+            'this is a very long description that should be truncated to fifty characters maximum';
+        const name = generateMigrationName('./migrations', longDesc);
+        const descPart = name.split('_').slice(2).join('_');
+        assert.ok(descPart.length <= 50);
+    });
+});