@contrail/cli 3.3.3 → 3.5.0-alpha

package/dist/commands/entities/create.js

@@ -0,0 +1,555 @@
+"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;
+let NUM_ENTITIES_TO_CREATE = 1; // Default to creating one entity if not specified
+const getNumEntitiesToCreate = () => NUM_ENTITIES_TO_CREATE; // method to get the latest number in case this changes later
+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) => {
+                if (entity.name)
+                    return; // skip if already specified
+                entity.name = Array.from(validValues)[Math.floor(Math.random() * validValues.size)];
+                validValues.delete(entity.name);
+            },
+        },
+    ],
+    'assortment-item': [
+        {
+            slug: 'itemId',
+            findValidValuesFn: async (assortmentItems, count) => new Set((await (0, entities_1.findItemsNotInAssortment)(assortmentItems[0].assortmentId, count)).map(({ id }) => id)),
+            applyValueToEntityFn: (entity, validValues) => {
+                if (entity.itemId)
+                    return; // skip if already specified
+                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) => {
+                if (entity.itemId)
+                    return; // skip if already specified
+                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)(getNumEntitiesToCreate()).then((families) => families === undefined ? undefined : families.map(({ id }) => id))),
+            applyValueToEntityFn: (entity, validValues) => {
+                if (entity.familyId)
+                    return; // skip if already specified
+                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) => {
+                if (entity.name)
+                    return; // skip if already specified
+                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.optionName)
+                    return; // skip if already specified
+                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.optionGroup)
+                    return; // skip if already specified
+                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) => {
+                if (entity.name)
+                    return; // skip if already specified
+                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,
+        }),
+        inputFile: core_1.Flags.string({
+            char: 'i',
+            description: 'A file with 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, inputFile: 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({});
+        NUM_ENTITIES_TO_CREATE = partialEntities.length;
+        // 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 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.allSettled(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) {
+    let type = await (0, types_3.getTypeByPath)(entityTypePath);
+    if (!type) {
+        console.warn(`Type not found for path: ${entityTypePath}`);
+        type = {
+            typePath: '',
+            typeProperties: [],
+        }; // Fallback to an empty type; This allows us to create entities that are not type-managed
+    }
+    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, entities.length);
+        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

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