@contrail/cli 3.4.4-alpha.1 → 3.4.4-alpha.7adb62a

package/node_modules/@contrail/sdk/lib/types/sub-types-helper.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubTypesHelper = void 0;
+const entities_1 = require("../entities");
+const types_client_1 = require("./types.client");
+let CACHE = {};
+class SubTypesHelper {
+    static getSubTypesFromPath(typePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cached = CACHE[typePath];
+            if (cached) {
+                return cached;
+            }
+            const type = yield new types_client_1.Types().getByRootAndPath({ path: typePath });
+            let types = yield new entities_1.Entities().get({
+                entityName: 'type',
+                criteria: { typeRootId: type.typeRootId },
+            });
+            types = types.filter((type) => type.typePath.includes(typePath));
+            CACHE[typePath] = types;
+            return types;
+        });
+    }
+    static getTypeListFromPath(typePath, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const types = yield this.getSubTypesFromPath(typePath);
+            return this.getTypeListFromTypes(types, options);
+        });
+    }
+    static getTypeListFromTypes(types, options) {
+        const pathMap = {};
+        const leafNodes = {};
+        const idMap = {};
+        let list = [];
+        for (let type of types) {
+            pathMap[type.typePath] = type;
+            leafNodes[type.typePath] = type;
+            idMap[type.id] = type;
+        }
+        const shouldRemoveTypesWithChildren = !options || !options.includeParentTypes;
+        if (shouldRemoveTypesWithChildren) {
+            for (const type of types) {
+                const parentPath = type.typePath.substring(0, type.typePath.lastIndexOf(':'));
+                if (pathMap[parentPath]) {
+                    delete leafNodes[parentPath];
+                }
+            }
+        }
+        function addLabel(path, array) {
+            let typeForLevel = pathMap[path];
+            if (typeForLevel) {
+                array.push(typeForLevel.label);
+            }
+        }
+        const leafNodeList = Object.values(leafNodes);
+        for (let type of leafNodeList) {
+            let labelArray = [];
+            let path = type.typePath;
+            while (path.indexOf(':') > 0) {
+                addLabel(path, labelArray);
+                path = path.substring(0, path.lastIndexOf(':'));
+            }
+            addLabel(path, labelArray);
+            let labelPath;
+            if (labelArray.length > 1) {
+                labelPath = labelArray.reverse().join('\\');
+            }
+            else if (labelArray.length === 1) {
+                labelPath = labelArray[0];
+            }
+            const entry = {
+                label: type.label,
+                typePath: type.typePath,
+                id: type.id,
+                parentId: type.parentid,
+                pathLabel: labelPath,
+            };
+            list.push(entry);
+        }
+        list = list.sort((o1, o2) => (o1.typePath > o2.typePath ? 1 : -1));
+        return list;
+    }
+    static clearCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            CACHE = {};
+        });
+    }
+}
+exports.SubTypesHelper = SubTypesHelper;

package/node_modules/@contrail/sdk/lib/types/types-cache.d.ts

@@ -0,0 +1,19 @@
+import { InvocationContext } from '../config';
+import { Type } from '@contrail/types';
+interface GetPropertyParams {
+    typeId: string;
+    propertySlug: string;
+}
+export declare class TypesCache {
+    constructor();
+    getType(typeIdentifier: string, ctx?: InvocationContext): Promise<Type>;
+    setType(typeIdentifier: any, type: Type, ctx?: InvocationContext): Promise<null>;
+    setTypePropertyMap(type: Type): void;
+    getProperty(params: GetPropertyParams): any;
+    clearLocal(): void;
+    private getOrgSlug;
+    private getLocalCacheKey;
+    private get;
+    private set;
+}
+export {};

