@contrail/cli 3.5.3-alpha.0e9434c → 3.5.3-alpha.317fe63

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.5.3-alpha.0e9434c linux-x64 node-v24.16.0
+@contrail/cli/3.5.3-alpha.317fe63 linux-x64 node-v24.19.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND
@@ -779,23 +779,29 @@ EXAMPLES
 
 ## `contrail projects export PROJECTNAME`
 
-Export a project.
+Export a project with optional post-processing.
 
 ```
 USAGE
-  $ contrail projects export PROJECTNAME [-l error|warn|info|debug] [-e true|false]
+  $ contrail projects export PROJECTNAME [-l error|warn|info|debug] [-e true|false] [--process]
+
+ARGUMENTS
+  PROJECTNAME  Name or identifier of the project to export
 
 FLAGS
   -e, --alwaysConfirmEnv=<option>  [default: true] The Environment variables
                                    <options: true|false>
   -l, --logLevel=<option>          The Log Level
                                    <options: error|warn|info|debug>
+  --process                        Enable post-processing of exported project data
 
 DESCRIPTION
-  Export a project.
+  Export a project with optional post-processing.
 
 EXAMPLES
   $ contrail project export <PROJECT_NAME>
+
+  $ contrail project export <PROJECT_NAME> --process
 ```
 
 ## `contrail projects list`
@@ -1611,31 +1617,25 @@ EXAMPLES
 
 ## `contrail workflow-templates export`
 
-Export all workflows in the org. By default exports one file per app to the current directory.
+Export all workflows in the org.
 
 ```
 USAGE
-  $ contrail workflow-templates export [-l error|warn|info|debug] [-e true|false] [-f <value>] [-d <value>]
-  [--overwrite]
+  $ contrail workflow-templates export [-l error|warn|info|debug] [-e true|false] [-f <value>] [--overwrite]
 
 FLAGS
-  -d, --dir=<value>                [default: .] Directory to write per-app workflow files
   -e, --alwaysConfirmEnv=<option>  [default: true] The Environment variables
                                    <options: true|false>
-  -f, --outFile=<value>            Export all workflows to a single file at this path (overrides per-app export)
+  -f, --outFile=<value>            [default: workflows.yml] The location for the file to be saved
   -l, --logLevel=<option>          The Log Level
                                    <options: error|warn|info|debug>
   --overwrite                      Replaces existing files if they exist
 
 DESCRIPTION
-  Export all workflows in the org. By default exports one file per app to the current directory.
+  Export all workflows in the org.
 
 EXAMPLES
   $ contrail workflow-templates export
-
-  $ contrail workflow-templates export --dir ./workflows
-
-  $ contrail workflow-templates export --outFile workflows.yml
 ```
 
 ## `contrail workflow-templates list`

package/dist/commands/projects/export.d.ts

@@ -3,6 +3,7 @@ export default class ExportProjects extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        process: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };

package/dist/commands/projects/export.js

