@itwin/core-frontend 5.12.0-dev.8 → 5.13.0-dev.1

package/lib/cjs/IModelConnection.js

@@ -107,7 +107,9 @@ class IModelConnection extends core_common_1.IModel {
      */
     fontMap; // eslint-disable-line @typescript-eslint/no-deprecated
     _schemaContext;
-    _schemasPromise;
+    // Created lazily on the first getSchemaView call. Owns the SchemaView's lifetime and does all its
+    // data access through the SchemaViewDataProvider implemented below.
+    _schemaViewManager;
     /** Load the FontMap for this IModelConnection.
      * @returns Returns a Promise<FontMap> that is fulfilled when the FontMap member of this IModelConnection is valid.
      * @deprecated in 5.0.0 - might be removed in next major version. If you need font Ids on the front-end for some reason, write an Ipc method that queries [IModelDb.fonts]($backend).
@@ -535,33 +537,23 @@ class IModelConnection extends core_common_1.IModel {
     }
     /** Get the schema view for this iModel. The view is built lazily on
      * first call by fetching compact binary schema data via `PRAGMA schema_view` through
-     * the existing queryRows RPC (ConcurrentQuery). Subsequent calls return the cached view.
-     * Multiple concurrent callers share a single in-flight fetch.
+     * the existing queryRows RPC (ConcurrentQuery).
      *
      * The returned `SchemaView` is a lightweight, read-only, synchronous API for
      * navigating schema metadata - classes, properties, relationships, enumerations, etc.
      * It is the recommended default for runtime read-only metadata access and is significantly
      * faster and lower-memory than [[schemaContext]]. Use [[schemaContext]] for custom-attribute
      * deserialization or anywhere you need the full ecschema-metadata object graph.
+     *
+     * Every call shares one accumulating view instance and concurrent calls are serialized, so a
+     * caller never observes a partially loaded view. The instance is discarded once the connection
+     * detects that schemas changed, for example after [[BriefcaseConnection.pullChanges]]; the next
+     * call builds a new one. See [GetSchemaViewArgs]($ecschema-metadata) for the arguments.
      * @beta
      */
-    async getSchemaView() {
-        if (this._schemasPromise) {
-            const ctx = await this._schemasPromise;
-            if (!ctx.isOutdated)
-                return ctx;
-        }
-        // Capture the in-flight promise locally so the rejection handler only clears
-        // `_schemasPromise` if it still points at this build. A concurrent invalidation +
-        // re-fetch could otherwise replace the field before our fetch fails, and a naive
-        // `_schemasPromise = undefined` would clobber that newer reference.
-        const inflight = this._fetchSchemas();
-        this._schemasPromise = inflight;
-        inflight.catch(() => {
-            if (this._schemasPromise === inflight)
-                this._schemasPromise = undefined;
-        });
-        return inflight;
+    async getSchemaView(args) {
+        this._schemaViewManager ??= new ecschema_metadata_1.SchemaViewManager(this._createSchemaViewDataProvider());
+        return this._schemaViewManager.getSchemaView(args);
     }
     /**
      * Checks whether the iModel's schemas have changed since the current cached [[SchemaView]] was
@@ -573,7 +565,7 @@ class IModelConnection extends core_common_1.IModel {
      * returns only the new changeset id, not the list of applied changesets with their types.
      * Unconditionally discarding the cached [[SchemaView]] after every such operation would cause
      * unnecessary reloads in the common case where schemas are unchanged. This method avoids that
-     * cost by fetching a lightweight schema checksum via `PRAGMA checksum(ecdb_schema)` and
+     * cost by fetching a lightweight schema token via `PRAGMA checksum(schema_token)` and
      * comparing it against the token stored in the cached view. Only when the token differs is the
      * cache discarded.
      *
@@ -582,61 +574,59 @@ class IModelConnection extends core_common_1.IModel {
      * @internal
      */
     async invalidateSchemaViewIfChanged() {
-        if (!this._schemasPromise)
-            return;
-        const existingPromise = this._schemasPromise;
-        let existing;
-        try {
-            existing = await existingPromise;
-        }
-        catch {
-            // The cached promise itself failed; drop it so the next getSchemaView() retries.
-            if (this._schemasPromise === existingPromise)
-                this._schemasPromise = undefined;
-            return;
-        }
-        if (!existing.schemaToken)
-            return;
-        try {
-            const reader = this.createQueryReader("PRAGMA checksum(ecdb_schema)");
-            const result = await reader.next();
-            if (result.done)
-                throw new Error("PRAGMA checksum(ecdb_schema) returned no rows");
-            const liveToken = result.value.sha3_256;
-            if (liveToken !== existing.schemaToken) {
-                if (this._schemasPromise === existingPromise)
-                    this._schemasPromise = undefined;
-                existing.markOutdated();
-            }
-        }
-        catch {
-            // The checksum check is called right after operations that may have changed schemas
-            // (e.g., pullChanges). If we cannot verify the cached view is still current, drop it
-            // rather than risk returning stale metadata indefinitely. The next getSchemaView() call
-            // will reload. We also mark the existing view outdated so any retained references can
-            // observe the invalidation.
-            if (this._schemasPromise === existingPromise) {
-                this._schemasPromise = undefined;
-                existing.markOutdated();
-            }
-        }
+        await this._schemaViewManager?.invalidateIfChanged();
+    }
+    /** The [SchemaViewDataProvider]($ecschema-metadata) backing this iModel's [[getSchemaView]]: the
+     * transport-specific half of schema-view loading, issued through the queryRows RPC
+     * (ConcurrentQuery). The frontend *pins* the blob format version in both pragmas, because the
+     * backend it talks to can be older or newer; the pin makes it return a blob this code can parse,
+     * or fail cleanly.
+     */
+    _createSchemaViewDataProvider() {
+        return {
+            fetchFullBlob: async () => this._fetchSchemaBlob(`PRAGMA schema_view(${ecschema_metadata_1.schemaViewFormatVersion})`),
+            // Names are ECNames, so a comma can never occur in one. Native re-validates each token as an
+            // ECName and fails the pragma on an unknown name. The `v<N>;` prefix pins the format version.
+            fetchFragmentBlob: async (schemaNames) => this._fetchSchemaBlob(`PRAGMA schema_view_fragment('v${ecschema_metadata_1.schemaViewFormatVersion};${schemaNames.join(",")}')`),
+            fetchManifest: async () => {
+                const schemaRows = [];
+                const schemaSql = "SELECT ECInstanceId, Name, VersionMajor, VersionWrite, VersionMinor FROM meta.ECSchemaDef";
+                for await (const row of this.createQueryReader(schemaSql)) {
+                    // ECInstanceId arrives as a hex Id64String. `ec_` metadata rowids carry no briefcase
+                    // prefix, so the local id is the full value.
+                    schemaRows.push({ ecInstanceId: core_bentley_1.Id64.getLocalId(row[0]), name: row[1], versionMajor: row[2], versionWrite: row[3], versionMinor: row[4] });
+                }
+                const referenceRows = [];
+                const referenceSql = "SELECT SourceECInstanceId, TargetECInstanceId FROM meta.SchemaHasSchemaReferences";
+                for await (const row of this.createQueryReader(referenceSql))
+                    referenceRows.push({ sourceECInstanceId: core_bentley_1.Id64.getLocalId(row[0]), targetECInstanceId: core_bentley_1.Id64.getLocalId(row[1]) });
+                return ecschema_metadata_1.SchemaManifest.fromRows(schemaRows, referenceRows);
+            },
+            fetchSchemaToken: async () => {
+                const reader = this.createQueryReader("PRAGMA checksum(schema_token)");
+                const result = await reader.next();
+                if (result.done)
+                    throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "PRAGMA checksum(schema_token) returned no rows");
+                return result.value.sha3_256;
+            },
+        };
     }
-    async _fetchSchemas() {
-        // PRAGMA returns exactly one row with format, formatVersion, data (binary), schemaToken.
-        // Important: only call reader.next() once - do NOT use `for await` on PRAGMA results.
-        // ConcurrentQuery wraps regular ECSQL in LIMIT/OFFSET for pagination but skips this for
-        // PRAGMAs. If the serialized result exceeds the memory threshold, the response is marked
-        // "Partial", and a `for await` loop would re-issue the same PRAGMA forever since PRAGMAs
-        // don't support OFFSET-based pagination.
-        const reader = this.createQueryReader(`PRAGMA schema_view(${ecschema_metadata_1.schemaViewFormatVersion})`);
+    /** Fetch one schema-view blob (full or fragment). Both `PRAGMA schema_view` and
+     * `PRAGMA schema_view_fragment` return a single row with the same columns. */
+    async _fetchSchemaBlob(pragma) {
+        // Only call reader.next() once - do NOT use `for await` on PRAGMA results. ConcurrentQuery wraps
+        // regular ECSQL in LIMIT/OFFSET for pagination but skips this for PRAGMAs; if the serialized
+        // result exceeds the memory threshold, the response is marked "Partial", and a `for await` loop
+        // would re-issue the same PRAGMA forever since PRAGMAs don't support OFFSET-based pagination.
+        const reader = this.createQueryReader(pragma);
         const result = await reader.next();
         if (result.done)
-            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "PRAGMA schema_view returned no rows");
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `${pragma} returned no rows`);
         const data = result.value.data;
         const token = result.value.schemaToken;
         if (data === undefined || data === null)
-            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "PRAGMA schema_view returned null data column");
-        return ecschema_metadata_1.SchemaView.fromBinary(data, token ?? "");
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `${pragma} returned null data column`);
+        return { data, schemaToken: token ?? "" };
     }
 }
 exports.IModelConnection = IModelConnection;
