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

package/dist/commands/types/uploadTypePolicies.js

@@ -8,7 +8,6 @@ const path = tslib_1.__importStar(require("path"));
 const login_1 = require("../../auth/login");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const core_1 = require("@oclif/core");
-const type_extractor_1 = require("../../helpers/types/type-extractor");
 const users_1 = require("../../api/users");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
@@ -37,9 +36,8 @@ async function uploadTypePolicies(dir) {
     try {
         await (0, login_1.authUser)();
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE POLICY')} Uploading`);
-        const [reducedTypePolicies, reducedTypePolicyLinks] = await loadTypePolicies(dir);
+        const reducedTypePolicies = await loadTypePolicies(dir);
         await uploadTypePolicyObjects(reducedTypePolicies);
-        await uploadTypePolicyLinks(reducedTypePolicyLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE POLICY')} Uploaded`);
     }
     catch (e) {
@@ -51,15 +49,13 @@ async function uploadTypePolicies(dir) {
 exports.uploadTypePolicies = uploadTypePolicies;
 function loadTypePolicies(fromDir) {
     const tps = [];
-    let tpLinks = [];
     const dir = path.join(fromDir, 'type-policies');
     try {
         const files = fs_1.default.readdirSync(dir);
         for (const file of files) {
             tps.push(js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
         }
-        tpLinks = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'type-policy-links.yml'), 'utf8'));
-        return [tps, tpLinks];
+        return tps;
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
@@ -152,83 +148,3 @@ async function uploadTypePolicyObjects(reducedTypePolicies) {
         }
     }
 }
-async function uploadTypePolicyLinks(reducedTypePolicyLinks) {
-    const types = await (0, type_extractor_1.getTypes)();
-    const currentTypePolicies = await new sdk_1.Entities().get({
-        entityName: 'type-policy',
-    });
-    const currentTypePolicyLinks = await new sdk_1.Entities().get({
-        entityName: 'type-policy-link',
-    });
-    const currentLinksHashes = {};
-    for (const currentLink of currentTypePolicyLinks) {
-        const foundType = types.find((type) => type.id === currentLink.typeId);
-        const foundTypePolicy = currentTypePolicies.find((tp) => tp.id === currentLink.typePolicyId);
-        if (!foundType || !foundTypePolicy) {
-            logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
-        }
-        const hash = `${foundType.slug}|${foundTypePolicy.identifier}`;
-        currentLinksHashes[hash] = currentLink;
-    }
-    const reducedLinksByHashes = {};
-    for (const loadedLink of reducedTypePolicyLinks) {
-        const hash = `${loadedLink.typeSlug}|${loadedLink.typePolicyIdentifier}`;
-        reducedLinksByHashes[hash] = loadedLink;
-    }
-    for (const loadedTPLink of reducedTypePolicyLinks) {
-        try {
-            const found = currentLinksHashes[`${loadedTPLink.typeSlug}|${loadedTPLink.typePolicyIdentifier}`];
-            if (!found) {
-                if (!transformReducedLink(loadedTPLink, types, currentTypePolicies)) {
-                    continue;
-                }
-                logger_1.default.info(`Creating:  ${loadedTPLink.typeSlug}|${loadedTPLink.typePolicyIdentifier}`);
-                await new sdk_1.Entities().create({
-                    entityName: 'type-policy-link',
-                    object: {
-                        typePolicyId: loadedTPLink.typePolicyId,
-                        typeId: loadedTPLink.typeId,
-                    },
-                });
-            }
-            else {
-                if (!transformReducedLink(loadedTPLink, types, currentTypePolicies)) {
-                    continue;
-                }
-            }
-        }
-        catch (err) {
-            logger_1.default.error(`Error Uploading type policy links: ${err}`);
-        }
-    }
-    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
-        try {
-            const found = reducedLinksByHashes[currentLinkHash];
-            if (!found) {
-                logger_1.default.info(`Deleting:  ${currentLinkHash}`);
-                await new sdk_1.Entities().delete({
-                    entityName: 'type-policy-link',
-                    id: currentLink['id'],
-                });
-            }
-        }
-        catch (err) {
-            logger_1.default.error(`Error Deleting rule set link: ${err}`);
-        }
-    }
-}
-function transformReducedLink(typePolicyLink, types, typePolicies) {
-    const foundType = types.find((type) => type.slug === typePolicyLink.typeSlug);
-    if (!foundType) {
-        logger_1.default.error(`Could not find type with slug ${typePolicyLink.typeSlug}`);
-        return false;
-    }
-    typePolicyLink.typeId = foundType.id;
-    const foundTypePolicy = typePolicies.find((tpp) => tpp.identifier === typePolicyLink.typePolicyIdentifier);
-    if (!foundTypePolicy) {
-        logger_1.default.error(`Could not find type policy with identifier ${typePolicyLink.typePolicyIdentifier}`);
-        return false;
-    }
-    typePolicyLink.typePolicyId = foundTypePolicy.id;
-    return true;
-}

package/dist/commands/types/uploadTypePropertyPolicies.d.ts

@@ -10,4 +10,3 @@ export default class UploadTypePropertyPolicies extends BaseCommand {
     run(): Promise<void>;
 }
 export declare function uploadTypePropertyPolicies(dir: string): Promise<void>;
-export declare function findAllOccurrences(array: any, evaluator: any): any[];

package/dist/commands/types/uploadTypePropertyPolicies.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllOccurrences = exports.uploadTypePropertyPolicies = void 0;
+exports.uploadTypePropertyPolicies = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -8,12 +8,10 @@ const path = tslib_1.__importStar(require("path"));
 const login_1 = require("../../auth/login");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const core_1 = require("@oclif/core");
-const type_extractor_1 = require("../../helpers/types/type-extractor");
 const users_1 = require("../../api/users");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
-const _ = tslib_1.__importStar(require("lodash"));
 class UploadTypePropertyPolicies extends basecommand_1.BaseCommand {
     static description = 'Upload type property policies';
     static examples = [
@@ -38,14 +36,12 @@ async function uploadTypePropertyPolicies(dir) {
     try {
         await (0, login_1.authUser)();
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE PROPERTY POLICY')} Uploading`);
-        const [reducedTypePropertyPolicies, reducedTypePropertyPolicyLinks] = await loadTPPolicies(dir);
+        const reducedTypePropertyPolicies = await loadTPPolicies(dir);
         await uploadTPPolicyObjects(reducedTypePropertyPolicies);
-        await uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE PROPERTY POLICY')} Uploaded`);
     }
     catch (e) {
         logger_1.default.info(`${chalk_1.default.red.bold('FAIL')} Type Property Policy Upload Failed . ${e}`);
-        //TODO make this only print if a debug flag is set
         console.trace(e);
         return;
     }
@@ -54,15 +50,13 @@ async function uploadTypePropertyPolicies(dir) {
 exports.uploadTypePropertyPolicies = uploadTypePropertyPolicies;
 function loadTPPolicies(fromDir) {
     const tpps = [];
-    let tppLinks = [];
     const dir = path.join(fromDir, 'type-property-policies');
     try {
         const files = fs_1.default.readdirSync(dir);
         for (const file of files) {
             tpps.push(js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
         }
-        tppLinks = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'type-property-policy-links.yml'), 'utf8'));
-        return [tpps, tppLinks];
+        return tpps;
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
@@ -155,133 +149,3 @@ async function uploadTPPolicyObjects(reducedTypePropertyPolicies) {
         }
     }
 }
-async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
-    const typesWithProperties = await (0, type_extractor_1.getTypes)();
-    const typeProperties = [];
-    typesWithProperties.forEach((type) => {
-        if (type.typeProperties) {
-            for (const tp of type.typeProperties) {
-                tp.typeId = type.id;
-                tp.typeSlug = type.slug;
-                typeProperties.push(tp);
-            }
-        }
-    });
-    const currentTPPs = await new sdk_1.Entities().get({
-        entityName: 'type-property-policy',
-    });
-    const currentTPPLinks = await new sdk_1.Entities().get({
-        entityName: 'type-property-policy-link',
-    });
-    logger_1.default.info(`found ${currentTPPLinks.length} current type property policy links`);
-    logger_1.default.info(`found ${reducedTypePropertyPolicyLinks.length} type property policy links to load`);
-    const currentLinksHashes = {};
-    for (const currentLink of currentTPPLinks) {
-        const foundTPs = findAllOccurrences(typeProperties, (tp) => tp.id === currentLink.typePropertyId);
-        for (const foundTP of foundTPs) {
-            const foundTPP = currentTPPs.find((tpp) => tpp.id === currentLink.typePropertyPolicyId);
-            if (!foundTP || !foundTPP) {
-                logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
-                continue;
-            }
-            const hash = `${foundTP.typeSlug}|${foundTP.slug}|${foundTPP.identifier}`;
-            currentLinksHashes[hash] = currentLink;
-        }
-    }
-    logger_1.default.debug(`current links hashes: ${JSON.stringify(currentLinksHashes, null, 2)}`);
-    const reducedLinksByHashes = {};
-    for (const loadedLink of reducedTypePropertyPolicyLinks) {
-        const hash = `${loadedLink.typeSlug}|${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyIdentifier}`;
-        reducedLinksByHashes[hash] = loadedLink;
-    }
-    const toCreate = Object.keys(reducedLinksByHashes)
-        .filter((x) => !currentLinksHashes[x])
-        .map((x) => {
-        return {
-            [x]: reducedLinksByHashes[x],
-        };
-    })
-        .reduce((a, b) => Object.assign(a, b), {});
-    const toDelete = _.uniqBy(Object.keys(currentLinksHashes)
-        .filter((x) => !reducedLinksByHashes[x])
-        .map((x) => {
-        return {
-            [x]: currentLinksHashes[x],
-        };
-    }), 'id').reduce((a, b) => Object.assign(a, b), {});
-    logger_1.default.debug(`reduced links hashes: ${JSON.stringify(reducedLinksByHashes, null, 2)}`);
-    logger_1.default.info(`found ${Object.keys(toCreate).length} type property policy links to create`);
-    logger_1.default.info(`found ${Object.keys(toDelete).length} type property policy links to delete`);
-    logger_1.default.debug(`to create: ${JSON.stringify(toCreate, null, 2)}`);
-    logger_1.default.debug(`to delete: ${JSON.stringify(toDelete, null, 2)}`);
-    logger_1.default.debug(`current links hashes to delete: ${JSON.stringify(Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]), null, 2)}`);
-    // fs.writeFileSync('toCreate.json', JSON.stringify(toCreate, null, 2));
-    // fs.writeFileSync('toDelete.json', JSON.stringify(toDelete, null, 2));
-    // fs.writeFileSync('currentLinksHashes.json', JSON.stringify(currentLinksHashes, null, 2));
-    // fs.writeFileSync('reducedLinksByHashes.json', JSON.stringify(reducedLinksByHashes, null, 2));
-    // fs.writeFileSync(
-    //   'current_link_hashes_to_delete.json',
-    //   JSON.stringify(
-    //     Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]),
-    //     null,
-    //     2,
-    //   ),
-    // );
-    // return;
-    for (const [hash, link] of Object.entries(toCreate)) {
-        try {
-            if (!transformReducedLink(link, typeProperties, currentTPPs)) {
-                continue;
-            }
-            logger_1.default.info(`Creating: ${hash}: ${JSON.stringify(link, null, 2)}`);
-            await new sdk_1.Entities().create({
-                entityName: 'type-property-policy-link',
-                object: {
-                    typePropertyPolicyId: link.typePropertyPolicyId,
-                    typePropertyId: link.typePropertyId,
-                },
-            });
-        }
-        catch (err) {
-            logger_1.default.error(`Error Uploading type property policy links: ${err}`);
-        }
-    }
-    for (const [hash, link] of Object.entries(toDelete)) {
-        try {
-            logger_1.default.info(`Deleting: ${hash}`);
-            await new sdk_1.Entities().delete({
-                entityName: 'type-property-policy-link',
-                id: link['id'],
-            });
-        }
-        catch (err) {
-            logger_1.default.error(`Error Deleting type property policy link: ${err}`);
-        }
-    }
-    function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
-        const foundTP = typeProperties.find((tp) => tp.slug === TPPLink.typePropertySlug && tp.typeSlug === TPPLink.typeSlug);
-        if (!foundTP) {
-            logger_1.default.error(`Could not find type property with slug ${TPPLink.typePropertySlug} `);
-            return false;
-        }
-        TPPLink.typePropertyId = foundTP.id;
-        const foundTPP = typePropertyPolicies.find((tpp) => tpp.identifier === TPPLink.typePropertyPolicyIdentifier);
-        if (!foundTPP) {
-            logger_1.default.error(`Could not find type property policy with identifier ${TPPLink.typePropertyPolicyIdentifier} `);
-            return false;
-        }
-        TPPLink.typePropertyPolicyId = foundTPP.id;
-        return true;
-    }
-}
-function findAllOccurrences(array, evaluator) {
-    const found = [];
-    for (let i = 0; i < array.length; i++) {
-        const element = array[i];
-        if (evaluator(element)) {
-            found.push(element);
-        }
-    }
-    return found;
-}
-exports.findAllOccurrences = findAllOccurrences;

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;
+}