@@ -7,23 +7,37 @@ const login_1 = require("../../auth/login");
 const helpers_1 = require("../../helpers/projects/helpers");
 const basecommand_1 = require("../../basecommand");
 class ExportProjects extends basecommand_1.BaseCommand {
-    static description = 'Export a project.';
+    static description = 'Export a project with optional post-processing.';
     static examples = [
-        `$ contrail project export <PROJECT_NAME>
-`,
+        '$ contrail project export <PROJECT_NAME>',
+        '$ contrail project export <PROJECT_NAME> --process',
     ];
     static flags = {
         ...basecommand_1.BaseCommand.baseFlags,
+        process: core_1.Flags.boolean({
+            description: 'Enable post-processing of exported project data',
+            default: false,
+        }),
     };
     static args = {
-        projectName: core_1.Args.string({ description: '', required: true }),
+        projectName: core_1.Args.string({
+            description: 'Name or identifier of the project to export',
+            required: true,
+        }),
     };
     async run() {
         try {
             await (0, login_1.authUser)();
             this.log(`${chalk_1.default.blue.bold('START')} Exporting Project.`);
+            const processingOptions = {
+                removeBackings: true,
+                fixMissingIdentifiers: true,
+                cleanProperties: true,
+                analyzeOnly: false,
+                verbose: false,
+            };
             this.log(`${chalk_1.default.yellow.bold('PROJECT')} Exporting`);
-            await (0, helpers_1.exportProject)(this.args.projectName);
+            await (0, helpers_1.exportProject)(this.args.projectName, this.flags.process ? processingOptions : null);
             this.log(`${chalk_1.default.yellow.bold('PROJECT')} Exported`);
         }
         catch (e) {

package/dist/commands/workflow-templates/export.d.ts

@@ -5,12 +5,10 @@ export default class ExportWorkflows extends BaseCommand {
     static examples: string[];
     static flags: {
         outFile: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        dir: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         overwrite: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     run(): Promise<void>;
 }
-export declare function exportWorkflowsByApp(outputDir: string, overwrite: boolean): Promise<void>;
-export declare function exportWorkflowsToFile(fileLocation: string, overwrite: boolean): Promise<void>;
+export declare function exportWorkflows(fileLocation: string, overwrite: boolean): Promise<void>;

package/dist/commands/workflow-templates/export.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportWorkflowsToFile = exports.exportWorkflowsByApp = exports.DEFAULT_FILE_LOCATION = void 0;
+exports.exportWorkflows = exports.DEFAULT_FILE_LOCATION = void 0;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
@@ -11,30 +11,22 @@ const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
 const core_1 = require("@oclif/core");
 const file_helpers_1 = require("../../helpers/file-helpers");
 const event_workflow_templates_1 = require("../../api/event-workflow-templates");
-const schedules_1 = require("../../api/schedules");
-const apps_1 = require("../../api/apps");
 const helper_1 = require("../../helpers/workflow-templates/helper");
 const basecommand_1 = require("../../basecommand");
 exports.DEFAULT_FILE_LOCATION = 'workflows.yml';
 class ExportWorkflows extends basecommand_1.BaseCommand {
-    static description = 'Export all workflows in the org. By default exports one file per app to the current directory.';
+    static description = 'Export all workflows in the org.';
     static examples = [
-        '$ contrail workflow-templates export',
-        '$ contrail workflow-templates export --dir ./workflows',
-        '$ contrail workflow-templates export --outFile workflows.yml',
+        `$ contrail workflow-templates export
+`,
     ];
     static flags = {
         ...basecommand_1.BaseCommand.baseFlags,
         outFile: core_1.Flags.string({
             char: 'f',
-            description: 'Export all workflows to a single file at this path (overrides per-app export)',
+            description: 'The location for the file to be saved',
             required: false,
-        }),
-        dir: core_1.Flags.string({
-            char: 'd',
-            description: 'Directory to write per-app workflow files',
-            required: false,
-            default: '.',
+            default: exports.DEFAULT_FILE_LOCATION,
         }),
         overwrite: core_1.Flags.boolean({
             description: 'Replaces existing files if they exist',
@@ -46,12 +38,7 @@ class ExportWorkflows extends basecommand_1.BaseCommand {
         try {
             await (0, login_1.authUser)();
             this.log(`${chalk_1.default.blue.bold('START')} Getting Workflows.`);
-            if (this.flags.outFile) {
-                await exportWorkflowsToFile(this.flags.outFile, this.flags.overwrite);
-            }
-            else {
-                await exportWorkflowsByApp(this.flags.dir ?? '.', this.flags.overwrite);
-            }
+            await exportWorkflows(this.flags.outFile ?? exports.DEFAULT_FILE_LOCATION, this.flags.overwrite);
             this.log(`${chalk_1.default.yellow.bold('WORKFLOWS')} Done`);
         }
         catch (e) {
@@ -62,95 +49,31 @@ class ExportWorkflows extends basecommand_1.BaseCommand {
     }
 }
 exports.default = ExportWorkflows;
-async function exportWorkflowsByApp(outputDir, overwrite) {
+async function exportWorkflows(fileLocation, overwrite) {
     const allWorkflowsInOrg = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
-    const allSchedules = await (0, schedules_1.getExistingSchedules)();
-    const installedApps = await (0, apps_1.getInstalledApps)();
-    const appIdToIdentifier = new Map(installedApps.map((a) => [a.appId, a.app.identifier]));
-    const workflowsByApp = new Map();
-    const unassigned = [];
-    for (const workflow of allWorkflowsInOrg) {
-        let appIdentifier = workflow.supportingAppId
-            ? appIdToIdentifier.get(workflow.supportingAppId)
-            : undefined;
-        // If no supportingAppId, try to extract app identifier from workflow identifier
-        // Format: @{appIdentifier}@{randomId}:{workflowName}
-        if (!appIdentifier && workflow.identifier) {
-            const match = workflow.identifier.match(/^@([^@]+)@/);
-            if (match) {
-                // Keep the @ prefix in the appIdentifier
-                appIdentifier = `@${match[1]}`;
-            }
-        }
-        if (appIdentifier) {
-            if (!workflowsByApp.has(appIdentifier)) {
-                workflowsByApp.set(appIdentifier, []);
-            }
-            const workflows = workflowsByApp.get(appIdentifier);
-            if (workflows) {
-                workflows.push(workflow);
-            }
-        }
-        else {
-            unassigned.push(workflow);
-        }
-    }
-    const resolvedDir = path.resolve(process.cwd(), outputDir);
-    for (const [appIdentifier, workflows] of workflowsByApp.entries()) {
-        const exportObj = { appIdentifier, workflows: [] };
-        for (const workflow of workflows) {
-            exportObj.workflows.push(await buildExportWorkflow(workflow, allSchedules));
-        }
-        const safeAppIdentifier = appIdentifier.replace(/[\\/]/g, '-');
-        const filePath = path.join(resolvedDir, `workflows-${safeAppIdentifier}.yml`);
-        await writeYamlFile(exportObj, filePath, overwrite);
-        console.log(`${chalk_1.default.green('EXPORTED')} ${filePath}`);
-    }
-    if (unassigned.length > 0) {
-        const unassignedObj = { workflows: [] };
-        for (const workflow of unassigned) {
-            unassignedObj.workflows.push(await buildExportWorkflow(workflow, allSchedules));
-        }
-        const unassignedFilePath = path.join(resolvedDir, 'workflows-unassigned.yml');
-        await writeYamlFile(unassignedObj, unassignedFilePath, overwrite);
-        console.log(`${chalk_1.default.yellow('EXPORTED')} ${unassignedFilePath} (unassigned workflows)`);
-    }
-}
-exports.exportWorkflowsByApp = exportWorkflowsByApp;
-async function exportWorkflowsToFile(fileLocation, overwrite) {
-    const allWorkflowsInOrg = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
-    const allSchedules = await (0, schedules_1.getExistingSchedules)();
     const workflowsObj = { workflows: [] };
     for (const workflow of allWorkflowsInOrg) {
-        workflowsObj.workflows.push(await buildExportWorkflow(workflow, allSchedules));
-    }
-    const pathToWrite = path.resolve(process.cwd(), fileLocation);
-    await writeYamlFile(workflowsObj, pathToWrite, overwrite);
-}
-exports.exportWorkflowsToFile = exportWorkflowsToFile;
-async function buildExportWorkflow(workflow, allSchedules) {
-    const exportWorkflow = lodash_1.default.pick(workflow, [
-        'identifier',
-        'name',
-        'triggerKey',
-        'isActive',
-        'messageGroup',
-        'dynamicMessageGroupId',
-        'parallelWorkerCount',
-        'workflowDefinition',
-    ]);
-    const schedules = allSchedules.filter((s) => s.ownerReference === `event-workflow-template:${workflow.id}`);
-    if (schedules.length > 0) {
-        exportWorkflow.crons = schedules.map((s) => ({ name: s.name, cron: s.cron }));
+        const exportWorkflow = lodash_1.default.pick(workflow, [
+            'triggerKey',
+            'workflowDefinition',
+            'name',
+            'isActive',
+            'identifier',
+            'messageGroup',
+            'dynamicMessageGroupId',
+        ]);
+        await (0, helper_1.populateActionIdentifiers)(exportWorkflow);
+        workflowsObj.workflows.push(exportWorkflow);
     }
-    await (0, helper_1.populateActionIdentifiers)(exportWorkflow);
-    (0, helper_1.extractShortActionKeys)(exportWorkflow);
-    return exportWorkflow;
+    await saveData(workflowsObj, fileLocation, overwrite);
 }
-async function writeYamlFile(data, absolutePath, overwrite) {
-    if (fs_1.default.existsSync(absolutePath)) {
-        await (0, file_helpers_1.safeFileOverwrite)(absolutePath, overwrite);
+exports.exportWorkflows = exportWorkflows;
+async function saveData(data, fileLocation, overwrite) {
+    const yamlStr = js_yaml_1.default.dump(data);
+    const CURRENT_DIR = process.cwd();
+    const pathToWrite = path.resolve(path.join(CURRENT_DIR, fileLocation));
+    if (fs_1.default.existsSync(pathToWrite)) {
+        await (0, file_helpers_1.safeFileOverwrite)(pathToWrite, overwrite);
     }
-    fs_1.default.mkdirSync(path.dirname(absolutePath), { recursive: true });
-    fs_1.default.writeFileSync(absolutePath, js_yaml_1.default.dump(data), 'utf8');
+    fs_1.default.writeFileSync(pathToWrite, yamlStr, 'utf8');
 }

package/dist/helpers/projects/helpers.d.ts

@@ -1,3 +1,4 @@
 import { ProjectConfiguration } from '../../interfaces';
+import { ProcessingOptions } from './post-processor';
 export declare function getProjectFile(fileName: any): ProjectConfiguration;
-export declare function exportProject(name: any): Promise<void>;
+export declare function exportProject(name: string, processingOptions?: ProcessingOptions | null): Promise<void>;

package/dist/helpers/projects/helpers.js

@@ -8,6 +8,7 @@ const fs_1 = tslib_1.__importDefault(require("fs"));
 const sdk_1 = require("@contrail/sdk");
 const util_1 = require("@contrail/util");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
+const post_processor_1 = require("./post-processor");
 function getProjectFile(fileName) {
     const CURRENT_DIR = process.cwd();
     try {
@@ -21,7 +22,7 @@ function getProjectFile(fileName) {
     }
 }
 exports.getProjectFile = getProjectFile;
-async function exportProject(name) {
+async function exportProject(name, processingOptions) {
     const allWorkspaces = await new sdk_1.Entities().get({
         entityName: 'workspace',
         useSearch: false,
@@ -42,7 +43,41 @@ async function exportProject(name) {
     const allAssortments = [];
     await getAssortmentsAndSubFolders(workspace.id, projectConfiguration.assortments, projectConfiguration.subFolders, allAssortments);
     await convertRelationshipsInFolders(projectConfiguration, allAssortments);
-    saveData({ projectConfiguration: projectConfiguration }, name);
+    let finalData = { projectConfiguration: projectConfiguration };
+    // Apply post-processing if requested
+    if (processingOptions) {
+        logger_1.default.info('Starting post-processing...');
+        const processor = new post_processor_1.ProjectPostProcessor(processingOptions);
+        const { data, results } = processor.processProjectData(finalData);
+        finalData = data;
+        // Log analysis results
+        if (processingOptions.verbose || processingOptions.analyzeOnly) {
+            logger_1.default.info('========== ANALYSIS RESULTS ==========');
+            logger_1.default.info(`Total objects analyzed: ${results.stats.totalObjects}`);
+            logger_1.default.info(`- Assortments: ${results.stats.totalAssortments}`);
+            logger_1.default.info(`- Plans: ${results.stats.totalPlans}`);
+            logger_1.default.info(`- Backings: ${results.stats.totalBackings}`);
+            logger_1.default.info(`- Folders: ${results.stats.totalFolders}`);
+            logger_1.default.info('\nIDENTIFIER ANALYSIS:');
+            logger_1.default.info(`- Missing identifiers: ${results.stats.missingIdentifiers}`);
+            logger_1.default.info(`- Duplicate identifiers: ${results.stats.duplicateIdentifiers}`);
+            logger_1.default.info(`- Empty identifiers: ${results.stats.emptyIdentifiers}`);
+            if (Object.keys(results.duplicates).length > 0) {
+                logger_1.default.info('\n=== DUPLICATE IDENTIFIERS ===');
+                for (const [id, info] of Object.entries(results.duplicates)) {
+                    logger_1.default.info(`\n"${id}" (${info.count} occurrences):`);
+                    info.names.forEach((nameItem, i) => {
+                        logger_1.default.info(`  ${i + 1}. "${nameItem}"`);
+                    });
+                }
+            }
+        }
+        if (processingOptions.analyzeOnly) {
+            logger_1.default.info('Analysis complete. No file written (analyze-only mode).');
+            return;
+        }
+    }
+    saveData(finalData, name);
 }
 exports.exportProject = exportProject;
 async function getAssortmentsAndSubFolders(parentId, assortments, subFolders, allAssortments) {

package/dist/helpers/projects/post-processor.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Configuration interface for processing options
+ */
+export interface ProcessingOptions {
+    removeBackings: boolean;
+    fixMissingIdentifiers: boolean;
+    cleanProperties: boolean;
+    analyzeOnly: boolean;
+    verbose: boolean;
+}
+/**
+ * Statistics tracking for all operations
+ */
+export interface ProcessingStats {
+    itemTypeConverted: number;
+    nbFXRatesRemoved: number;
+    createdByRemoved: number;
+    updatedByRemoved: number;
+    emptyAssortmentAttsRemoved: number;
+    itemTypeIdRemoved?: number;
+    identifiersCreated: number;
+    planIdentifiers: number;
+    backingIdentifiers: number;
+    folderIdentifiers: number;
+    viewsIdentifiers: number;
+    assortmentIdentifiers: number;
+    backingsRemoved: number;
+    removedBackingNames: string[];
+    totalObjects: number;
+    totalAssortments: number;
+    totalPlans: number;
+    totalBackings: number;
+    totalFolders: number;
+    duplicateIdentifiers: number;
+    emptyIdentifiers: number;
+    missingIdentifiers: number;
+}
+/**
+ * Duplicate identifier information
+ */
+export interface DuplicateInfo {
+    count: number;
+    names: string[];
+    paths: string[];
+}
+/**
+ * Analysis results interface
+ */
+export interface AnalysisResults {
+    stats: ProcessingStats;
+    duplicates: Record<string, DuplicateInfo>;
+    emptyIdentifierObjects: Array<{
+        name: string;
+        path: string;
+    }>;
+    missingIdentifierObjects: {
+        assortments: Array<{
+            name: string;
+            path: string;
+        }>;
+        plans: Array<{
+            name: string;
+            path: string;
+        }>;
+        folders: Array<{
+            name: string;
+            path: string;
+        }>;
+    };
+}
+/**
+ * Main class for processing project YAML data
+ */
+export declare class ProjectPostProcessor {
+    private stats;
+    private options;
+    private projectId;
+    constructor(options?: Partial<ProcessingOptions>);
+    private initializeStats;
+    /**
+     * Main processing method for project data
+     */
+    processProjectData(projectData: any): {
+        data: any;
+        results: AnalysisResults;
+    };
+    /**
+     * Extract project ID from project data
+     */
+    private extractProjectId;
+    /**
+     * Analyze project data for identifiers, types, and structure
+     */
+    private analyzeProjectData;
+    /**
+     * Clean properties from project data
+     */
+    private cleanProperties;
+    /**
+     * Process assortmentAtts object
+     */
+    private processAssortmentAtts;
+    /**
+     * Fix missing identifiers
+     */
+    private fixMissingIdentifiers;
+    /**
+     * Remove backing assortments
+     */
+    private removeBackings;
+    /**
+     * Generate identifier for an object
+     */
+    private generateIdentifier;
+    /**
+     * Determine object type
+     */
+    private getObjectType;
+    /**
+     * Check if object should have an identifier
+     */
+    private shouldHaveIdentifier;
+    /**
+     * Log processing summary
+     */
+    private logProcessingSummary;
+    /**
+     * Get processing statistics
+     */
+    getStats(): ProcessingStats;
+}

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/workflow-templates/helper.d.ts

@@ -18,4 +18,3 @@ export declare class WorkflowTemplateDeployer {
 export declare function deleteWorkflowTemplates(): Promise<void>;
 export declare function localDeployWorkflowTemplate(saveFileLocation: string): Promise<void>;
 export declare function populateActionIdentifiers(workflowTemplate: WorkflowTemplate): Promise<void>;
-export declare function extractShortActionKeys(workflowTemplate: WorkflowTemplate): void;

package/dist/helpers/workflow-templates/helper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractShortActionKeys = exports.populateActionIdentifiers = exports.localDeployWorkflowTemplate = exports.deleteWorkflowTemplates = exports.WorkflowTemplateDeployer = exports.getActionByIdentifier = exports.getWorkflowTemplateIdentifier = exports.LocalWorkflowTemplateDeployer = void 0;
+exports.populateActionIdentifiers = exports.localDeployWorkflowTemplate = exports.deleteWorkflowTemplates = exports.WorkflowTemplateDeployer = exports.getActionByIdentifier = exports.getWorkflowTemplateIdentifier = exports.LocalWorkflowTemplateDeployer = void 0;
 const tslib_1 = require("tslib");
 const util_1 = require("@contrail/util");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
@@ -20,6 +20,7 @@ class LocalWorkflowTemplateDeployer {
         const existingWorkflows = await (0, event_workflow_templates_1.getExistingWorkflowTemplates)();
         // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
         logger_1.default.info(`${chalk_1.default.yellow.bold('WORKFLOW TEMPLATES')} Deploying workflow templates.`);
+        logger_1.default.info(wtDeclaration);
         for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
             await this.deployWorkflowTemplate(wtDeclaration.workflows[workflowKey], existingWorkflows, wtDeclaration.appIdentifier);
         }
@@ -34,7 +35,7 @@ class LocalWorkflowTemplateDeployer {
         return await this.createNewWorkflowTemplate(identifier, workflow, appIdentifier);
     }
     async createNewWorkflowTemplate(workflowKey, workflowTemplate, appIdentifier) {
-        this.populateActionIds(workflowTemplate, workflowKey, appIdentifier);
+        await this.populateActionIds(workflowTemplate, workflowKey, appIdentifier);
         const newObject = {
             identifier: getWorkflowTemplateIdentifier(workflowTemplate),
             name: workflowTemplate.name,
@@ -43,8 +44,6 @@ class LocalWorkflowTemplateDeployer {
             isActive: workflowTemplate.isActive,
             supportingAppId: workflowTemplate.supportingAppId,
             messageGroupId: workflowTemplate.messageGroupId,
-            messageGroup: workflowTemplate.messageGroup,
-            dynamicMessageGroupId: workflowTemplate.dynamicMessageGroupId,
             parallelWorkerCount: workflowTemplate.parallelWorkerCount,
         };
         const newWorkflowTemplate = await (0, event_workflow_templates_1.createWorkflowTemplate)(newObject);
@@ -56,10 +55,8 @@ class LocalWorkflowTemplateDeployer {
     }
     async populateActionIds(workflowTemplate, workflowKey, appIdentifier) {
         const installedApps = await (0, apps_1.getInstalledApps)();
-        const appOrg = installedApps.find((x) => x.app?.identifier === appIdentifier);
-        if (!appOrg) {
-            throw new Error(`Could not find installed app with identifier "${appIdentifier}". Make sure the app is installed in this org before importing workflows.`);
-        }
+        const appOrg = installedApps.find((x) => x.app.identifier === appIdentifier);
+        logger_1.default.info('workflow template:', JSON.stringify(workflowTemplate, null, 2));
         if (!workflowTemplate?.workflowDefinition?.paths) {
             return;
         }
@@ -89,7 +86,7 @@ class LocalWorkflowTemplateDeployer {
         }
     }
     async createWorkflowSchedule(workflowTemplate, workflowId) {
-        if (!workflowTemplate?.crons?.length) {
+        if (!workflowTemplate?.crons?.length || !workflowTemplate.id) {
             return;
         }
         const crons = [];
@@ -286,21 +283,3 @@ async function populateActionIdentifiers(workflowTemplate) {
     }
 }
 exports.populateActionIdentifiers = populateActionIdentifiers;
-function extractShortActionKeys(workflowTemplate) {
-    if (!workflowTemplate?.workflowDefinition?.paths) {
-        return;
-    }
-    for (const wfPath of workflowTemplate.workflowDefinition.paths) {
-        if (!wfPath?.actionDefinitionConfigs) {
-            continue;
-        }
-        for (const actionConfig of wfPath.actionDefinitionConfigs) {
-            if (actionConfig.action?.includes(':')) {
-                // Full identifier format: "app-id@version:action-name" -> "action-name"
-                actionConfig.action = actionConfig.action.split(':').pop();
-            }
-            delete actionConfig.identifier;
-        }
-    }
-}
-exports.extractShortActionKeys = extractShortActionKeys;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.3-alpha.0e9434c",
+  "version": "3.5.3-alpha.317fe63",
   "commands": {
     "app:create": {
       "id": "app:create",
@@ -1241,14 +1241,15 @@
     },
     "projects:export": {
       "id": "projects:export",
-      "description": "Export a project.",
+      "description": "Export a project with optional post-processing.",
       "strict": true,
       "pluginName": "@contrail/cli",
       "pluginAlias": "@contrail/cli",
       "pluginType": "core",
       "aliases": [],
       "examples": [
-        "$ contrail project export <PROJECT_NAME>\n"
+        "$ contrail project export <PROJECT_NAME>",
+        "$ contrail project export <PROJECT_NAME> --process"
       ],
       "flags": {
         "logLevel": {
@@ -1277,12 +1278,18 @@
             "false"
           ],
           "default": "true"
+        },
+        "process": {
+          "name": "process",
+          "type": "boolean",
+          "description": "Enable post-processing of exported project data",
+          "allowNo": false
         }
       },
       "args": {
         "projectName": {
           "name": "projectName",
-          "description": "",
+          "description": "Name or identifier of the project to export",
           "required": true
         }
       }
@@ -2956,16 +2963,14 @@
     },
     "workflow-templates:export": {
       "id": "workflow-templates:export",
-      "description": "Export all workflows in the org. By default exports one file per app to the current directory.",
+      "description": "Export all workflows in the org.",
       "strict": true,
       "pluginName": "@contrail/cli",
       "pluginAlias": "@contrail/cli",
       "pluginType": "core",
       "aliases": [],
       "examples": [
-        "$ contrail workflow-templates export",
-        "$ contrail workflow-templates export --dir ./workflows",
-        "$ contrail workflow-templates export --outFile workflows.yml"
+        "$ contrail workflow-templates export\n"
       ],
       "flags": {
         "logLevel": {
@@ -2999,18 +3004,10 @@
           "name": "outFile",
           "type": "option",
           "char": "f",
-          "description": "Export all workflows to a single file at this path (overrides per-app export)",
-          "required": false,
-          "multiple": false
-        },
-        "dir": {
-          "name": "dir",
-          "type": "option",
-          "char": "d",
-          "description": "Directory to write per-app workflow files",
+          "description": "The location for the file to be saved",
           "required": false,
           "multiple": false,
-          "default": "."
+          "default": "workflows.yml"
         },
         "overwrite": {
           "name": "overwrite",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "3.5.3-alpha.0e9434c",
+  "version": "3.5.3-alpha.317fe63",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",