@@ -1100,24 +1090,24 @@ exports.SnapshotConnection = SnapshotConnection;
                 return [];
             const select3d = `
         SELECT
-          ECInstanceId,
+          ECInstanceId as id,
           Origin.x as x, Origin.y as y, Origin.z as z,
           BBoxLow.x as lx, BBoxLow.y as ly, BBoxLow.z as lz,
           BBoxHigh.x as hx, BBoxHigh.y as hy, BBoxHigh.z as hz,
-          Yaw, Pitch, Roll,
-          NULL as Rotation
+          Yaw as yaw, Pitch as pitch, Roll as roll,
+          NULL as rotation
         FROM bis.GeometricElement3d
         WHERE Origin IS NOT NULL AND BBoxLow IS NOT NULL AND BBoxHigh IS NOT NULL`;
             // Note: For the UNION ALL statement, the column aliases in select2d are ignored - so they
             // must match those in select3d.
             const select2d = `
         SELECT
-          ECInstanceId,
+          ECInstanceId as id,
           Origin.x as x, Origin.y as y, NULL as z,
           BBoxLow.x as lx, BBoxLow.y as ly, NULL as lz,
           BBoxHigh.x as hx, BBoxHigh.y as hy, NULL as hz,
           NULL as yaw, NULL as pitch, NULL as roll,
-          Rotation
+          Rotation as rotation
         FROM bis.GeometricElement2d
         WHERE Origin IS NOT NULL AND BBoxLow IS NOT NULL AND BBoxHigh IS NOT NULL`;
             const idCriterion = `ECInstanceId IN (${ids.join(",")})`;
@@ -1139,8 +1129,7 @@ exports.SnapshotConnection = SnapshotConnection;
                     break;
             }
             const placements = new Array();
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            for await (const queryRow of this._iModel.createQueryReader(ecsql, undefined, { rowFormat: core_common_1.QueryRowFormat.UseJsPropertyNames })) {
+            for await (const queryRow of this._iModel.createQueryReader(ecsql, undefined, { rowFormat: core_common_1.QueryRowFormat.UseECSqlPropertyNames })) {
                 const row = queryRow.toRow();
                 const origin = [row.x, row.y, row.z];
                 const bbox = {