package/node_modules/@contrail/sdk/lib/types/types-cache.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesCache = void 0;
+const config_1 = require("../config");
+let LOCAL_CACHE = {};
+class TypesCache {
+    constructor() { }
+    getType(typeIdentifier, ctx) {
+        return this.get(typeIdentifier, ctx);
+    }
+    setType(typeIdentifier, type, ctx) {
+        this.setTypePropertyMap(type);
+        return this.set(typeIdentifier, type, ctx);
+    }
+    setTypePropertyMap(type) {
+        if (!type) {
+            return;
+        }
+        for (const prop of type.typeProperties) {
+            LOCAL_CACHE[this.getLocalCacheKey(type.id) + '_' + prop.slug] = prop;
+        }
+    }
+    getProperty(params) {
+        if (!params.typeId || !params.propertySlug) {
+            return;
+        }
+        return LOCAL_CACHE[this.getLocalCacheKey(params.typeId) + '_' + params.propertySlug];
+    }
+    clearLocal() {
+        LOCAL_CACHE = {};
+    }
+    getOrgSlug(ctx) {
+        const config = (0, config_1.getConfig)();
+        return (ctx === null || ctx === void 0 ? void 0 : ctx.orgSlug) || config.orgSlug;
+    }
+    getLocalCacheKey(typeIdentifier, ctx) {
+        const orgSlug = this.getOrgSlug(ctx);
+        const typeKey = `org:${orgSlug}|${typeIdentifier}`;
+        return typeKey;
+    }
+    get(typeIdentifier, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let type;
+            const typeKey = this.getLocalCacheKey(typeIdentifier, ctx);
+            type = LOCAL_CACHE[typeKey];
+            return type;
+        });
+    }
+    set(typeIdentifier, type, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeIdentifier) {
+                LOCAL_CACHE[this.getLocalCacheKey(typeIdentifier, ctx)] = type;
+            }
+            if (type) {
+                const typeId = type.id;
+                const typePath = type.typePath;
+                LOCAL_CACHE[this.getLocalCacheKey(typeId, ctx)] = type;
+                LOCAL_CACHE[this.getLocalCacheKey(typePath, ctx)] = type;
+            }
+            return;
+        });
+    }
+}
+exports.TypesCache = TypesCache;

package/node_modules/@contrail/sdk/lib/types/types.client.d.ts

@@ -0,0 +1,42 @@
+import { Type, TypeProperty } from '@contrail/types';
+import { InvocationContext } from '../config';
+export declare const PATH_REQUIRED_FULL_PATH_ERROR = "Search type by path requires both root and path (e.g. path: \"color:color\")";
+export interface TypeClientOptions {
+    root?: string;
+    path?: string;
+    id?: string;
+    relations?: Array<string>;
+    criteria?: {
+        [key: string]: any;
+    };
+    includeArchivedTypeProperties?: boolean;
+    ignoreTypePolicies?: boolean;
+}
+export declare class Types {
+    private ctx;
+    constructor(ctx?: InvocationContext);
+    static clearTypeCache(): void;
+    getByRootAndPath(options: TypeClientOptions): Promise<Type>;
+    getType(options: TypeClientOptions): Promise<Type>;
+    getAllReferencePropertiesByRootSlug(options: TypeClientOptions): Promise<any[]>;
+    private requestReferenceProperties;
+    private requestType;
+    getProperty(typeId: any, propertySlug: any): Promise<TypeProperty>;
+}
+export interface AccessManagedType extends Type {
+    canRead?: boolean;
+    canCreate?: boolean;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    restrictedTypePropertySlugs?: Array<string>;
+}
+export declare function populateTypePolicies(ctx: InvocationContext, type: Type): void;
+export interface AccessManagedTypeProperty extends TypeProperty {
+    canRead?: boolean;
+    canCreate?: boolean;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    policiesSet?: Array<any>;
+    typePropertyPolicyIds?: Array<any>;
+}
+export declare function populatePropertyPolicies(ctx: InvocationContext, type: Type): void;

