@contrail/cli 2.2.5 → 2.2.7

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/2.2.5 darwin-arm64 node-v18.13.0
+@contrail/cli/2.2.7 darwin-arm64 node-v18.13.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND

package/dist/commands/types/uploadOptionSetHierarchies.js

@@ -178,7 +178,7 @@ async function uploadOSHLinks(reducedOSHLinks) {
         if (!foundType ||
             !foundOSH ||
             foundTPSlugs.length !== currentLink.hierarchyTypePropertyIds.length) {
-            logger_1.default.info(`skipping unhashable, invalid type option set hierarchy link: ${currentLink}`);
+            logger_1.default.info(`skipping unhashable, invalid type option set hierarchy link: ${JSON.stringify(currentLink, null, 2)}`);
         }
         // don't mutate original array
         const sortedFoundTPSlugs = [...foundTPSlugs].sort();

package/dist/commands/types/uploadTypePolicies.js

@@ -165,7 +165,7 @@ async function uploadTypePolicyLinks(reducedTypePolicyLinks) {
         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: ${currentLink}`);
+            logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
         }
         const hash = `${foundType.slug}|${foundTypePolicy.identifier}`;
         currentLinksHashes[hash] = currentLink;
@@ -182,6 +182,7 @@ async function uploadTypePolicyLinks(reducedTypePolicyLinks) {
                 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: {

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

@@ -8,3 +8,4 @@ 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.uploadTypePropertyPolicies = void 0;
+exports.findAllOccurrences = exports.uploadTypePropertyPolicies = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -13,6 +13,7 @@ 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 {
     async run() {
         const { flags } = await this.parse(UploadTypePropertyPolicies);
@@ -172,75 +173,115 @@ async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
     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 foundTypeProperty = typeProperties.find((tp) => tp.id === currentLink.typePropertyId);
-        const foundTPP = currentTPPs.find((tpp) => tpp.id === currentLink.typePropertyPolicyId);
-        if (!foundTypeProperty || !foundTPP) {
-            logger_1.default.info(`skipping unhashable, invalid policy link: ${currentLink}`);
-            continue;
+        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;
         }
-        const hash = `${foundTypeProperty.typeSlug}${foundTypeProperty.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;
     }
-    for (const loadedTPPLink of reducedTypePropertyPolicyLinks) {
+    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 {
-            const found = currentLinksHashes[`${loadedTPPLink.typeSlug}|${loadedTPPLink.typePropertySlug}|${loadedTPPLink.typePropertyPolicyIdentifier}`];
-            if (!found) {
-                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
-                    continue;
-                }
-                await new sdk_1.Entities().create({
-                    entityName: 'type-property-policy-link',
-                    object: {
-                        typePropertyPolicyId: loadedTPPLink.typePropertyPolicyId,
-                        typePropertyId: loadedTPPLink.typePropertyId,
-                    },
-                });
-            }
-            else {
-                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
-                    continue;
-                }
+            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 [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+    for (const [hash, link] of Object.entries(toDelete)) {
         try {
-            const found = reducedLinksByHashes[currentLinkHash];
-            if (!found) {
-                logger_1.default.info(`Deleting:  ${currentLinkHash}`);
-                await new sdk_1.Entities().delete({
-                    entityName: 'type-property-policy-link',
-                    id: currentLink['id'],
-                });
-            }
+            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 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/commands/types/uploadUsageInfo.js

@@ -70,7 +70,7 @@ async function uploadUsageInfoObjects(loadedUsageInfo) {
         const foundType = typesWithProperties.find((t) => t.id === currentUI.typeId);
         const foundTypeProperty = typeProperties.find((tp) => tp.id === currentUI.typePropertyId);
         if (!foundType || !foundTypeProperty) {
-            logger_1.default.info(`skipping unhashable, invalid usage info: ${currentUI}`);
+            logger_1.default.info(`skipping unhashable, invalid usage info: ${JSON.stringify(currentUI, null, 2)}`);
             continue;
         }
         const hash = `${foundType.slug}|${foundTypeProperty.slug}`;

package/dist/helpers/app/app-config-validators.js

@@ -40,7 +40,9 @@ function visibilityValidator(appDeclaration) {
             error: 'Invalid visibility. Visibility must be "public" or "private".',
         };
     }
-    if (appDeclaration.visibility === 'private' && appDeclaration.hidden !== true) {
+    if (appDeclaration.visibility === 'private' &&
+        Object.prototype.hasOwnProperty.call(appDeclaration, 'hidden') &&
+        appDeclaration.hidden === true) {
         return {
             error: 'Apps can not be private and hidden.',
         };

package/dist/helpers/app/app-config-validators.spec.js

@@ -65,3 +65,41 @@ it('should return an error if app version has invalid format', () => {
     const validationResult = (0, app_config_validators_1.appVersionValidator)(appDeclaration);
     expect(validationResult).toEqual(expectedError);
 });
+describe('visibilityValidator', () => {
+    it('should return an error if visibility is neither "public" nor "private"', () => {
+        const appDeclaration = {
+            visibility: 'invalidVisibility',
+        };
+        const expectedError = {
+            error: 'Invalid visibility. Visibility must be "public" or "private".',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toEqual(expectedError);
+    });
+    it('should return an error if app is private and not hidden', () => {
+        const appDeclaration = {
+            visibility: 'private',
+            hidden: true,
+        };
+        const expectedError = {
+            error: 'Apps can not be private and hidden.',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toEqual(expectedError);
+    });
+    it('should not return an error if visibility is "public"', () => {
+        const appDeclaration = {
+            visibility: 'public',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toBeUndefined();
+    });
+    it('should not return an error if app is private and hidden', () => {
+        const appDeclaration = {
+            visibility: 'private',
+            hidden: false,
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toBeUndefined();
+    });
+});

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.2.5",
+  "version": "2.2.7",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",