@itwin/ecschema-editing 4.0.0-dev.10 → 4.0.0-dev.100

package/lib/cjs/Editing/ECClasses.js

@@ -1,270 +1,270 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ECClasses = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-const core_bentley_1 = require("@itwin/core-bentley");
-const Rules = require("../Validation/ECRules");
-/**
- * @alpha
- * Acts as a base class for schema class creation. Enables property creation.
- */
-class ECClasses {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    /**
-     * Creates a property on class identified by the given SchemaItemKey. This method restricts the
-     * property type to primitives of type Double, String, DateTime and Integer.
-     * @param classKey The SchemaItemKey of the class.
-     * @param name The name of the new property.
-     * @param type The PrimitiveType assigned to the new property.
-     */
-    async createProperty(classKey, name, type, prefix) {
-        let mutableClass;
-        if (type !== ecschema_metadata_1.PrimitiveType.Double && type !== ecschema_metadata_1.PrimitiveType.String && type !== ecschema_metadata_1.PrimitiveType.DateTime
-            && type !== ecschema_metadata_1.PrimitiveType.Integer)
-            throw new Error("Property creation is restricted to type Double, String, DateTime, and Integer.");
-        if ("" === prefix)
-            throw new Error("The specified property name prefix is invalid");
-        const prefixedName = `${prefix}_${name}`;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.createPrimitiveProperty(prefixedName, type);
-        return { itemKey: classKey, propertyName: prefixedName };
-    }
-    /**
-     * Create a primitive property on class identified by the given SchemaItemKey.
-     * @param classKey The SchemaItemKey of the class.
-     * @param name The name of the new property.
-     * @param type The PrimitiveType assigned to the new property.
-     */
-    async createPrimitiveProperty(classKey, name, type) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.createPrimitiveProperty(name, type);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createPrimitivePropertyFromProps(classKey, name, type, primitiveProps) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const newProperty = await mutableClass.createPrimitiveProperty(name, type);
-        await newProperty.fromJSON(primitiveProps);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createEnumerationProperty(classKey, name, type) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const enumSchemaItemKey = mutableClass.schema.getSchemaItemKey(type.fullName);
-        if (enumSchemaItemKey === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate the enumeration ${type.fullName}.`);
-        await mutableClass.createPrimitiveProperty(name, type);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createEnumerationPropertyFromProps(classKey, name, type, enumProps) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const newProperty = await mutableClass.createPrimitiveProperty(name, type);
-        await newProperty.fromJSON(enumProps);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createPrimitiveArrayProperty(classKey, name, type) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.createPrimitiveArrayProperty(name, type);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createPrimitiveArrayPropertyFromProps(classKey, name, type, primitiveProps) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const newProperty = await mutableClass.createPrimitiveArrayProperty(name, type);
-        await newProperty.fromJSON(primitiveProps);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createStructProperty(classKey, name, type) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.createStructProperty(name, type);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createStructPropertyFromProps(classKey, name, type, structProps) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const newProperty = await mutableClass.createStructProperty(name, type);
-        await newProperty.fromJSON(structProps);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createStructArrayProperty(classKey, name, type) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.createStructArrayProperty(name, type);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async createStructArrayPropertyFromProps(classKey, name, type, structProps) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const newProperty = await mutableClass.createStructArrayProperty(name, type);
-        await newProperty.fromJSON(structProps);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async deleteProperty(classKey, name) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        await mutableClass.deleteProperty(name);
-        return { itemKey: classKey, propertyName: name };
-    }
-    async delete(classKey) {
-        const schema = await this._schemaEditor.getSchema(classKey.schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${classKey.schemaKey.toString(true)} not found in context` };
-        const ecClass = await schema.getItem(classKey.name);
-        if (ecClass === undefined)
-            return {};
-        await schema.deleteClass(ecClass.name);
-        return { itemKey: classKey };
-    }
-    /**
-     * Adds a CustomAttribute instance to the Class identified by the given SchemaItemKey
-     * @param classKey The SchemaItemKey identifying the schema.
-     * @param customAttribute The CustomAttribute instance to add.
-     */
-    async addCustomAttribute(classKey, customAttribute) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        mutableClass.addCustomAttribute(customAttribute);
-        const diagnostics = Rules.validateCustomAttributeInstance(mutableClass, customAttribute);
-        const result = { errorMessage: "" };
-        for await (const diagnostic of diagnostics) {
-            result.errorMessage += `${diagnostic.code}: ${diagnostic.messageText}\r\n`;
-        }
-        if (result.errorMessage) {
-            this.removeCustomAttribute(mutableClass, customAttribute);
-            return result;
-        }
-        return {};
-    }
-    /**
-     * Adds a CustomAttribute instance to the Property identified by the given SchemaItemKey and property name.
-     * @param classKey The SchemaItemKey identifying the class.
-     * @param propertyName The name of the property.
-     * @param customAttribute The CustomAttribute instance to add.
-     */
-    async addCustomAttributeToProperty(classKey, propertyName, customAttribute) {
-        let mutableClass;
-        try {
-            mutableClass = await this.getClass(classKey);
-        }
-        catch (e) {
-            return { errorMessage: e.message };
-        }
-        const property = await mutableClass.getProperty(propertyName);
-        if (!property) {
-            return { errorMessage: `Property with the name ${propertyName} could not be found in the class ${classKey.fullName}.` };
-        }
-        property.addCustomAttribute(customAttribute);
-        const diagnostics = Rules.validateCustomAttributeInstance(property, customAttribute);
-        const result = { errorMessage: "" };
-        for await (const diagnostic of diagnostics) {
-            result.errorMessage += `${diagnostic.code}: ${diagnostic.messageText}\r\n`;
-        }
-        if (result.errorMessage) {
-            this.removeCustomAttribute(property, customAttribute);
-            return result;
-        }
-        return {};
-    }
-    async getClass(classKey) {
-        const schema = await this._schemaEditor.getSchema(classKey.schemaKey);
-        const ecClass = await schema.getItem(classKey.name);
-        if (ecClass === undefined)
-            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Class ${classKey.name} was not found in schema ${classKey.schemaKey.toString(true)}`);
-        switch (ecClass.schemaItemType) {
-            case ecschema_metadata_1.SchemaItemType.EntityClass:
-            case ecschema_metadata_1.SchemaItemType.Mixin:
-            case ecschema_metadata_1.SchemaItemType.StructClass:
-            case ecschema_metadata_1.SchemaItemType.CustomAttributeClass:
-            case ecschema_metadata_1.SchemaItemType.RelationshipClass:
-                break;
-            default:
-                throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Schema item type not supported`);
-        }
-        return ecClass;
-    }
-    removeCustomAttribute(container, customAttribute) {
-        (0, core_bentley_1.assert)(container.customAttributes !== undefined);
-        const map = container.customAttributes;
-        map.delete(customAttribute.className);
-    }
-}
-exports.ECClasses = ECClasses;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECClasses = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const core_bentley_1 = require("@itwin/core-bentley");
+const Rules = require("../Validation/ECRules");
+/**
+ * @alpha
+ * Acts as a base class for schema class creation. Enables property creation.
+ */
+class ECClasses {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    /**
+     * Creates a property on class identified by the given SchemaItemKey. This method restricts the
+     * property type to primitives of type Double, String, DateTime and Integer.
+     * @param classKey The SchemaItemKey of the class.
+     * @param name The name of the new property.
+     * @param type The PrimitiveType assigned to the new property.
+     */
+    async createProperty(classKey, name, type, prefix) {
+        let mutableClass;
+        if (type !== ecschema_metadata_1.PrimitiveType.Double && type !== ecschema_metadata_1.PrimitiveType.String && type !== ecschema_metadata_1.PrimitiveType.DateTime
+            && type !== ecschema_metadata_1.PrimitiveType.Integer)
+            throw new Error("Property creation is restricted to type Double, String, DateTime, and Integer.");
+        if ("" === prefix)
+            throw new Error("The specified property name prefix is invalid");
+        const prefixedName = `${prefix}_${name}`;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.createPrimitiveProperty(prefixedName, type);
+        return { itemKey: classKey, propertyName: prefixedName };
+    }
+    /**
+     * Create a primitive property on class identified by the given SchemaItemKey.
+     * @param classKey The SchemaItemKey of the class.
+     * @param name The name of the new property.
+     * @param type The PrimitiveType assigned to the new property.
+     */
+    async createPrimitiveProperty(classKey, name, type) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.createPrimitiveProperty(name, type);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createPrimitivePropertyFromProps(classKey, name, type, primitiveProps) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const newProperty = await mutableClass.createPrimitiveProperty(name, type);
+        await newProperty.fromJSON(primitiveProps);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createEnumerationProperty(classKey, name, type) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const enumSchemaItemKey = mutableClass.schema.getSchemaItemKey(type.fullName);
+        if (enumSchemaItemKey === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidECJson, `Unable to locate the enumeration ${type.fullName}.`);
+        await mutableClass.createPrimitiveProperty(name, type);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createEnumerationPropertyFromProps(classKey, name, type, enumProps) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const newProperty = await mutableClass.createPrimitiveProperty(name, type);
+        await newProperty.fromJSON(enumProps);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createPrimitiveArrayProperty(classKey, name, type) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.createPrimitiveArrayProperty(name, type);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createPrimitiveArrayPropertyFromProps(classKey, name, type, primitiveProps) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const newProperty = await mutableClass.createPrimitiveArrayProperty(name, type);
+        await newProperty.fromJSON(primitiveProps);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createStructProperty(classKey, name, type) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.createStructProperty(name, type);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createStructPropertyFromProps(classKey, name, type, structProps) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const newProperty = await mutableClass.createStructProperty(name, type);
+        await newProperty.fromJSON(structProps);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createStructArrayProperty(classKey, name, type) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.createStructArrayProperty(name, type);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async createStructArrayPropertyFromProps(classKey, name, type, structProps) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const newProperty = await mutableClass.createStructArrayProperty(name, type);
+        await newProperty.fromJSON(structProps);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async deleteProperty(classKey, name) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        await mutableClass.deleteProperty(name);
+        return { itemKey: classKey, propertyName: name };
+    }
+    async delete(classKey) {
+        const schema = await this._schemaEditor.getSchema(classKey.schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${classKey.schemaKey.toString(true)} not found in context` };
+        const ecClass = await schema.getItem(classKey.name);
+        if (ecClass === undefined)
+            return {};
+        await schema.deleteClass(ecClass.name);
+        return { itemKey: classKey };
+    }
+    /**
+     * Adds a CustomAttribute instance to the Class identified by the given SchemaItemKey
+     * @param classKey The SchemaItemKey identifying the schema.
+     * @param customAttribute The CustomAttribute instance to add.
+     */
+    async addCustomAttribute(classKey, customAttribute) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        mutableClass.addCustomAttribute(customAttribute);
+        const diagnostics = Rules.validateCustomAttributeInstance(mutableClass, customAttribute);
+        const result = { errorMessage: "" };
+        for await (const diagnostic of diagnostics) {
+            result.errorMessage += `${diagnostic.code}: ${diagnostic.messageText}\r\n`;
+        }
+        if (result.errorMessage) {
+            this.removeCustomAttribute(mutableClass, customAttribute);
+            return result;
+        }
+        return {};
+    }
+    /**
+     * Adds a CustomAttribute instance to the Property identified by the given SchemaItemKey and property name.
+     * @param classKey The SchemaItemKey identifying the class.
+     * @param propertyName The name of the property.
+     * @param customAttribute The CustomAttribute instance to add.
+     */
+    async addCustomAttributeToProperty(classKey, propertyName, customAttribute) {
+        let mutableClass;
+        try {
+            mutableClass = await this.getClass(classKey);
+        }
+        catch (e) {
+            return { errorMessage: e.message };
+        }
+        const property = await mutableClass.getProperty(propertyName);
+        if (!property) {
+            return { errorMessage: `Property with the name ${propertyName} could not be found in the class ${classKey.fullName}.` };
+        }
+        property.addCustomAttribute(customAttribute);
+        const diagnostics = Rules.validateCustomAttributeInstance(property, customAttribute);
+        const result = { errorMessage: "" };
+        for await (const diagnostic of diagnostics) {
+            result.errorMessage += `${diagnostic.code}: ${diagnostic.messageText}\r\n`;
+        }
+        if (result.errorMessage) {
+            this.removeCustomAttribute(property, customAttribute);
+            return result;
+        }
+        return {};
+    }
+    async getClass(classKey) {
+        const schema = await this._schemaEditor.getSchema(classKey.schemaKey);
+        const ecClass = await schema.getItem(classKey.name);
+        if (ecClass === undefined)
+            throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.ClassNotFound, `Class ${classKey.name} was not found in schema ${classKey.schemaKey.toString(true)}`);
+        switch (ecClass.schemaItemType) {
+            case ecschema_metadata_1.SchemaItemType.EntityClass:
+            case ecschema_metadata_1.SchemaItemType.Mixin:
+            case ecschema_metadata_1.SchemaItemType.StructClass:
+            case ecschema_metadata_1.SchemaItemType.CustomAttributeClass:
+            case ecschema_metadata_1.SchemaItemType.RelationshipClass:
+                break;
+            default:
+                throw new ecschema_metadata_1.ECObjectsError(ecschema_metadata_1.ECObjectsStatus.InvalidSchemaItemType, `Schema item type not supported`);
+        }
+        return ecClass;
+    }
+    removeCustomAttribute(container, customAttribute) {
+        (0, core_bentley_1.assert)(container.customAttributes !== undefined);
+        const map = container.customAttributes;
+        map.delete(customAttribute.className);
+    }
+}
+exports.ECClasses = ECClasses;
 //# sourceMappingURL=ECClasses.js.map