@contrail/cli 3.3.0-alpha → 3.3.0

package/dist/commands/entities/create.js

@@ -1,532 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.doesPropertyLevelMatchRole = exports.selectRandomObject = exports.buildObjectReferenceCache = exports.getReferencedObjectPaths = exports.pickRandomValueForProperty = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const unique_names_generator_1 = require("unique-names-generator");
-const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
-const types_1 = require("@contrail/types");
-const types_2 = require("../../api/types");
-const core_1 = require("@oclif/core");
-const types_3 = require("../../api/types");
-const login_1 = require("../../auth/login");
-const basecommand_1 = require("../../basecommand");
-const sdk_1 = require("@contrail/sdk");
-const entities_1 = require("../../helpers/entities");
-const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
-const file_helpers_1 = require("../../helpers/file-helpers");
-let IS_DRY_RUN = false;
-let SHOULD_USE_READABLE_IDS = false;
-let SHOULD_SKIP_HYDRATE_RELATIONSHIPS = false;
-let SHOULD_ONLY_USE_SPECIFIED_PROPERTIES = false;
-const baseValidationMap = {
-    assortmentId: async (_slug, assortmentId) => (0, entities_1.throwIfInvalidAssortmentId)(assortmentId),
-    itemId: async (_slug, itemId) => (0, entities_1.throwIfInvalidItemId)(itemId),
-    projectId: async (_slug, projectId) => (0, entities_1.throwIfInvalidProjectId)(projectId),
-};
-const throwIfInvalidPropertyLevelFn = async (_slug, maybeRoles) => maybeRoles.forEach((maybeRole) => (0, entities_1.throwIfInvalidItemLevel)(maybeRole));
-const throwIfInvalidUserOrgRoleFn = async (_slug, maybeRole) => {
-    if (maybeRole !== 'MEMBER' && maybeRole !== 'ADMIN') {
-        throw new Error(`${maybeRole} is not a valid User Org Role`); // TODO: get these roles from a shared library
-    }
-};
-const SLUG_VALIDATION_BY_ROOT_MAP = {
-    item: { ...baseValidationMap, roles: throwIfInvalidPropertyLevelFn },
-    'project-item': { ...baseValidationMap, roles: throwIfInvalidPropertyLevelFn },
-    'assortment-item': baseValidationMap,
-    'user-org': baseValidationMap,
-    'custom-entity': { ...baseValidationMap, role: throwIfInvalidUserOrgRoleFn },
-};
-const SLUGS_THAT_MUST_BE_SPECIFIED_BY_TYPE_PATH = {
-    item: ['roles'],
-    'project-item': ['projectId'],
-    'assortment-item': ['assortmentId'],
-    'user-org': ['role'],
-};
-const FIND_VALID_VALUE_MAP = {
-    assortment: [
-        {
-            slug: 'name',
-            findValidValuesFn: async (assortments) => new Set(Array.from({ length: assortments.length }, () => generateRandomReadableString())),
-            applyValueToEntityFn: (entity, validValues) => {
-                entity.name = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.name);
-            },
-        },
-    ],
-    'assortment-item': [
-        {
-            slug: 'itemId',
-            findValidValuesFn: async (assortmentItems) => new Set((await (0, entities_1.findItemsNotInAssortment)(assortmentItems[0].assortmentId)).map(({ id }) => id)),
-            applyValueToEntityFn: (entity, validValues) => {
-                entity.itemId = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.itemId);
-            },
-        },
-    ],
-    'project-item': [
-        {
-            slug: 'itemId',
-            findValidValuesFn: async (projectItems) => new Set((await (0, entities_1.findItemsNotInProject)(projectItems[0].projectId)).map(({ id }) => id)),
-            applyValueToEntityFn: (entity, validValues) => {
-                entity.itemId = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.itemId);
-            },
-        },
-    ],
-    item: [
-        {
-            slug: 'familyId',
-            findValidValuesFn: async (_items) => new Set(await (0, entities_1.getItemFamilies)().then((families) => families === undefined ? undefined : families.map(({ id }) => id))),
-            applyValueToEntityFn: (entity, validValues) => {
-                if (entity.roles?.includes('option')) {
-                    entity.familyId = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                    // can reuse familyId for options
-                }
-            },
-        },
-        {
-            slug: 'name',
-            findValidValuesFn: async (items) => new Set(Array.from({ length: items.length }, () => generateRandomReadableString())),
-            applyValueToEntityFn: (entity, validValues) => {
-                entity.name = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.name);
-            },
-        },
-        {
-            slug: 'optionName',
-            findValidValuesFn: async (items) => new Set(Array.from({ length: items.length }, () => generateRandomReadableString())),
-            applyValueToEntityFn: (entity, validValues) => {
-                if (!entity.roles?.includes('option'))
-                    return; // only apply to options
-                entity.optionName = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.optionName);
-            },
-        },
-        {
-            slug: 'optionGroup',
-            findValidValuesFn: async (_items) => new Set(),
-            applyValueToEntityFn: (entity, _validValues) => {
-                if (!entity.roles?.includes('option'))
-                    return; // only apply to options
-                entity.optionGroup = 'color';
-            },
-        },
-    ],
-    workspace: [
-        {
-            slug: 'name',
-            findValidValuesFn: async (items) => new Set(Array.from({ length: items.length }, () => generateRandomReadableString())),
-            applyValueToEntityFn: (entity, validValues) => {
-                entity.name = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
-                validValues.delete(entity.name);
-            },
-        },
-    ],
-};
-class CreateEntity extends basecommand_1.BaseCommand {
-    static description = '(BETA) Create entities';
-    static examples = [
-        'contrail entities create color -n=10 # creates 10 random colors',
-        'contrail entities create color # creates one item',
-        'contrail entities create custom-entities:franchise',
-        'contrail entities create project-item -n=1 -- projectId=abc # creates 10 project items within project ABC',
-        'contrail entities create color -r # creates a random color with a human readable ID',
-        'contrail entities create color -d # simulates the creation of a random color without actually creating it',
-        'contrail entities create custom-entity:franchise -s # creates a random color and the response does not contain hydrating relationships',
-        'contrail entities create color -p -- name=Electric\ Blue green=1 red=2 blue=3 # creates a color with specified properties',
-        'contrail entities create color -o /tmp/colors.json # creates a random color and saves the output to /tmp/colors.json',
-    ];
-    static flags = {
-        ...basecommand_1.BaseCommand.baseFlags,
-        count: core_1.Flags.integer({
-            char: 'n',
-            description: 'Number of random entities to create',
-            required: false,
-        }),
-        dryRun: core_1.Flags.boolean({
-            char: 'd',
-            description: 'If true, does not create the entity but simulates the creation',
-            required: false,
-            default: false,
-        }),
-        input: core_1.Flags.string({
-            char: 'i',
-            description: 'A JSON array of objects where each object is one entity to create. Cannot be used with --count. Unless --precise is specified, any missing values will be populated with random values.',
-            required: false,
-            multiple: false,
-        }),
-        outputFile: core_1.Flags.string({
-            char: 'o',
-            description: 'File to save the output (optional)',
-            required: false,
-            multiple: false,
-        }),
-        preciseProperties: core_1.Flags.boolean({
-            char: 'p',
-            description: 'If true, does not generate random values for properties. All values must be specified.',
-            required: false,
-            default: false,
-        }),
-        readableIds: core_1.Flags.boolean({
-            char: 'r',
-            description: 'If true, uses readable IDs for the created entities',
-            required: false,
-            default: false,
-        }),
-        skipHydrateRelationships: core_1.Flags.boolean({
-            char: 's',
-            description: 'If true, does not hydrate relationships for the created entities',
-            required: false,
-            default: false,
-        }),
-    };
-    static args = {
-        path: core_1.Args.string({
-            description: 'Path of the entity type to create',
-            required: true,
-            multiple: false,
-        }),
-    };
-    static strict = false;
-    async run() {
-        this.log('🚨 This command is in BETA and may change or be removed at any time.');
-        await (0, login_1.authUser)();
-        const { flags, argv, args } = await this.parse(CreateEntity);
-        const { count, dryRun: isDryRun, input: inputFilename, outputFile: outputFilename, preciseProperties: shouldOnlyUseSpecifiedProperties, readableIds: shouldUseReadableIds, skipHydrateRelationships, } = flags;
-        const { path: entityTypePath } = args;
-        // Global flags is a little hacky, but it was easier
-        // and it doesn't see *that* bad because they are only valid
-        // for the lifecycle of the command.
-        IS_DRY_RUN = isDryRun;
-        SHOULD_USE_READABLE_IDS = shouldUseReadableIds;
-        SHOULD_SKIP_HYDRATE_RELATIONSHIPS = skipHydrateRelationships;
-        SHOULD_ONLY_USE_SPECIFIED_PROPERTIES = shouldOnlyUseSpecifiedProperties;
-        const propertySpecificationArgs = argv
-            .slice(1, argv.length)
-            .filter(propertySpecifications_1.isValidPropertySpecification);
-        const propertySpecBySlug = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(propertySpecificationArgs);
-        // Validate args
-        if (!entityTypePath) {
-            this.error('You must specify an entity type path.');
-        }
-        if (inputFilename && count) {
-            throw new Error('You cannot use --input and --count together. Please specify one or the other.');
-        }
-        if (count !== undefined && count <= 0) {
-            this.error('Count must be a positive integer.');
-        }
-        const partialEntities = inputFilename
-            ? (0, file_helpers_1.parseFileAsJsonArray)(inputFilename)
-            : Array.from({ length: count || 1 }).fill({});
-        // Ensure we have the required properties for the entity type
-        if (SLUGS_THAT_MUST_BE_SPECIFIED_BY_TYPE_PATH[entityTypePath]) {
-            const requiredSlugs = SLUGS_THAT_MUST_BE_SPECIFIED_BY_TYPE_PATH[entityTypePath];
-            for (const slug of requiredSlugs) {
-                if (!propertySpecBySlug.has(slug)) {
-                    this.error(`Property '${slug}' must be specified for entity type '${entityTypePath}'.`);
-                }
-            }
-        }
-        try {
-            const entitiesToCreate = await buildEntitiesToCreate(entityTypePath, partialEntities, propertySpecBySlug);
-            const { root: entityName } = (0, types_2.parseTypePath)(entityTypePath);
-            const createdEntities = await createEntities(entityName, entitiesToCreate);
-            if (outputFilename) {
-                fs_1.default.writeFileSync(outputFilename, JSON.stringify(createdEntities, null, 2));
-                this.log(`Output saved to ${outputFilename}`);
-            }
-            else {
-                console.log(`Created ${entityTypePath}(s), Entity: ${JSON.stringify(createdEntities, null, 2)}`);
-            }
-        }
-        catch (error) {
-            this.error(`Failed to create random entities: ${error.message}, ${error.stack}`);
-        }
-    }
-}
-exports.default = CreateEntity;
-async function createEntities(entityName, entities) {
-    const limit = (0, p_limit_1.default)(20);
-    const createdEntities = IS_DRY_RUN
-        ? entities
-        : await Promise.all(entities.map(async (e) => limit(() => createEntity(entityName, e))));
-    if (IS_DRY_RUN) {
-        console.log(`Dry run mode: not creating entities, but simulating creation for ${entityName}`);
-    }
-    return createdEntities;
-}
-async function buildEntitiesToCreate(entityTypePath, entities, propertySpecificationBySlug) {
-    const type = await (0, types_3.getTypeByPath)(entityTypePath);
-    if (!type) {
-        throw new Error(`Type not found for path: ${entityTypePath}`);
-    }
-    const [typesCache, objectReferencesCache] = await Promise.all([
-        (0, types_2.buildLocalTypesCache)([...(0, types_2.getReferencedTypePaths)(type), entityTypePath]),
-        buildLocalObjectReferencesCache(getReferencedObjectPaths(type)),
-    ]);
-    const populatedEntities = entities.map((entity) => ({
-        ...createEntityWithPopulatedValues(type, typesCache, objectReferencesCache, propertySpecificationBySlug),
-        ...entity,
-    }));
-    const limit = (0, p_limit_1.default)(30);
-    await Promise.all(populatedEntities.map(async () => limit(() => throwIfEntityIsInvalid)));
-    // Add system values if needed
-    const { root } = (0, types_2.parseTypePath)(type.typePath);
-    const valueFinderApplierForEntity = FIND_VALID_VALUE_MAP[root] || [];
-    for (const { slug, findValidValuesFn, applyValueToEntityFn } of valueFinderApplierForEntity) {
-        // If the property is already specified, skip it unless it is a role for an option or family
-        if (propertySpecificationBySlug?.has(slug)) {
-            console.log(`Skipping property ${slug} because it is already specified.`);
-            continue;
-        }
-        const values = await findValidValuesFn(populatedEntities);
-        if (values) {
-            populatedEntities.forEach((e) => applyValueToEntityFn(e, values));
-        }
-        else {
-            console.warn(`No valid values found for property ${slug}. Skipping.`);
-        }
-    }
-    return populatedEntities;
-}
-function createEntityWithPopulatedValues(type, typeReferencesCache, objectReferencesCache, propertySpecificationBySlug) {
-    const roles = propertySpecificationBySlug?.get('roles');
-    const entity = SHOULD_ONLY_USE_SPECIFIED_PROPERTIES
-        ? {}
-        : pickRandomPropertyValues(type, objectReferencesCache, typeReferencesCache, roles);
-    // Handle property specifications
-    for (const [propertySlug, specifiedValue] of propertySpecificationBySlug.entries()) {
-        const correspondingProperty = type.typeProperties.find((prop) => getPropertySlug(prop) === propertySlug);
-        if (!specifiedValue) {
-            throw new Error(`Value for property ${propertySlug} is required`);
-        }
-        entity[propertySlug] = castValueToPropertyType(specifiedValue, correspondingProperty?.propertyType || types_1.PropertyType.String);
-    }
-    // Give Readbable IDs if specified
-    if (SHOULD_USE_READABLE_IDS) {
-        entity.specifiedId = generateRandomReadableString();
-    }
-    // Support specifiedId
-    if (propertySpecificationBySlug?.has('specifiedId')) {
-        const specifiedId = propertySpecificationBySlug.get('specifiedId');
-        entity.specifiedId = specifiedId;
-    }
-    // There are some required values for certain entity types
-    const requiredValuesForType = requiredValues(type.typePath, typeReferencesCache);
-    if (requiredValuesForType) {
-        requiredValuesForType.forEach(({ slug, value }) => {
-            entity[slug] = value;
-        });
-    }
-    return entity;
-}
-function pickRandomPropertyValues(type, objectReferencesCache, typeReferencesCache, roles) {
-    const entity = {};
-    // Get values for properties
-    for (const property of type.typeProperties) {
-        // Validate property level
-        if (roles?.length && roles.every((r) => !doesPropertyLevelMatchRole(property.propertyLevel, r)))
-            continue;
-        // Generate random value
-        if (property.propertyType === types_1.PropertyType.ObjectReference) {
-            const cache = objectReferencesCache.get(property.referencedTypePath);
-            if (!cache || cache.size === 0) {
-                throw new Error(`No object references found for referencedTypePath: ${property.referencedTypePath}`);
-            }
-            entity[getPropertySlug(property)] = selectRandomObject(cache).id;
-        }
-        else {
-            entity[getPropertySlug(property)] = pickRandomValueForProperty(property, objectReferencesCache, typeReferencesCache);
-        }
-    }
-    return entity;
-}
-async function throwIfEntityIsInvalid(typeRoot, entity) {
-    const propertySlugs = Object.keys(entity);
-    const validationMap = SLUG_VALIDATION_BY_ROOT_MAP[typeRoot] || {};
-    const promises = propertySlugs
-        .filter((slug) => validationMap[slug])
-        .map((slug) => validationMap[slug](slug, entity[slug]));
-    await Promise.all(promises);
-}
-function pickRandomValueForProperty(property, objectReferencesCache, typeReferencesCache) {
-    const getRandomObjectReference = (referencedTypePath) => {
-        if (!objectReferencesCache.has(referencedTypePath)) {
-            throw new Error(`No object references found for referencedTypePath: ${referencedTypePath}`);
-        }
-        const cache = objectReferencesCache.get(referencedTypePath);
-        if (cache.size === 0) {
-            return null;
-        }
-        const randomIndex = Math.floor(Math.random() * cache.size);
-        const randomObjectReference = Array.from(cache.values())[randomIndex];
-        return randomObjectReference;
-    };
-    switch (property.propertyType) {
-        case types_1.PropertyType.String:
-            return generateRandomReadableString();
-        case types_1.PropertyType.Text:
-            return generateRandomReadableString();
-        case types_1.PropertyType.Boolean:
-            return generateRandomBooleanValue();
-        case types_1.PropertyType.Number:
-            return generateRandomNumber();
-        case types_1.PropertyType.Currency:
-            return generateRandomNumber();
-        case types_1.PropertyType.SingleSelect:
-            if (!property.options)
-                throw new Error(`Option set is required for SingleSelect property ${property.slug}, ${JSON.stringify(property, null, 2)}`);
-            return pickRandomOptions(property.options, 1)[0].value;
-        case types_1.PropertyType.MultiSelect:
-            if (!property.options)
-                throw new Error('Option set is required for MultiSelect property');
-            const randomSelection = pickRandomOptions(property.options, Math.max(2, property.options.length)); // Avoid picking more than the number of options
-            return randomSelection.map((option) => option.value);
-        case types_1.PropertyType.Sequence:
-            return generateRandomNumber();
-        case types_1.PropertyType.Date:
-            return generateRandomDateString();
-        case types_1.PropertyType.Percent:
-            return generateRandomNumber(0, 100);
-        case types_1.PropertyType.ObjectReference:
-            const { referencedTypePath: typeForObjectReference } = property;
-            const randomObjectReference = getRandomObjectReference(typeForObjectReference);
-            if (!randomObjectReference) {
-                throw new Error(`No object references found for referencedTypePath: ${typeForObjectReference}`);
-            }
-            return randomObjectReference.id; // Assuming the object reference has an 'id' field
-        case types_1.PropertyType.TypeReference:
-            const { referencedTypePath } = property;
-            const type = typeReferencesCache.get(referencedTypePath);
-            if (!type) {
-                throw new Error(`Referenced type not found for path: ${referencedTypePath}`);
-            }
-            return type.id;
-        case types_1.PropertyType.Formula:
-            return undefined; // Placeholder for formula properties because they are evaluated on save anyway
-        default:
-            throw new Error(`Cannot handle property type: ${property.propertyType}.\n\n See property: ${JSON.stringify(property, null, 2)}`);
-        // TODO: Handle UserList
-        // TODO: Handle ObjectReferenceList
-    }
-}
-exports.pickRandomValueForProperty = pickRandomValueForProperty;
-function pickRandomOptions(options, count) {
-    const shuffled = options.sort(() => 0.5 - Math.random());
-    return shuffled.slice(0, count);
-}
-function generateRandomBooleanValue() {
-    return Math.random() < 0.5;
-}
-function generateRandomNumber(min, max) {
-    if (min === undefined) {
-        min = 0;
-    }
-    if (max === undefined) {
-        max = 100;
-    }
-    return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-function generateRandomReadableString() {
-    return (0, unique_names_generator_1.uniqueNamesGenerator)({ dictionaries: [unique_names_generator_1.adjectives, unique_names_generator_1.animals, unique_names_generator_1.colors, unique_names_generator_1.starWars], length: 3 });
-}
-function generateRandomDateString() {
-    return new Date().toISOString();
-}
-function castValueToPropertyType(value, propertyType) {
-    switch (propertyType) {
-        case types_1.PropertyType.Boolean:
-            return value.toString().toLowerCase() === 'true';
-        case types_1.PropertyType.Number:
-            const numValue = parseFloat(value.toString());
-            if (isNaN(numValue)) {
-                throw new Error(`Invalid number value: ${value}`);
-            }
-            return numValue;
-        case types_1.PropertyType.Date:
-            return new Date(value.toString()).toISOString();
-        default:
-            return value; // For string and other types, return as is
-    }
-}
-async function createEntity(entityName, entity) {
-    const client = new sdk_1.Entities();
-    const skipHydrateRelationships = SHOULD_SKIP_HYDRATE_RELATIONSHIPS;
-    if (entityName === 'assortment-item')
-        return (0, entities_1.createAssortmentItem)(entity, { skipHydrateRelationships }); // special case
-    const response = await client.create({ entityName, object: entity, skipHydrateRelationships });
-    return response;
-}
-function getReferencedObjectPaths(type) {
-    const properties = type.typeProperties || [];
-    return properties
-        .filter((prop) => prop.propertyType === types_1.PropertyType.ObjectReference)
-        .map(({ referencedTypePath }) => referencedTypePath);
-}
-exports.getReferencedObjectPaths = getReferencedObjectPaths;
-async function buildLocalObjectReferencesCache(paths) {
-    const cache = new Map();
-    const getExampleCustomEntitiesByTypePath = (path) => {
-        const client = new sdk_1.Entities();
-        const entities = client.get({
-            entityName: 'custom-entity',
-            criteria: {
-                typePath: path,
-            },
-        });
-        return entities;
-    };
-    const getExampleEntites = async (path) => {
-        if (path.startsWith('custom-entity')) {
-            return getExampleCustomEntitiesByTypePath(path);
-        }
-        const { root } = (0, types_2.parseTypePath)(path);
-        const client = new sdk_1.Entities();
-        const entities = await client.get({
-            entityName: root,
-        });
-        return entities;
-    };
-    const entitiesByPath = await Promise.all((paths || []).map(async (path) => {
-        const entities = await getExampleEntites(path);
-        return { path, entities };
-    }));
-    entitiesByPath.forEach(({ path, entities }) => {
-        const cacheForPath = buildObjectReferenceCache(entities);
-        cache.set(path, cacheForPath);
-    });
-    return cache;
-}
-function buildObjectReferenceCache(entities) {
-    const cache = new Map();
-    entities.forEach((entity) => {
-        const { id } = entity;
-        if (id && !cache.has(id)) {
-            cache.set(id, entity);
-        }
-    });
-    return cache;
-}
-exports.buildObjectReferenceCache = buildObjectReferenceCache;
-function selectRandomObject(cache) {
-    return Array.from(cache.values())[Math.floor(Math.random() * cache.size)];
-}
-exports.selectRandomObject = selectRandomObject;
-function requiredValues(path, typeCache) {
-    if (path.startsWith('custom-entity')) {
-        return [{ slug: 'typeId', value: typeCache.get(path)?.id || '' }];
-    }
-}
-function getPropertySlug(property) {
-    return property.propertyType === types_1.PropertyType.ObjectReference
-        ? `${property.slug}Id`
-        : property.slug;
-}
-function doesPropertyLevelMatchRole(propertyLevel, role) {
-    const isMatchingLevel = propertyLevel === role;
-    return (isMatchingLevel ||
-        propertyLevel === types_1.PropertyLevel.ALL ||
-        propertyLevel === types_1.PropertyLevel.OVERRIDABLE);
-}
-exports.doesPropertyLevelMatchRole = doesPropertyLevelMatchRole;

package/dist/commands/entities/create.spec.d.ts

@@ -1 +0,0 @@
-export {};