@contrail/cli 3.5.2 → 3.5.3-alpha.317fe63

package/dist/helpers/projects/post-processor.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectPostProcessor = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("../../logger"));
+/**
+ * Main class for processing project YAML data
+ */
+class ProjectPostProcessor {
+    stats;
+    options;
+    projectId = null;
+    constructor(options = {}) {
+        this.options = {
+            removeBackings: true,
+            fixMissingIdentifiers: true,
+            cleanProperties: true,
+            analyzeOnly: false,
+            verbose: false,
+            ...options,
+        };
+        this.stats = this.initializeStats();
+    }
+    initializeStats() {
+        return {
+            itemTypeConverted: 0,
+            nbFXRatesRemoved: 0,
+            createdByRemoved: 0,
+            updatedByRemoved: 0,
+            emptyAssortmentAttsRemoved: 0,
+            identifiersCreated: 0,
+            planIdentifiers: 0,
+            backingIdentifiers: 0,
+            folderIdentifiers: 0,
+            viewsIdentifiers: 0,
+            assortmentIdentifiers: 0,
+            backingsRemoved: 0,
+            removedBackingNames: [],
+            totalObjects: 0,
+            totalAssortments: 0,
+            totalPlans: 0,
+            totalBackings: 0,
+            totalFolders: 0,
+            duplicateIdentifiers: 0,
+            emptyIdentifiers: 0,
+            missingIdentifiers: 0,
+        };
+    }
+    /**
+     * Main processing method for project data
+     */
+    processProjectData(projectData) {
+        try {
+            if (this.options.verbose) {
+                logger_1.default.info('Starting project data processing...');
+            }
+            // Extract project ID
+            this.extractProjectId(projectData);
+            // Analysis phase
+            const analysisResults = this.analyzeProjectData(projectData);
+            if (this.options.analyzeOnly) {
+                return { data: projectData, results: analysisResults };
+            }
+            let processedData = projectData;
+            // Processing phase
+            if (this.options.cleanProperties) {
+                if (this.options.verbose)
+                    logger_1.default.info('Cleaning properties...');
+                processedData = this.cleanProperties(processedData);
+            }
+            if (this.options.fixMissingIdentifiers) {
+                if (this.options.verbose)
+                    logger_1.default.info('Fixing missing identifiers...');
+                processedData = this.fixMissingIdentifiers(processedData);
+            }
+            if (this.options.removeBackings) {
+                if (this.options.verbose)
+                    logger_1.default.info('Removing backing assortments...');
+                processedData = this.removeBackings(processedData);
+            }
+            // Final analysis after processing
+            const finalAnalysis = this.analyzeProjectData(processedData);
+            if (this.options.verbose) {
+                this.logProcessingSummary();
+            }
+            return { data: processedData, results: finalAnalysis };
+        }
+        catch (error) {
+            logger_1.default.error('Error processing project data:', error);
+            throw error;
+        }
+    }
+    /**
+     * Extract project ID from project data
+     */
+    extractProjectId(projectData) {
+        if (projectData.projectConfiguration?.projectName) {
+            this.projectId = projectData.projectConfiguration.projectName;
+        }
+        else if (projectData.name?.match(/^S\d-\d+/)) {
+            const match = projectData.name.match(/^(S\d-\d+)/);
+            this.projectId = match ? match[1] : null;
+        }
+        if (this.options.verbose && this.projectId) {
+            logger_1.default.info(`Project ID identified: ${this.projectId}`);
+        }
+    }
+    /**
+     * Analyze project data for identifiers, types, and structure
+     */
+    analyzeProjectData(projectData) {
+        const identifiers = {};
+        const duplicates = {};
+        const emptyIdentifierObjects = [];
+        const missingIdentifierObjects = {
+            assortments: [],
+            plans: [],
+            folders: [],
+        };
+        const analyzeObject = (obj, path = []) => {
+            if (!obj || typeof obj !== 'object')
+                return;
+            if (Array.isArray(obj)) {
+                obj.forEach((item, index) => {
+                    analyzeObject(item, [...path, index.toString()]);
+                });
+                return;
+            }
+            this.stats.totalObjects++;
+            // Analyze object with name
+            if (obj.name) {
+                // Determine object type
+                let objType = 'unknown';
+                if (obj.subFolders) {
+                    objType = 'folder';
+                    this.stats.totalFolders++;
+                }
+                if (obj.type) {
+                    objType = obj.type.toLowerCase();
+                    if (objType === 'plan')
+                        this.stats.totalPlans++;
+                    if (objType === 'assortment')
+                        this.stats.totalAssortments++;
+                    if (objType === 'backing')
+                        this.stats.totalBackings++;
+                }
+                // Check identifier
+                if (obj.identifier !== undefined) {
+                    const id = obj.identifier;
+                    if (!id || id.trim() === '') {
+                        this.stats.emptyIdentifiers++;
+                        emptyIdentifierObjects.push({
+                            name: obj.name,
+                            path: path.join('.'),
+                        });
+                    }
+                    else {
+                        if (identifiers[id]) {
+                            identifiers[id].count++;
+                            identifiers[id].names.push(obj.name);
+                            identifiers[id].paths.push(path.join('.'));
+                        }
+                        else {
+                            identifiers[id] = {
+                                count: 1,
+                                names: [obj.name],
+                                paths: [path.join('.')],
+                            };
+                        }
+                    }
+                }
+                else if (this.shouldHaveIdentifier(obj)) {
+                    this.stats.missingIdentifiers++;
+                    if (objType === 'assortment') {
+                        missingIdentifierObjects.assortments.push({
+                            name: obj.name,
+                            path: path.join('.'),
+                        });
+                    }
+                    else if (objType === 'plan') {
+                        missingIdentifierObjects.plans.push({
+                            name: obj.name,
+                            path: path.join('.'),
+                        });
+                    }
+                    else if (objType === 'folder') {
+                        missingIdentifierObjects.folders.push({
+                            name: obj.name,
+                            path: path.join('.'),
+                        });
+                    }
+                }
+            }
+            // Recursively analyze nested objects
+            for (const key in obj) {
+                if (typeof obj[key] === 'object' && obj[key] !== null) {
+                    analyzeObject(obj[key], [...path, key]);
+                }
+            }
+        };
+        analyzeObject(projectData);
+        // Find duplicates
+        for (const [id, info] of Object.entries(identifiers)) {
+            if (info.count > 1) {
+                duplicates[id] = info;
+            }
+        }
+        this.stats.duplicateIdentifiers = Object.keys(duplicates).length;
+        return {
+            stats: { ...this.stats },
+            duplicates,
+            emptyIdentifierObjects,
+            missingIdentifierObjects,
+        };
+    }
+    /**
+     * Clean properties from project data
+     */
+    cleanProperties(projectData) {
+        const processObject = (obj) => {
+            if (!obj || typeof obj !== 'object')
+                return obj;
+            if (Array.isArray(obj)) {
+                return obj.map((item) => processObject(item));
+            }
+            const newObj = {};
+            for (const key in obj) {
+                if (!Object.prototype.hasOwnProperty.call(obj, key))
+                    continue;
+                if (key === 'itemType') {
+                    // Handle itemType conversion
+                    if (typeof obj[key] === 'object' && obj[key]?.typePath) {
+                        newObj[key] = obj[key].typePath;
+                        this.stats.itemTypeConverted++;
+                    }
+                    else {
+                        newObj[key] = obj[key];
+                    }
+                }
+                else if (key === 'nbFXRates') {
+                    // Remove nbFXRates
+                    this.stats.nbFXRatesRemoved++;
+                    if (this.options.verbose) {
+                        logger_1.default.debug(`Removed nbFXRates from object: ${obj.name || 'unnamed'}`);
+                    }
+                }
+                else if (key === 'updatedBy') {
+                    // Remove updatedBy
+                    this.stats.updatedByRemoved++;
+                }
+                else if (key === 'createdBy') {
+                    // Remove createdBy
+                    this.stats.createdByRemoved++;
+                }
+                else if (key === 'assortmentAtts' && typeof obj[key] === 'object') {
+                    // Process assortmentAtts
+                    const processedAtts = this.processAssortmentAtts(obj[key]);
+                    if (Object.keys(processedAtts).length > 0) {
+                        newObj[key] = processedAtts;
+                    }
+                    else {
+                        this.stats.emptyAssortmentAttsRemoved++;
+                    }
+                }
+                else if (obj[key] === null) {
+                    // Skip null values
+                }
+                else if (typeof obj[key] === 'object') {
+                    newObj[key] = processObject(obj[key]);
+                }
+                else {
+                    newObj[key] = obj[key];
+                }
+            }
+            return newObj;
+        };
+        return processObject(projectData);
+    }
+    /**
+     * Process assortmentAtts object
+     */
+    processAssortmentAtts(assortmentAtts) {
+        const processed = {};
+        for (const key in assortmentAtts) {
+            if (key === 'updatedBy' || key === 'createdBy') {
+                // Skip these properties
+                if (key === 'updatedBy')
+                    this.stats.updatedByRemoved++;
+                if (key === 'createdBy')
+                    this.stats.createdByRemoved++;
+            }
+            else if (key === 'nbFXRates') {
+                // Skip nbFXRates
+                this.stats.nbFXRatesRemoved++;
+            }
+            else if (key === 'itemTypeId') {
+                // Skip itemTypeId
+                this.stats.itemTypeIdRemoved++;
+            }
+            else if (key === 'itemType' &&
+                typeof assortmentAtts[key] === 'object' &&
+                assortmentAtts[key]?.typePath) {
+                // Convert itemType object to string
+                processed[key] = assortmentAtts[key].typePath;
+                this.stats.itemTypeConverted++;
+            }
+            else if (assortmentAtts[key] !== null && assortmentAtts[key] !== undefined) {
+                // Keep other properties
+                processed[key] = assortmentAtts[key];
+            }
+        }
+        return processed;
+    }
+    /**
+     * Fix missing identifiers
+     */
+    fixMissingIdentifiers(projectData) {
+        const processObject = (obj, path = [], parentIdentifier = '') => {
+            if (!obj || typeof obj !== 'object')
+                return obj;
+            if (Array.isArray(obj)) {
+                return obj.map((item, index) => processObject(item, [...path, index.toString()], parentIdentifier));
+            }
+            const newObj = { ...obj };
+            // Generate identifier if missing
+            if (newObj.name && !newObj.identifier && this.shouldHaveIdentifier(newObj)) {
+                const identifier = this.generateIdentifier(newObj, parentIdentifier);
+                if (identifier) {
+                    newObj.identifier = identifier;
+                    this.stats.identifiersCreated++;
+                    const objType = this.getObjectType(newObj);
+                    if (objType === 'plan')
+                        this.stats.planIdentifiers++;
+                    else if (objType === 'assortment')
+                        this.stats.assortmentIdentifiers++;
+                    else if (objType === 'backing')
+                        this.stats.backingIdentifiers++;
+                    else if (objType === 'folder')
+                        this.stats.folderIdentifiers++;
+                    if (newObj.name.toLowerCase().includes('views')) {
+                        this.stats.viewsIdentifiers++;
+                    }
+                    if (this.options.verbose) {
+                        logger_1.default.debug(`Generated identifier "${identifier}" for "${newObj.name}"`);
+                    }
+                }
+            }
+            else if (newObj.identifier) {
+                parentIdentifier = newObj.identifier;
+            }
+            // Process nested objects
+            for (const key in newObj) {
+                if (typeof newObj[key] === 'object' && newObj[key] !== null && key !== 'identifier') {
+                    newObj[key] = processObject(newObj[key], [...path, key], parentIdentifier);
+                }
+            }
+            return newObj;
+        };
+        return processObject(projectData);
+    }
+    /**
+     * Remove backing assortments
+     */
+    removeBackings(projectData) {
+        const processObject = (obj) => {
+            if (!obj || typeof obj !== 'object')
+                return obj;
+            if (Array.isArray(obj)) {
+                const filtered = obj.filter((item) => {
+                    if (item && item.type === 'BACKING') {
+                        this.stats.backingsRemoved++;
+                        if (item.name) {
+                            this.stats.removedBackingNames.push(item.name);
+                        }
+                        if (this.options.verbose) {
+                            logger_1.default.debug(`Removed backing: ${item.name || 'unnamed'}`);
+                        }
+                        return false;
+                    }
+                    return true;
+                });
+                return filtered.map((item) => processObject(item));
+            }
+            const newObj = {};
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    newObj[key] = processObject(obj[key]);
+                }
+            }
+            return newObj;
+        };
+        return processObject(projectData);
+    }
+    /**
+     * Generate identifier for an object
+     */
+    generateIdentifier(obj, parentIdentifier) {
+        const objType = this.getObjectType(obj);
+        let typeSuffix = 'folder';
+        if (objType === 'plan')
+            typeSuffix = 'product.plan';
+        else if (objType === 'assortment')
+            typeSuffix = 'product.assortment';
+        else if (objType === 'backing')
+            typeSuffix = 'backing';
+        const sanitizeName = (name) => {
+            return name
+                .toLowerCase()
+                .replace(/'/g, '')
+                .replace(/&/g, 'and')
+                .replace(/\s+/g, '')
+                .replace(/[^\w]/g, '');
+        };
+        // Strategy 1: Extract from name pattern
+        const nameMatch = obj.name.match(/^(S\d-\d+)\s+(.+)$/);
+        if (nameMatch) {
+            const projectId = nameMatch[1];
+            const sanitizedName = sanitizeName(nameMatch[2]);
+            return `${projectId}:${sanitizedName}:${typeSuffix}`;
+        }
+        // Strategy 2: Views objects
+        if (obj.name.toLowerCase().includes('views')) {
+            let sanitizedName = 'main';
+            if (obj.name.startsWith('Views -')) {
+                sanitizedName = sanitizeName(obj.name.substring(8).trim());
+            }
+            else if (obj.name.toLowerCase() !== 'views') {
+                sanitizedName = sanitizeName(obj.name);
+            }
+            const baseId = this.projectId || parentIdentifier;
+            return `${baseId}:views:${sanitizedName}:${typeSuffix}`;
+        }
+        // Strategy 3: Training objects
+        if (obj.name.toLowerCase().includes('training')) {
+            let sanitizedName;
+            if (obj.name.startsWith('(Training)')) {
+                sanitizedName = sanitizeName(obj.name.substring(10).trim());
+            }
+            else {
+                sanitizedName = sanitizeName(obj.name);
+            }
+            const baseId = this.projectId || parentIdentifier;
+            return `${baseId}:training:${sanitizedName}:${typeSuffix}`;
+        }
+        // Strategy 4: Seasonal/Regional patterns
+        if (obj.name.match(/^(SS|FW|SU|FA)\d{2}/i) || obj.name.match(/^(APAC|NA|EMEA|LATAM|ANZ)/i)) {
+            const sanitizedName = sanitizeName(obj.name);
+            const baseId = this.projectId || parentIdentifier;
+            if (obj.name.match(/^(SS|FW|SU|FA)\d{2}/i)) {
+                return `${baseId}:seasons:${sanitizedName}:${typeSuffix}`;
+            }
+            else {
+                return `${baseId}:regions:${sanitizedName}:${typeSuffix}`;
+            }
+        }
+        // Strategy 5: Use parent identifier
+        if (parentIdentifier) {
+            const sanitizedName = sanitizeName(obj.name);
+            return `${parentIdentifier}:${sanitizedName}:${typeSuffix}`;
+        }
+        // Strategy 6: Use project ID
+        if (this.projectId) {
+            const sanitizedName = sanitizeName(obj.name);
+            return `${this.projectId}:${sanitizedName}:${typeSuffix}`;
+        }
+        return null;
+    }
+    /**
+     * Determine object type
+     */
+    getObjectType(obj) {
+        if (obj.subFolders)
+            return 'folder';
+        if (obj.type)
+            return obj.type.toLowerCase();
+        return 'unknown';
+    }
+    /**
+     * Check if object should have an identifier
+     */
+    shouldHaveIdentifier(obj) {
+        return (obj.name &&
+            (obj.type === 'ASSORTMENT' || obj.type === 'PLAN' || obj.type === 'BACKING' || obj.subFolders));
+    }
+    /**
+     * Log processing summary
+     */
+    logProcessingSummary() {
+        logger_1.default.info('========== PROCESSING SUMMARY ==========');
+        if (this.options.cleanProperties) {
+            logger_1.default.info('PROPERTY CLEANING:');
+            logger_1.default.info(`- ItemType objects converted: ${this.stats.itemTypeConverted}`);
+            logger_1.default.info(`- nbFXRates properties removed: ${this.stats.nbFXRatesRemoved}`);
+            logger_1.default.info(`- updatedBy properties removed: ${this.stats.updatedByRemoved}`);
+            logger_1.default.info(`- createdBy properties removed: ${this.stats.createdByRemoved}`);
+            logger_1.default.info(`- Empty assortmentAtts removed: ${this.stats.emptyAssortmentAttsRemoved}`);
+        }
+        if (this.options.fixMissingIdentifiers) {
+            logger_1.default.info('IDENTIFIER GENERATION:');
+            logger_1.default.info(`- Total identifiers created: ${this.stats.identifiersCreated}`);
+            logger_1.default.info(`  - Assortments: ${this.stats.assortmentIdentifiers}`);
+            logger_1.default.info(`  - Plans: ${this.stats.planIdentifiers}`);
+            logger_1.default.info(`  - Backings: ${this.stats.backingIdentifiers}`);
+            logger_1.default.info(`  - Folders: ${this.stats.folderIdentifiers}`);
+            logger_1.default.info(`  - Views: ${this.stats.viewsIdentifiers}`);
+        }
+        if (this.options.removeBackings) {
+            logger_1.default.info('BACKING REMOVAL:');
+            logger_1.default.info(`- Backing assortments removed: ${this.stats.backingsRemoved}`);
+        }
+    }
+    /**
+     * Get processing statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+}
+exports.ProjectPostProcessor = ProjectPostProcessor;

package/dist/helpers/types/type-uploader.js

@@ -303,7 +303,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
             }
         }
         catch (err) {
-            throw new Error(`Error Deleting Properties: ${err}`);
+            logger_1.default.error(`Error Deleting Type-Property ${currentPropertyType.slug}: ${err}`);
         }
     }
 }

package/dist/interfaces.d.ts

@@ -370,31 +370,6 @@ export interface ReducedOptionSet {
     isArchived: boolean;
     optionSet: any[];
 }
-export interface ReducedUsageInfo {
-    typeId: string;
-    typePropertyId: string;
-    typePath: string;
-    typePropertySlug: string;
-    editable: boolean;
-    used: boolean;
-    formulaFunction?: string;
-    validationFunction?: string;
-    numberFormat?: any;
-    defaultValue?: string;
-    label?: string;
-    required?: boolean;
-    searchable?: boolean;
-    isUniqueProperty?: boolean;
-    isUniquePropertyInFamily?: boolean;
-    copyBehavior?: string;
-    copyDefault?: string;
-    propertyLevel?: string;
-    isArchived: boolean;
-    isFederationProperty?: boolean;
-    carryOverBehavior?: string;
-    carryOverDefault?: string;
-}
-export type PersistReducedUsageInfo = Omit<ReducedUsageInfo, 'typePath' | 'typePropertySlug'>;
 export declare enum PropertyType {
     Text = "text",
     String = "string",

package/node_modules/@contrail/org-config-migration/.github/workflows/publish-to-npm.yml

@@ -0,0 +1,117 @@
+name: Publish to NPM
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: ['**']
+
+jobs:
+  check-version:
+    name: Verify version is available on npm
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check version not already published
+        run: |
+          PACKAGE_NAME=$(node -p "require('./package.json').name")
+          VERSION=$(node -p "require('./package.json').version")
+          echo "Checking if ${PACKAGE_NAME}@${VERSION} exists on npm..."
+          if npm view "${PACKAGE_NAME}@${VERSION}" version 2>/dev/null; then
+            echo "::error::Version ${VERSION} is already published on npm. Bump the version in package.json before merging."
+            exit 1
+          else
+            echo "Version ${VERSION} is available."
+          fi
+
+  check-dependencies:
+    name: Verify no private dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Verify no private dependencies
+        run: |
+          node -e "
+            const deps = require('./package.json').dependencies || {};
+            const { execSync } = require('child_process');
+            let failed = false;
+            for (const pkg of Object.keys(deps)) {
+              try {
+                execSync('npm view ' + pkg, { stdio: 'pipe' });
+              } catch {
+                console.error('::error::Dependency ' + pkg + ' is not publicly accessible on npm');
+                failed = true;
+              }
+            }
+            if (failed) process.exit(1);
+            console.log('All ' + Object.keys(deps).length + ' dependencies are public.');
+          "
+
+  publish-alpha:
+    name: Publish alpha
+    needs: check-dependencies
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish alpha
+        id: publish
+        run: |
+          SHORT_SHA=$(echo ${{ github.event.pull_request.head.sha }} | cut -c1-7)
+          VERSION=$(node -p "require('./package.json').version")-alpha.${SHORT_SHA}
+          npm version $VERSION --no-git-tag-version
+          OUTPUT=$(npm publish --tag alpha 2>&1) && {
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+          } || {
+            if echo "$OUTPUT" | grep -q "You cannot publish over the previously published versions"; then
+              echo "::warning::Alpha ${VERSION} already published, skipping."
+            else
+              echo "::error::Failed to publish alpha ${VERSION}"
+              echo "$OUTPUT"
+              exit 1
+            fi
+          }
+
+  publish-release:
+    name: Publish release
+    needs: check-dependencies
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    outputs:
+      version: ${{ steps.publish.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install and build
+        run: npm ci && npm run build
+
+      - name: Publish release
+        id: publish
+        run: |
+          npm publish
+          echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT

package/node_modules/@contrail/org-config-migration/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from './types';
-export * from './services';
-export * from './users';
+export * from './types';
+export * from './services';
+export * from './users';