@itwin/presentation-hierarchies 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/{esm/hierarchies → hierarchies}/imodel/NodeSelectQueryFactory.js

@@ -3,8 +3,8 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import { assert } from "@itwin/core-bentley";
-import { GenericInstanceFilter, GenericInstanceFilterRuleValue, } from "@itwin/core-common";
-import { ECSql, getClass, parseFullClassName, PrimitiveValue, } from "@itwin/presentation-shared";
+import { GenericInstanceFilter, GenericInstanceFilterRuleValue } from "@itwin/core-common";
+import { ECSql, getClass, normalizeFullClassName, parseFullClassName, PrimitiveValue, } from "@itwin/presentation-shared";
 /**
  * Column names of the SELECT clause created by `NodeSelectClauseFactory`. Order of the names matches the order of columns
  * created by the factory.
@@ -13,7 +13,7 @@ import { ECSql, getClass, parseFullClassName, PrimitiveValue, } from "@itwin/pre
  */
 export var NodeSelectClauseColumnNames;
 (function (NodeSelectClauseColumnNames) {
-    /** Full class name of the instance the node represents. Type: `string` in format `{schema name}:{class name}`. */
+    /** Full class name of the instance the node represents. Type: `string` in format `{schema name}.{class name}`. */
     NodeSelectClauseColumnNames["FullClassName"] = "FullClassName";
     /** ECInstance ID of the instance the node represents. Type: `Id64String`. */
     NodeSelectClauseColumnNames["ECInstanceId"] = "ECInstanceId";
@@ -41,7 +41,10 @@ export var NodeSelectClauseColumnNames;
 })(NodeSelectClauseColumnNames || (NodeSelectClauseColumnNames = {}));
 /**
  * Creates an instance of `NodeSelectQueryFactory`.
- * @public
+ *
+ * The created factory caches metadata derived from the iModel's schemas (e.g. the tree of hidden classes for a
+ * given select class). The cache lives for the lifetime of the factory and is not invalidated automatically, so
+ * the factory must be re-created when the iModel's schemas may have changed.
  */
 export function createNodesQueryClauseFactory(props) {
     return new NodeSelectQueryFactory(props);
@@ -50,6 +53,7 @@ export function createNodesQueryClauseFactory(props) {
 class NodeSelectQueryFactory {
     _imodelAccess;
     _instanceLabelSelectClauseFactory;
+    _hiddenClassesTreeCache = new Map();
     constructor(props) {
         this._imodelAccess = props.imodelAccess;
         this._instanceLabelSelectClauseFactory = props.instanceLabelSelectClauseFactory;
@@ -58,9 +62,11 @@ class NodeSelectQueryFactory {
     async createSelectClause(props) {
         // note: the columns order must match the order in `NodeSelectClauseColumnNames`
         return `
-      ec_ClassName(${props.ecClassId.selector}) AS ${NodeSelectClauseColumnNames.FullClassName},
+      ec_ClassName(${props.ecClassId.selector}, 's.c') AS ${NodeSelectClauseColumnNames.FullClassName},
       ${props.ecInstanceId.selector} AS ${NodeSelectClauseColumnNames.ECInstanceId},
-      ${createECSqlValueSelector(props.nodeLabel)} AS ${NodeSelectClauseColumnNames.DisplayLabel},
+      ${createECSqlValueSelector(typeof props.nodeLabel === "object" && "of" in props.nodeLabel
+            ? { selector: await this._instanceLabelSelectClauseFactory.createSelectClause(props.nodeLabel.of) }
+            : props.nodeLabel)} AS ${NodeSelectClauseColumnNames.DisplayLabel},
       CAST(${createECSqlValueSelector(props.hasChildren)} AS BOOLEAN) AS ${NodeSelectClauseColumnNames.HasChildren},
       CAST(${createECSqlValueSelector(props.hideIfNoChildren)} AS BOOLEAN) AS ${NodeSelectClauseColumnNames.HideIfNoChildren},
       CAST(${createECSqlValueSelector(props.hideNodeInHierarchy)} AS BOOLEAN) AS ${NodeSelectClauseColumnNames.HideNodeInHierarchy},
@@ -83,28 +89,32 @@ class NodeSelectQueryFactory {
      *
      * Special cases:
      * - If `filter` is `undefined`, `joins` and `where` are set to empty strings and `from` is set to `contentClass.fullName`.
-     * - If the provided content class doesn't intersect with the property class in provided filter, a special result
-     * is returned to make sure the resulting query is valid and doesn't return anything.
+     * - If the provided content class doesn't intersect with the property class in provided filter OR referenced schema items (classes/properties)
+     * don't exist in the iModel, a special result is returned to make sure the resulting query is valid and doesn't return anything.
      */
     async createFilterClauses(props) {
         const { contentClass, filter } = props;
         const { from, joins, where } = filter
             ? await createInstanceFilterClauses({ imodelAccess: this._imodelAccess, contentClass, filter })
-            : {
-                from: contentClass.fullName,
-                joins: [],
-                where: [],
-            };
-        const fromClass = await getClass(this._imodelAccess, from);
-        const hiddenClasses = await getHiddenClassesTree(fromClass);
+            : { from: contentClass.fullName, joins: [], where: [] };
+        const normalizedFrom = normalizeFullClassName(from);
+        const fromClass = await getClass(this._imodelAccess, normalizedFrom);
+        // The hidden-classes tree depends only on the select class and the (static) schema metadata, but it is
+        // expensive to compute (it recursively walks the whole derived-class subtree). The same select classes
+        // recur across every hierarchy level, so memoize the result per class for the lifetime of this factory.
+        let hiddenClassesPromise = this._hiddenClassesTreeCache.get(normalizedFrom);
+        if (!hiddenClassesPromise) {
+            hiddenClassesPromise = getHiddenClassesTree(this._imodelAccess, fromClass);
+            // Don't keep a rejected result cached - drop it so a later call can retry. Until this handler runs, the
+            // entry stays this same promise (concurrent calls get a cache hit), so an unconditional delete is safe.
+            hiddenClassesPromise.catch(() => this._hiddenClassesTreeCache.delete(normalizedFrom));
+            this._hiddenClassesTreeCache.set(normalizedFrom, hiddenClassesPromise);
+        }
+        const hiddenClasses = await hiddenClassesPromise;
         const hiddenClassesWhereClause = createWhereClauseForHiddenClasses(hiddenClasses, contentClass.alias);
         hiddenClassesWhereClause.hideClause && where.push(hiddenClassesWhereClause.hideClause);
         assert(!hiddenClassesWhereClause.showClause, "`showClause` is expected to always be empty here");
-        return {
-            from,
-            joins: joins.join("\n"),
-            where: where.join(" AND "),
-        };
+        return { from, joins: joins.join("\n"), where: where.join(" AND ") };
     }
 }
 /**
@@ -121,47 +131,97 @@ class NodeSelectQueryFactory {
  */
 async function createInstanceFilterClauses(props) {
     const { imodelAccess, contentClass, filter } = props;
+    // In some cases the given filter means we want the query to return nothing - e.g. when filtering by classes that don't intersect
+    // with the given content class. Return a special result that makes sure the resulting query is valid, but returns no rows.
+    const DISABLE_QUERY = { from: contentClass.fullName, joins: [], where: ["FALSE"] };
     const from = await specializeContentClass({
-        classHierarchyInspector: imodelAccess,
+        classHierarchyInspector: {
+            async classDerivesFrom(derivedClassName, baseClassName) {
+                try {
+                    return await imodelAccess.classDerivesFrom(derivedClassName, baseClassName);
+                }
+                catch (e) {
+                    /* v8 ignore else -- @preserve */
+                    if (isSchemaOrClassNotFoundError(e)) {
+                        // either derived or base class doesn't exist in this iModel
+                        return false;
+                    }
+                    /* v8 ignore next -- @preserve */
+                    throw e;
+                }
+            },
+        },
         contentClassName: contentClass.fullName,
-        filterClassNames: filter.propertyClassNames,
+        filterClassNames: filter.propertyClassNames.map(normalizeFullClassName),
     });
     if (!from) {
-        // filter class doesn't intersect with content class - make sure the query returns nothing by returning a `FALSE` WHERE clause
-        return { from: contentClass.fullName, joins: [], where: ["FALSE"] };
+        // filter class doesn't intersect with content class
+        return DISABLE_QUERY;
     }
-    /**
-     * TODO:
-     * There may be similar related instance paths, e.g.:
-     * - A -> B -> C,
-     * - A -> B -> D.
-     * At this moment we're handling each path individually which means A and B would get joined twice. We could look into
-     * creating a join tree first, e.g.
-     *         C
-     *        /
-     * A -> B
-     *        \
-     *         D
-     */
-    const joins = await Promise.all(filter.relatedInstances.map(async (rel, i) => ECSql.createRelationshipPathJoinClause({
-        schemaProvider: imodelAccess,
-        path: assignRelationshipPathAliases(rel.path, i, contentClass.alias, rel.alias),
-    })));
-    const where = new Array();
+    let filteredClassNamesInThisIModel;
     if (filter.filteredClassNames && filter.filteredClassNames.length > 0) {
+        filteredClassNamesInThisIModel = (await Promise.all(filter.filteredClassNames
+            .map(normalizeFullClassName)
+            .map(async (fullClassName) => ({
+            fullClassName,
+            filteredClass: await tryGetClass(imodelAccess, fullClassName),
+        }))))
+            .filter(({ filteredClass }) => !!filteredClass)
+            .map(({ fullClassName }) => fullClassName);
+        if (filteredClassNamesInThisIModel.length === 0) {
+            // we had filter classes, but none of them exist in this iModel
+            return DISABLE_QUERY;
+        }
+    }
+    let joins;
+    try {
+        joins = await Promise.all(filter.relatedInstances.map(async (rel, i) => {
+            const res = await ECSql.createRelationshipPathJoinClause({
+                schemaProvider: imodelAccess,
+                path: assignRelationshipPathAliases(rel.path, i, contentClass.alias, rel.alias),
+            });
+            assert(!res.bindings, "Expecting no bindings as the relationship path has no instance filter.");
+            return res.joins;
+        }));
+    }
+    catch (e) {
+        /* v8 ignore else -- @preserve */
+        if (isSchemaOrClassNotFoundError(e)) {
+            // at least one related instance spec uses a class that doesn't exist in this iModel
+            return DISABLE_QUERY;
+        }
+        /* v8 ignore next -- @preserve */
+        throw e;
+    }
+    const classAliasMap = new Map([[contentClass.alias, from]]);
+    filter.relatedInstances.forEach(({ path, alias }) => path.length > 0 && classAliasMap.set(alias, normalizeFullClassName(path[path.length - 1].targetClassName)));
+    let propertiesFilter;
+    try {
+        propertiesFilter = await createWhereClause(contentClass.alias, async (alias) => {
+            const aliasClassName = classAliasMap.get(alias);
+            return aliasClassName ? getClass(imodelAccess, aliasClassName) : undefined;
+        }, filter.rules);
+    }
+    catch (e) {
+        // note: don't need to worry about schemas & classes here, because that's taken care of above, when
+        // validating property class names & related instance defs
+        /* v8 ignore else -- @preserve */
+        if (isPropertyNotFoundError(e)) {
+            // filter uses a property that doesn't exist in this iModel
+            return DISABLE_QUERY;
+        }
+        /* v8 ignore next -- @preserve */
+        throw e;
+    }
+    const where = new Array();
+    if (filteredClassNamesInThisIModel) {
         where.push(`${ECSql.createRawPropertyValueSelector(contentClass.alias, "ECClassId")} IS (
-          ${filter.filteredClassNames
+          ${filteredClassNamesInThisIModel
             .map(parseFullClassName)
             .map(({ schemaName, className }) => `[${schemaName}].[${className}]`)
             .join(", ")}
         )`);
     }
-    const classAliasMap = new Map([[contentClass.alias, from]]);
-    filter.relatedInstances.forEach(({ path, alias }) => path.length > 0 && classAliasMap.set(alias, path[path.length - 1].targetClassName));
-    const propertiesFilter = await createWhereClause(contentClass.alias, async (alias) => {
-        const aliasClassName = classAliasMap.get(alias);
-        return aliasClassName ? getClass(imodelAccess, aliasClassName) : undefined;
-    }, filter.rules);
     if (propertiesFilter) {
         where.push(propertiesFilter);
     }
@@ -206,6 +266,8 @@ async function createGroupingSelector(grouping, imodelAccess, instanceLabelSelec
                 ...createBaseGroupingParamSelectors(grouping.byBaseClasses),
             ]),
         });
+    // TODO: MISSING_COVERAGE
+    /* v8 ignore else -- @preserve */
     if (grouping.byProperties) {
         const propertyClass = await getClass(imodelAccess, grouping.byProperties.propertiesClassName);
         groupingSelectors.push({
@@ -244,16 +306,10 @@ async function createGroupingSelector(grouping, imodelAccess, instanceLabelSelec
 function createLabelGroupingBaseParamsSelectors(byLabel) {
     const selectors = new Array();
     if (byLabel.action !== undefined) {
-        selectors.push({
-            key: "action",
-            selector: `${createECSqlValueSelector(byLabel.action)}`,
-        });
+        selectors.push({ key: "action", selector: `${createECSqlValueSelector(byLabel.action)}` });
     }
     if (byLabel.groupId !== undefined) {
-        selectors.push({
-            key: "groupId",
-            selector: createECSqlValueSelector(byLabel.groupId),
-        });
+        selectors.push({ key: "groupId", selector: createECSqlValueSelector(byLabel.groupId) });
     }
     if (byLabel.action !== "merge") {
         selectors.push(...createBaseGroupingParamSelectors(byLabel));
@@ -262,17 +318,18 @@ function createLabelGroupingBaseParamsSelectors(byLabel) {
 }
 async function createPropertyGroupSelectors(propertyGroup, propertyClass, instanceLabelSelectClauseFactory) {
     const selectors = new Array();
-    selectors.push({
-        key: "propertyName",
-        selector: `${createECSqlValueSelector(propertyGroup.propertyName)}`,
-    });
-    const property = await propertyClass.getProperty(propertyGroup.propertyName);
+    selectors.push({ key: "propertyName", selector: `${createECSqlValueSelector(propertyGroup.propertyName)}` });
+    const property = propertyClass.getProperty(propertyGroup.propertyName);
     if (!property) {
         throw new Error(`Property "${propertyGroup.propertyName}" not found in ECClass "${propertyClass.fullName}".`);
     }
     if (property.isNavigation()) {
-        const relationshipClass = await property.relationshipClass;
-        const abstractConstraint = property.direction === "Forward" ? await relationshipClass.target.abstractConstraint : await relationshipClass.source.abstractConstraint;
+        const relationshipClass = property.relationshipClass;
+        const abstractConstraint = property.direction === "Forward"
+            ? relationshipClass.target.abstractConstraint
+            : relationshipClass.source.abstractConstraint;
+        // TODO: MISSING_COVERAGE
+        /* v8 ignore else -- @preserve */
         if (!abstractConstraint) {
             throw new Error(`Could not determine class name for navigation property with direction "${property.direction}".`);
         }
@@ -303,21 +360,10 @@ function createRangeParamSelectors(ranges) {
         key: "ranges",
         selector: `json_array(${ranges
             .map((range) => serializeJsonObject([
-            {
-                key: "fromValue",
-                selector: createECSqlValueSelector(range.fromValue),
-            },
-            {
-                key: "toValue",
-                selector: createECSqlValueSelector(range.toValue),
-            },
+            { key: "fromValue", selector: createECSqlValueSelector(range.fromValue) },
+            { key: "toValue", selector: createECSqlValueSelector(range.toValue) },
             ...(range.rangeLabel
-                ? [
-                    {
-                        key: "rangeLabel",
-                        selector: `${createECSqlValueSelector(range.rangeLabel)}`,
-                    },
-                ]
+                ? [{ key: "rangeLabel", selector: `${createECSqlValueSelector(range.rangeLabel)}` }]
                 : []),
         ]))
             .join(", ")})`,
@@ -326,22 +372,13 @@ function createRangeParamSelectors(ranges) {
 function createBaseGroupingParamSelectors(params) {
     const selectors = new Array();
     if (params.hideIfNoSiblings !== undefined) {
-        selectors.push({
-            key: "hideIfNoSiblings",
-            selector: createECSqlValueSelector(params.hideIfNoSiblings),
-        });
+        selectors.push({ key: "hideIfNoSiblings", selector: createECSqlValueSelector(params.hideIfNoSiblings) });
     }
     if (params.hideIfOneGroupedNode !== undefined) {
-        selectors.push({
-            key: "hideIfOneGroupedNode",
-            selector: createECSqlValueSelector(params.hideIfOneGroupedNode),
-        });
+        selectors.push({ key: "hideIfOneGroupedNode", selector: createECSqlValueSelector(params.hideIfOneGroupedNode) });
     }
     if (params.autoExpand !== undefined) {
-        selectors.push({
-            key: "autoExpand",
-            selector: createECSqlValueSelector(params.autoExpand),
-        });
+        selectors.push({ key: "autoExpand", selector: createECSqlValueSelector(params.autoExpand) });
     }
     return selectors;
 }
@@ -356,7 +393,15 @@ async function createWhereClause(contentClassAlias, classLoader, rule) {
         return clause ? (rule.operator === "or" ? `(${clause})` : clause) : undefined;
     }
     const sourceAlias = rule.sourceAlias ? rule.sourceAlias : contentClassAlias;
-    const propertyValueSelector = ECSql.createRawPropertyValueSelector(sourceAlias, rule.propertyName);
+    const propertyClass = await classLoader(sourceAlias);
+    if (!propertyClass) {
+        throw new Error(`Class with alias "${sourceAlias}" not found.`);
+    }
+    const property = propertyClass.getProperty(rule.propertyName);
+    if (!property) {
+        throw new Error(`Property "${rule.propertyName}" not found in ECClass "${propertyClass.fullName}".`);
+    }
+    const propertyValueSelector = ECSql.createRawPropertyValueSelector(sourceAlias, property.name);
     if (isUnaryRuleOperator(rule.operator)) {
         switch (rule.operator) {
             case "is-true":
@@ -378,24 +423,16 @@ async function createWhereClause(contentClassAlias, classLoader, rule) {
         const escapedValue = value.replace(/[%_\\]/g, "\\$&");
         return `${propertyValueSelector} ${ecsqlOperator} '%${escapedValue}%' ESCAPE '\\'`;
     }
-    const propertyClass = await classLoader(sourceAlias);
-    if (!propertyClass) {
-        throw new Error(`Class with alias "${sourceAlias}" not found.`);
-    }
-    const property = await propertyClass.getProperty(rule.propertyName);
-    if (!property) {
-        throw new Error(`Property "${rule.propertyName}" not found in ECClass "${propertyClass.fullName}".`);
-    }
     if (property.isNavigation()) {
-        assert(rule.value !== undefined && GenericInstanceFilterRuleValue.isInstanceKey(value));
+        assert(GenericInstanceFilterRuleValue.isInstanceKey(value));
         return `${propertyValueSelector}.[Id] ${ecsqlOperator} ${ECSql.createRawPrimitiveValueSelector(value.id)}`;
     }
     if (property.isEnumeration()) {
-        assert(rule.value !== undefined && !GenericInstanceFilterRuleValue.isInstanceKey(value));
+        assert(!GenericInstanceFilterRuleValue.isInstanceKey(value));
         return `${propertyValueSelector} ${ecsqlOperator} ${ECSql.createRawPrimitiveValueSelector(value)}`;
     }
     if (property.isPrimitive()) {
-        assert(rule.value !== undefined && !GenericInstanceFilterRuleValue.isInstanceKey(value));
+        assert(!GenericInstanceFilterRuleValue.isInstanceKey(value));
         switch (property.primitiveType) {
             case "Point2d": {
                 assert(rule.operator === "is-equal" || rule.operator === "is-not-equal");
@@ -472,14 +509,17 @@ function assignRelationshipPathAliases(path, pathIndex, sourceAlias, targetAlias
     }
     const result = [];
     path.forEach((step, i) => {
+        const sourceClassName = normalizeFullClassName(step.sourceClassName);
+        const targetClassName = normalizeFullClassName(step.targetClassName);
+        const relationshipName = normalizeFullClassName(step.relationshipClassName);
         result.push({
-            targetClassName: step.targetClassName,
-            relationshipName: step.relationshipClassName,
-            sourceClassName: step.sourceClassName,
+            targetClassName,
+            relationshipName,
+            sourceClassName,
             relationshipReverse: !step.isForwardRelationship,
             sourceAlias: i === 0 ? sourceAlias : result[i - 1].targetAlias,
-            relationshipAlias: createAlias(step.relationshipClassName, i),
-            targetAlias: i === path.length - 1 ? targetAlias : createAlias(step.targetClassName, i),
+            relationshipAlias: createAlias(relationshipName, i),
+            targetAlias: i === path.length - 1 ? targetAlias : createAlias(targetClassName, i),
             joinType: "inner",
         });
     });
@@ -511,50 +551,65 @@ async function getSpecializedPropertyClass(classHierarchyInspector, classes) {
     }
     return resolvedClassName;
 }
-async function getHiddenClassesTree(selectClass, selectClassAttribute = "show") {
-    const derivedClasses = await getDirectDerivedClasses(selectClass);
-    const derivedClassSchemas = derivedClasses.reduce((acc, ecClass) => {
-        if (!acc.set.has(ecClass.schema.name)) {
-            acc.schemas.push(ecClass.schema);
-            acc.set.add(ecClass.schema.name);
+async function getHiddenClassesTree(schemaProvider, selectClass, selectClassAttribute = "show") {
+    const derivedClassNames = selectClass.getDerivedClassNames({ onlyDirect: true });
+    const derivedClassNamesBySchema = derivedClassNames.reduce((acc, fullClassName) => {
+        const { schemaName, className } = parseFullClassName(fullClassName);
+        let entry = acc.get(schemaName);
+        if (!entry) {
+            entry = [];
+            acc.set(schemaName, entry);
         }
+        entry.push(className);
         return acc;
-    }, { set: new Set(), schemas: new Array() }).schemas;
-    const hiddenSchemas = new Map();
-    await Promise.all(derivedClassSchemas.map(async (ecSchema) => {
-        hiddenSchemas.set(ecSchema.name, await getHiddenSchemaAttribute(ecSchema));
+    }, new Map());
+    const derivedClassesBySchema = await Promise.all([...derivedClassNamesBySchema.entries()].map(async ([schemaName, classNames]) => {
+        const schema = await schemaProvider.getSchema(schemaName);
+        /* v8 ignore next 3 -- @preserve */
+        if (!schema) {
+            throw new Error(`Schema "${schemaName}" not found.`);
+        }
+        return {
+            schema,
+            classes: classNames.map((className) => {
+                const lookupClass = schema.getClass(className);
+                /* v8 ignore next 3 -- @preserve */
+                if (!lookupClass) {
+                    throw new Error(`Class "${className}" not found in schema "${schemaName}".`);
+                }
+                return lookupClass;
+            }),
+        };
     }));
-    const tree = (await Promise.all(derivedClasses.map(async (ecClass) => {
-        const hiddenClassAttr = await getHiddenClassAttribute(ecClass);
+    const hiddenSchemas = new Map();
+    for (const { schema } of derivedClassesBySchema) {
+        hiddenSchemas.set(schema.name, schema.isHidden ? "hide" : undefined);
+    }
+    return Promise.all(derivedClassesBySchema
+        .flatMap(({ classes }) => classes)
+        .map(async (ecClass) => {
+        const hiddenClassAttr = (() => {
+            switch (ecClass.isHidden) {
+                case true:
+                    return "hide";
+                case false:
+                    return "show";
+                default:
+                    return undefined;
+            }
+        })();
         const attr = hiddenClassAttr ?? hiddenSchemas.get(ecClass.schema.name);
         if (!attr || attr === selectClassAttribute) {
-            return getHiddenClassesTree(ecClass, selectClassAttribute);
+            return getHiddenClassesTree(schemaProvider, ecClass, selectClassAttribute);
         }
         return [
             {
                 fullName: ecClass.fullName,
                 state: attr,
-                children: await getHiddenClassesTree(ecClass, attr),
+                children: await getHiddenClassesTree(schemaProvider, ecClass, attr),
             },
         ];
-    }))).flat();
-    return tree;
-}
-async function getDirectDerivedClasses(ecClass) {
-    const allDerived = await ecClass.getDerivedClasses();
-    return (await Promise.all(allDerived.map(async (c) => ({ derived: c, base: await c.baseClass }))))
-        .filter(({ base }) => base?.fullName === ecClass.fullName)
-        .map(({ derived }) => derived);
-}
-async function getHiddenClassAttribute(ecClass) {
-    const customAttributes = await ecClass.getCustomAttributes();
-    const hiddenClassAttribute = customAttributes.get("CoreCustomAttributes.HiddenClass");
-    return hiddenClassAttribute ? (hiddenClassAttribute.Show ? "show" : "hide") : undefined;
-}
-async function getHiddenSchemaAttribute(ecSchema) {
-    const customAttributes = await ecSchema.getCustomAttributes();
-    const hiddenSchemaAttribute = customAttributes.get("CoreCustomAttributes.HiddenSchema");
-    return hiddenSchemaAttribute ? (hiddenSchemaAttribute.ShowClasses ? "show" : "hide") : undefined;
+    })).then((results) => results.flat());
 }
 function createWhereClauseForHiddenClasses(hiddenClasses, selectAlias) {
     const res = {};
@@ -584,4 +639,24 @@ function createWhereClauseForHiddenClasses(hiddenClasses, selectAlias) {
     }
     return res;
 }
+async function tryGetClass(schemaProvider, fullClassName) {
+    try {
+        return await getClass(schemaProvider, fullClassName);
+    }
+    catch (e) {
+        /* v8 ignore else -- @preserve */
+        if (isSchemaOrClassNotFoundError(e)) {
+            return undefined;
+        }
+        /* v8 ignore next -- @preserve */
+        throw e;
+    }
+}
+function isSchemaOrClassNotFoundError(e) {
+    return (e instanceof Error &&
+        (!!e.message.match(/^Schema "[\w\d_]+" not found/) || !!e.message.match(/^Class "[\w\d_\.:]+" not found/)));
+}
+function isPropertyNotFoundError(e) {
+    return e instanceof Error && !!e.message.match(/^Property "[\w\d]+" not found in ECClass/);
+}
 //# sourceMappingURL=NodeSelectQueryFactory.js.map