package/node_modules/@contrail/sdk/lib/types/types.client.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populatePropertyPolicies = exports.populateTypePolicies = exports.Types = exports.PATH_REQUIRED_FULL_PATH_ERROR = void 0;
+const request_1 = require("../core/request");
+const types_1 = require("@contrail/types");
+const types_cache_1 = require("./types-cache");
+const policies_1 = require("@contrail/policies");
+const policies_client_1 = require("../policies/policies.client");
+const config_1 = require("../config");
+const IS_JEST = (_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.JEST_WORKER_ID;
+exports.PATH_REQUIRED_FULL_PATH_ERROR = 'Search type by path requires both root and path (e.g. path: "color:color")';
+const CACHE = new types_cache_1.TypesCache();
+const PROMISE_MAP = {};
+class Types {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    static clearTypeCache() {
+        CACHE.clearLocal();
+    }
+    getByRootAndPath(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getType(options);
+        });
+    }
+    getType(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let resource = '';
+            if (!options.relations) {
+                options.relations = ['typeProperties', 'typeInterfaces'];
+            }
+            if (!options.relations.includes('typeProperties')) {
+                options.relations.push('typeProperties');
+            }
+            if (!options.relations.includes('typeInterfaces')) {
+                options.relations.push('typeInterfaces');
+            }
+            let typeKey;
+            if (options.id) {
+                resource = `/types/${options.id}`;
+            }
+            else if (options.root && !options.path) {
+                resource = `/types/roots/${options.root}/path/${options.root}`;
+            }
+            else if (options.path) {
+                let root;
+                const path = options.path;
+                if (path.includes(':')) {
+                    const parts = options.path.split(':');
+                    root = parts[0];
+                }
+                else {
+                    root = path;
+                }
+                resource = `/types/roots/${root}/path/${path}`;
+            }
+            else {
+                throw Error(`You must specify either an id, or path for a type.`);
+            }
+            resource += '?cacheMode=USE&';
+            if (options.relations) {
+                resource += `relations=${options.relations.join(',')}&`;
+            }
+            if (options.includeArchivedTypeProperties) {
+                resource += `includeArchivedTypeProperties=true&`;
+            }
+            if (options.ignoreTypePolicies) {
+                resource += `ignoreTypePolicies=true&`;
+            }
+            typeKey = resource;
+            let type;
+            if (!IS_JEST) {
+                type = yield CACHE.getType(typeKey, this.ctx);
+            }
+            if (type) {
+                return Promise.resolve(type);
+            }
+            const existingPromise = PROMISE_MAP[typeKey];
+            if (existingPromise) {
+                return existingPromise;
+            }
+            const promise = this.requestType(resource, typeKey, { ignoreTypePolicies: Boolean(options.ignoreTypePolicies) });
+            PROMISE_MAP[typeKey] = promise;
+            return yield promise;
+        });
+    }
+    getAllReferencePropertiesByRootSlug(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let resource = '';
+            let referencePropertiesKey;
+            if (options.root) {
+                resource = `/types/roots/${options.root}/referenceProperties`;
+            }
+            else {
+                throw Error(`You must specify a root for a type.`);
+            }
+            resource += '?cacheMode=USE&';
+            referencePropertiesKey = resource;
+            let referenceProperties;
+            if (!IS_JEST) {
+                referenceProperties = yield CACHE.getType(referencePropertiesKey, this.ctx);
+            }
+            if (referenceProperties) {
+                return Promise.resolve(referenceProperties);
+            }
+            const existingPromise = PROMISE_MAP[referencePropertiesKey];
+            if (existingPromise) {
+                return existingPromise;
+            }
+            const promise = this.requestReferenceProperties(resource, referencePropertiesKey);
+            PROMISE_MAP[referencePropertiesKey] = promise;
+            return promise;
+        });
+    }
+    requestReferenceProperties(resource, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objectReferences = yield request_1.Request.request(resource, { method: 'GET' }, this.ctx);
+            delete PROMISE_MAP[key];
+            return objectReferences;
+        });
+    }
+    requestType(resource, typeKey, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = (yield request_1.Request.request(resource, { method: 'GET' }, this.ctx));
+            const shouldApplyPolicies = Boolean(!(options === null || options === void 0 ? void 0 : options.ignoreTypePolicies));
+            if (shouldApplyPolicies) {
+                populatePropertyPolicies(this.ctx, type);
+                populateTypePolicies(this.ctx, type);
+            }
+            CACHE.setType(resource, type, this.ctx);
+            delete PROMISE_MAP[typeKey];
+            return type;
+        });
+    }
+    getProperty(typeId, propertySlug) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = yield this.getType({ id: typeId });
+            return CACHE.getProperty({ typeId, propertySlug });
+        });
+    }
+}
+exports.Types = Types;
+function populateTypePolicies(ctx, type) {
+    var _a;
+    const accessControlledType = type;
+    const userCtx = ctx || (0, config_1.getGlobalContext)();
+    const policies = (_a = type.typePolicies) === null || _a === void 0 ? void 0 : _a.map((tp) => tp.policy);
+    if (policies === null || policies === void 0 ? void 0 : policies.length) {
+        const allowed = (0, policies_1.getPermissionsOnResource)((0, policies_client_1.getPrincipalReferences)(userCtx), policies, '*');
+        accessControlledType.canRead = allowed.includes(policies_1.Operation.read);
+        accessControlledType.canUpdate = allowed.includes(policies_1.Operation.update);
+        accessControlledType.canDelete = allowed.includes(policies_1.Operation.delete);
+        accessControlledType.canCreate = allowed.includes(policies_1.Operation.create);
+    }
+    else {
+        accessControlledType.canRead = true;
+        accessControlledType.canUpdate = true;
+        accessControlledType.canDelete = true;
+        accessControlledType.canCreate = true;
+    }
+}
+exports.populateTypePolicies = populateTypePolicies;
+function populatePropertyPolicies(ctx, type) {
+    var _a;
+    const typeProperties = type.typeProperties;
+    const policies = type.typePropertyPolicies;
+    const userCtx = ctx || (0, config_1.getGlobalContext)();
+    if (!(policies === null || policies === void 0 ? void 0 : policies.length)) {
+        return;
+    }
+    const validTypeProperties = [];
+    const restrictedTypePropertySlugs = [];
+    for (const property of typeProperties) {
+        if (property.policiesSet) {
+            return;
+        }
+        if (((_a = property === null || property === void 0 ? void 0 : property.typePropertyPolicyIds) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            const thisPropertyPolicies = policies
+                .filter((x) => property.typePropertyPolicyIds.includes(x.id))
+                .map((x) => x.policy);
+            const allowed = (0, policies_1.getPermissionsOnResource)((0, policies_client_1.getPrincipalReferences)(userCtx), thisPropertyPolicies, '*');
+            property.canRead = allowed.includes(policies_1.Operation.read);
+            property.canUpdate = allowed.includes(policies_1.Operation.update);
+            property.canDelete = allowed.includes(policies_1.Operation.delete);
+            property.canCreate = allowed.includes(policies_1.Operation.create);
+        }
+        else {
+            property.canRead = true;
+            property.canUpdate = true;
+            property.canDelete = true;
+            property.canCreate = true;
+        }
+        if (property.canRead !== false) {
+            validTypeProperties.push(property);
+        }
+        else {
+            restrictedTypePropertySlugs.push(property.slug);
+            if ((0, types_1.isReferencePropertyType)(property.propertyType)) {
+                restrictedTypePropertySlugs.push(`${property.slug}Id`);
+            }
+        }
+    }
+    const accessControlledType = type;
+    accessControlledType.typeProperties = validTypeProperties;
+    accessControlledType.restrictedTypePropertySlugs = restrictedTypePropertySlugs;
+}
+exports.populatePropertyPolicies = populatePropertyPolicies;

package/node_modules/@contrail/sdk/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@contrail/sdk",
+  "version": "1.5.5",
+  "description": "Client library for interfacing with contrail services.",
+  "homepage": "https://archergreysorg.github.io/contrail-lib/",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\" \"src/**/*.json\" \"src/**/*.yml\"",
+    "lint": "tslint -p tsconfig.json",
+    "generate-docs": "npx typedoc src/index.ts --disableSources --excludeInternal  --plugin typedoc-plugin-extras --favicon home-hero.svg",
+    "test": "jest",
+    "prepare": "husky install",
+    "lint-staged:check": "lint-staged --config .lintstagedrc-check.json",
+    "lint-staged:format": "lint-staged --allow-empty --config .lintstagedrc-format.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@contrail/entity-types": "^1.1.50-2",
+    "@contrail/policies": "^2.0.5",
+    "@contrail/types": "^3.0.84",
+    "@contrail/util": "^1.0.19",
+    "amazon-cognito-identity-js": "^5.2.8",
+    "es6-promisify": "^6.1.1",
+    "form-data": "^4.0.0",
+    "jsurl": "^0.1.5",
+    "node-fetch": "^2.6.0",
+    "p-limit": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.2",
+    "@types/node": "^14.10.1",
+    "jest": "^29.5.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.1",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typedoc": "^0.25.7",
+    "typedoc-plugin-extras": "^3.0.0",
+    "typescript": "^4.0.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.5"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/node_modules/@contrail/types/README.md

@@ -0,0 +1 @@
+Module used for different utilities like property formatter

package/node_modules/@contrail/types/lib/copy/copy-helper.d.ts

@@ -0,0 +1,16 @@
+import { Type } from '../types';
+export declare enum CopyMethodTypes {
+    QUICK_COPY = "Quick Copy",
+    EXTENSION_COPY = "Extension Copy"
+}
+export declare class CopyHelper {
+    static buildCopiesOfEntities(entitiesToCopy: Array<any>, typeMap: {
+        [typeId: string]: Type;
+    }, propertySlugsToIgnore?: string[]): Array<any>;
+    static buildCopyOfEntity(entityToCopy: any, typeMap: {
+        [typeId: string]: Type;
+    }, propertySlugsToIgnore?: string[]): any;
+    private static assignCopyMetadata;
+    private static getTypePropertySlug;
+    private static getCastDefaultValue;
+}

package/node_modules/@contrail/types/lib/copy/copy-helper.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyHelper = exports.CopyMethodTypes = void 0;
+const type_properties_1 = require("../type-properties");
+const formatter_1 = require("../formatter");
+var CopyMethodTypes;
+(function (CopyMethodTypes) {
+    CopyMethodTypes["QUICK_COPY"] = "Quick Copy";
+    CopyMethodTypes["EXTENSION_COPY"] = "Extension Copy";
+})(CopyMethodTypes = exports.CopyMethodTypes || (exports.CopyMethodTypes = {}));
+class CopyHelper {
+    static buildCopiesOfEntities(entitiesToCopy, typeMap, propertySlugsToIgnore = []) {
+        const entityCopies = entitiesToCopy.map((entity) => this.buildCopyOfEntity(entity, typeMap, propertySlugsToIgnore));
+        return entityCopies.filter((entity) => !!entity);
+    }
+    static buildCopyOfEntity(entityToCopy, typeMap, propertySlugsToIgnore = []) {
+        if (!entityToCopy) {
+            console.warn('Input entity does not have a type.');
+            return;
+        }
+        const entityType = typeMap[entityToCopy?.typeId];
+        if (!entityType || !entityType.typeProperties || !entityType.typePath) {
+            console.warn('Entity type not found or has no properties.');
+            return;
+        }
+        const rootType = entityType.typePath.split(':')[0];
+        const isLeveledEntity = ['item', 'project-item'].includes(rootType);
+        const isFamilyEntity = entityToCopy.roles?.includes('family');
+        const isOptionEntity = entityToCopy.roles?.includes('option');
+        const typeLevel = isFamilyEntity ? 'family' : isOptionEntity ? 'option' : null;
+        if (isLeveledEntity && !typeLevel) {
+            console.warn('Leveled entity does not have assigned role of "family" or "option".');
+            return;
+        }
+        const validCopyPropertyTypes = [
+            type_properties_1.PropertyType.Text,
+            type_properties_1.PropertyType.String,
+            type_properties_1.PropertyType.Number,
+            type_properties_1.PropertyType.Currency,
+            type_properties_1.PropertyType.Percent,
+            type_properties_1.PropertyType.Date,
+            type_properties_1.PropertyType.Boolean,
+            type_properties_1.PropertyType.MultiSelect,
+            type_properties_1.PropertyType.SingleSelect,
+            type_properties_1.PropertyType.ObjectReference,
+            type_properties_1.PropertyType.TypeReference,
+            type_properties_1.PropertyType.UserList,
+            type_properties_1.PropertyType.SizeRange,
+        ];
+        const propertiesToCopy = entityType.typeProperties.filter((property) => {
+            const isConfiguredToCopy = property.copyBehavior === type_properties_1.CopyBehavior.Copy || !property.copyBehavior;
+            const doesPropertyLevelMatch = !isLeveledEntity ||
+                (property.propertyLevel && [typeLevel, 'overridable', 'all'].includes(property.propertyLevel));
+            const isPropertyTypeCopyable = property.propertyType && validCopyPropertyTypes.includes(property.propertyType);
+            return Boolean(isConfiguredToCopy && doesPropertyLevelMatch && isPropertyTypeCopyable && !property.isUniqueProperty);
+        });
+        const propertiesToDefault = entityType.typeProperties.filter((property) => {
+            const isConfiguredToDefault = property.copyBehavior === type_properties_1.CopyBehavior.Default;
+            const doesPropertyLevelMatch = !isLeveledEntity ||
+                (property.propertyLevel && [typeLevel, 'overridable', 'all'].includes(property.propertyLevel));
+            const isPropertyTypeCopyable = property.propertyType && validCopyPropertyTypes.includes(property.propertyType);
+            return Boolean(isConfiguredToDefault && doesPropertyLevelMatch && isPropertyTypeCopyable && !property.isUniqueProperty);
+        });
+        const defaultPropertiesToIgnore = isLeveledEntity ? ['id', 'roles', 'specifiedId'] : ['id', 'specifiedId'];
+        const propertiesToIgnore = [...new Set(...propertySlugsToIgnore, ...defaultPropertiesToIgnore)];
+        const copy = {};
+        propertiesToCopy.forEach((property) => {
+            if (!propertiesToIgnore.includes(property.slug)) {
+                copy[this.getTypePropertySlug(property)] = entityToCopy[this.getTypePropertySlug(property)];
+            }
+        });
+        propertiesToDefault.forEach((property) => {
+            if (!propertiesToIgnore.includes(property.slug)) {
+                copy[this.getTypePropertySlug(property)] = this.getCastDefaultValue(property);
+            }
+        });
+        this.assignCopyMetadata(copy, entityToCopy);
+        return copy;
+    }
+    static assignCopyMetadata(copyOfEntity, entityToCopy) {
+        copyOfEntity.createdFromId = entityToCopy.id;
+        copyOfEntity.createMethod = CopyMethodTypes.QUICK_COPY;
+        copyOfEntity.typeId = entityToCopy.typeId;
+        if (entityToCopy.roles) {
+            copyOfEntity.roles = entityToCopy.roles;
+        }
+        if (entityToCopy.workspaceId) {
+            copyOfEntity.workspaceId = entityToCopy.workspaceId;
+        }
+    }
+    static getTypePropertySlug(typeProperty) {
+        const isReferenceProperty = Boolean(typeProperty.propertyType &&
+            [type_properties_1.PropertyType.ObjectReference, type_properties_1.PropertyType.TypeReference, type_properties_1.PropertyType.UserList].includes(typeProperty.propertyType));
+        return isReferenceProperty ? typeProperty.slug + 'Id' : typeProperty.slug;
+    }
+    static getCastDefaultValue(typeProperty) {
+        if (typeProperty.propertyType === type_properties_1.PropertyType.Boolean) {
+            return new formatter_1.PropertyValueFormatter().parseBooleanValue(typeProperty.copyDefault);
+        }
+        return typeProperty.copyDefault;
+    }
+}
+exports.CopyHelper = CopyHelper;

package/node_modules/@contrail/types/lib/copy/index.d.ts

@@ -0,0 +1 @@
+export * from './copy-helper';

package/node_modules/@contrail/types/lib/copy/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./copy-helper"), exports);

package/node_modules/@contrail/types/lib/formatter/formatDate.d.ts

@@ -0,0 +1,3 @@
+import { DateFormatingOptions } from '../type-properties';
+export declare const formatDate: (date: any, dateFormatOptions?: DateFormatingOptions) => string;
+export declare const formatDateTime: (date: any, dateFormatOptions?: DateFormatingOptions) => string;