@itwin/core-backend 3.0.0-dev.100

package/lib/cjs/RpcBackend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcBackend.js","sourceRoot":"","sources":["../../src/RpcBackend.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module RpcInterface\r\n */\r\n\r\n// cspell:ignore calltrace\r\n\r\nimport * as multiparty from \"multiparty\";\r\nimport * as FormData from \"form-data\";\r\nimport { BentleyStatus, HttpServerRequest, IModelError, RpcActivity, RpcInvocation, RpcMultipart, RpcSerializedValue } from \"@itwin/core-common\";\r\nimport { AsyncLocalStorage } from \"async_hooks\";\r\nimport { Logger } from \"@itwin/core-bentley\";\r\n\r\n/**\r\n * Utility for tracing Rpc activity processing. When multiple Rpc requests are being processed asynchronously, this\r\n * class can be used to correlate the current calltrace with the originating RpcActivity. This is used for automatic appending\r\n * of RpcActivity to log messages emitted during Rpc processing. It may also be used to retrieve the user accessToken\r\n * from the RpcActivity.\r\n * @public\r\n */\r\nexport class RpcTrace {\r\n  private static _storage = new AsyncLocalStorage();\r\n\r\n  /** Get the [RpcActivity]($common) for the currently executing async, or `undefined` if there is no\r\n   * RpcActivity in the current call stack.\r\n   * */\r\n  public static get currentActivity(): RpcActivity | undefined {\r\n    return RpcTrace._storage.getStore() as RpcActivity | undefined;\r\n  }\r\n\r\n  /** Start the processing of an RpcActivity. */\r\n  public static async run<T>(activity: RpcActivity, fn: () => Promise<T>): Promise<T> {\r\n    return RpcTrace._storage.run(activity, fn);\r\n  }\r\n}\r\n\r\nlet initialized = false;\r\n/** @internal */\r\nexport function initializeRpcBackend() {\r\n  if (initialized)\r\n    return;\r\n\r\n  initialized = true;\r\n\r\n  RpcInvocation.runActivity = RpcTrace.run; // redirect the invocation processing to the tracer\r\n\r\n  // set up static logger metadata to include current RpcActivity information for logs during rpc processing\r\n  Logger.staticMetaData.set(\"rpc\", () => RpcInvocation.sanitizeForLog(RpcTrace.currentActivity));\r\n\r\n  RpcMultipart.createStream = (value: RpcSerializedValue) => {\r\n    const form = new FormData();\r\n    RpcMultipart.writeValueToForm(form, value);\r\n    return form;\r\n  };\r\n\r\n  RpcMultipart.parseRequest = async (req: HttpServerRequest) => {\r\n    return new Promise<RpcSerializedValue>((resolve, reject) => {\r\n      const form = new multiparty.Form({ maxFieldsSize: Infinity });\r\n      form.on(\"error\", (err) => {\r\n        reject(err);\r\n      });\r\n\r\n      const value = RpcSerializedValue.create();\r\n      const data: { [index: string]: { size: number, chunks: Buffer[] } } = {};\r\n\r\n      form.on(\"part\", (part: multiparty.Part) => {\r\n        part.on(\"data\", (chunk: string | Buffer) => {\r\n          if (part.name === \"objects\") {\r\n            value.objects += chunk.toString();\r\n          } else if (Buffer.isBuffer(chunk)) {\r\n            if (!data[part.name]) {\r\n              data[part.name] = { size: 0, chunks: [] };\r\n            }\r\n\r\n            data[part.name].size += chunk.byteLength;\r\n            data[part.name].chunks.push(chunk);\r\n          } else {\r\n            throw new IModelError(BentleyStatus.ERROR, \"Unknown input.\");\r\n          }\r\n        });\r\n      });\r\n\r\n      form.on(\"close\", () => {\r\n        let i = 0;\r\n        for (; ;) {\r\n          const part = data[`data-${i}`];\r\n          if (!part) {\r\n            break;\r\n          }\r\n\r\n          value.data.push(Buffer.concat(part.chunks, part.size));\r\n          ++i;\r\n        }\r\n\r\n        resolve(value);\r\n      });\r\n\r\n      form.parse(req);\r\n    });\r\n  };\r\n}\r\n\r\n"]}

package/lib/cjs/SQLiteDb.d.ts

@@ -0,0 +1,66 @@
+/** @packageDocumentation
+ * @module SQLiteDb
+ */
+import { DbResult, IDisposable, OpenMode } from "@itwin/core-bentley";
+import { IModelJsNative } from "@bentley/imodeljs-native";
+import { SqliteStatement } from "./SqliteStatement";
+/** A SQLiteDb file
+ * @public
+ */
+export declare class SQLiteDb implements IDisposable {
+    private _nativeDb?;
+    private _sqliteStatementCache;
+    /** @internal */
+    get nativeDb(): IModelJsNative.SQLiteDb;
+    constructor();
+    /** Call this function when finished with this SQLiteDb. This releases the native resources */
+    dispose(): void;
+    /** Create a SQLiteDb
+     * @param pathName The path to the SQLiteDb file to create.
+     */
+    createDb(pathName: string): void;
+    /** Open a SQLiteDb.
+     * @param pathName The path to the SQLiteDb file to open
+     */
+    openDb(pathName: string, openMode: OpenMode): void;
+    /** Returns true if the SQLiteDb is open */
+    get isOpen(): boolean;
+    /** Close SQLiteDb. */
+    closeDb(): void;
+    /** Commit the outermost transaction, writing changes to the file. Then, restart the transaction. */
+    saveChanges(): void;
+    /** Abandon (cancel) the outermost transaction, discarding all changes since last save. Then, restart the transaction. */
+    abandonChanges(): void;
+    /**
+       * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist
+       * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+       * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be
+       * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+       * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].
+       * @param sql The SQLite SQL statement to execute
+       * @param callback the callback to invoke on the prepared statement
+       * @returns the value returned by `callback`.
+       * @see [[withPreparedStatement]]
+       * @public
+       */
+    withPreparedSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T;
+    /**
+       * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.
+       * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.
+       * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].
+       * @param sql The SQLite SQL statement to execute
+       * @param callback the callback to invoke on the prepared statement
+       * @returns the value returned by `callback`.
+       * @public
+       */
+    withSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T;
+    /** Prepare an SQL statement.
+       * @param sql The SQLite SQL statement to prepare
+       * @param logErrors Determine if errors are logged or not
+       * @internal
+       */
+    prepareSqliteStatement(sql: string, logErrors?: boolean): SqliteStatement;
+    /** execute an SQL statement */
+    executeSQL(sql: string): DbResult;
+}
+//# sourceMappingURL=SQLiteDb.d.ts.map

package/lib/cjs/SQLiteDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQLiteDb.d.ts","sourceRoot":"","sources":["../../src/SQLiteDb.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAkB,MAAM,mBAAmB,CAAC;AAEpE;;GAEG;AACH,qBAAa,QAAS,YAAW,WAAW;IAC1C,OAAO,CAAC,SAAS,CAAC,CAA0B;IAC5C,OAAO,CAAC,qBAAqB,CAAyC;IAEtE,gBAAgB;IAChB,IAAW,QAAQ,IAAI,cAAc,CAAC,QAAQ,CAE7C;;IAKD,8FAA8F;IACvF,OAAO,IAAI,IAAI;IAStB;;OAEG;IACI,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIvC;;OAEG;IACI,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIzD,2CAA2C;IAC3C,IAAW,MAAM,IAAI,OAAO,CAAmC;IAE/D,sBAAsB;IACf,OAAO,IAAI,IAAI;IAKtB,oGAAoG;IAC7F,WAAW,IAAI,IAAI;IAI1B,yHAAyH;IAClH,cAAc,IAAI,IAAI;IAI7B;;;;;;;;;;;SAWK;IACE,2BAA2B,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,CAAC,GAAG,CAAC;IAiB7F;;;;;;;;SAQK;IACE,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,CAAC,GAAG,CAAC;IAiBrF;;;;SAIK;IACE,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,eAAe;IAM7E,+BAA+B;IACxB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;CAQzC"}

package/lib/cjs/SQLiteDb.js

@@ -0,0 +1,140 @@
+"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 SQLiteDb
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteDb = void 0;
+const IModelHost_1 = require("./IModelHost");
+const SqliteStatement_1 = require("./SqliteStatement");
+/** A SQLiteDb file
+ * @public
+ */
+class SQLiteDb {
+    constructor() {
+        this._sqliteStatementCache = new SqliteStatement_1.StatementCache();
+        this._nativeDb = new IModelHost_1.IModelHost.platform.SQLiteDb();
+    }
+    /** @internal */
+    get nativeDb() {
+        return this._nativeDb;
+    }
+    /** Call this function when finished with this SQLiteDb. This releases the native resources */
+    dispose() {
+        if (!this._nativeDb)
+            return;
+        this.closeDb();
+        this._nativeDb.dispose();
+        this._nativeDb = undefined;
+    }
+    /** Create a SQLiteDb
+     * @param pathName The path to the SQLiteDb file to create.
+     */
+    createDb(pathName) {
+        this.nativeDb.createDb(pathName);
+    }
+    /** Open a SQLiteDb.
+     * @param pathName The path to the SQLiteDb file to open
+     */
+    openDb(pathName, openMode) {
+        this.nativeDb.openDb(pathName, openMode);
+    }
+    /** Returns true if the SQLiteDb is open */
+    get isOpen() { return this.nativeDb.isOpen(); }
+    /** Close SQLiteDb. */
+    closeDb() {
+        this._sqliteStatementCache.clear();
+        this.nativeDb.closeDb();
+    }
+    /** Commit the outermost transaction, writing changes to the file. Then, restart the transaction. */
+    saveChanges() {
+        this.nativeDb.saveChanges();
+    }
+    /** Abandon (cancel) the outermost transaction, discarding all changes since last save. Then, restart the transaction. */
+    abandonChanges() {
+        this.nativeDb.abandonChanges();
+    }
+    /**
+       * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist
+       * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+       * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be
+       * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+       * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].
+       * @param sql The SQLite SQL statement to execute
+       * @param callback the callback to invoke on the prepared statement
+       * @returns the value returned by `callback`.
+       * @see [[withPreparedStatement]]
+       * @public
+       */
+    withPreparedSqliteStatement(sql, callback) {
+        var _a;
+        const stmt = (_a = this._sqliteStatementCache.findAndRemove(sql)) !== null && _a !== void 0 ? _a : this.prepareSqliteStatement(sql);
+        const release = () => this._sqliteStatementCache.addOrDispose(stmt);
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /**
+       * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.
+       * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.
+       * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].
+       * @param sql The SQLite SQL statement to execute
+       * @param callback the callback to invoke on the prepared statement
+       * @returns the value returned by `callback`.
+       * @public
+       */
+    withSqliteStatement(sql, callback) {
+        const stmt = this.prepareSqliteStatement(sql);
+        const release = () => stmt.dispose();
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /** Prepare an SQL statement.
+       * @param sql The SQLite SQL statement to prepare
+       * @param logErrors Determine if errors are logged or not
+       * @internal
+       */
+    prepareSqliteStatement(sql, logErrors = true) {
+        const stmt = new SqliteStatement_1.SqliteStatement(sql);
+        stmt.prepare(this.nativeDb, logErrors);
+        return stmt;
+    }
+    /** execute an SQL statement */
+    executeSQL(sql) {
+        const stmt = this.prepareSqliteStatement(sql);
+        try {
+            return stmt.step();
+        }
+        finally {
+            stmt.dispose();
+        }
+    }
+}
+exports.SQLiteDb = SQLiteDb;
+//# sourceMappingURL=SQLiteDb.js.map

package/lib/cjs/SQLiteDb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQLiteDb.js","sourceRoot":"","sources":["../../src/SQLiteDb.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module SQLiteDb\r\n */\r\n\r\nimport { DbResult, IDisposable, OpenMode } from \"@itwin/core-bentley\";\r\nimport { IModelJsNative } from \"@bentley/imodeljs-native\";\r\nimport { IModelHost } from \"./IModelHost\";\r\nimport { SqliteStatement, StatementCache } from \"./SqliteStatement\";\r\n\r\n/** A SQLiteDb file\r\n * @public\r\n */\r\nexport class SQLiteDb implements IDisposable {\r\n  private _nativeDb?: IModelJsNative.SQLiteDb;\r\n  private _sqliteStatementCache = new StatementCache<SqliteStatement>();\r\n\r\n  /** @internal */\r\n  public get nativeDb(): IModelJsNative.SQLiteDb {\r\n    return this._nativeDb!;\r\n  }\r\n\r\n  constructor() {\r\n    this._nativeDb = new IModelHost.platform.SQLiteDb();\r\n  }\r\n  /** Call this function when finished with this SQLiteDb. This releases the native resources */\r\n  public dispose(): void {\r\n    if (!this._nativeDb)\r\n      return;\r\n\r\n    this.closeDb();\r\n    this._nativeDb.dispose();\r\n    this._nativeDb = undefined;\r\n  }\r\n\r\n  /** Create a SQLiteDb\r\n   * @param pathName The path to the SQLiteDb file to create.\r\n   */\r\n  public createDb(pathName: string): void {\r\n    this.nativeDb.createDb(pathName);\r\n  }\r\n\r\n  /** Open a SQLiteDb.\r\n   * @param pathName The path to the SQLiteDb file to open\r\n   */\r\n  public openDb(pathName: string, openMode: OpenMode): void {\r\n    this.nativeDb.openDb(pathName, openMode);\r\n  }\r\n\r\n  /** Returns true if the SQLiteDb is open */\r\n  public get isOpen(): boolean { return this.nativeDb.isOpen(); }\r\n\r\n  /** Close SQLiteDb. */\r\n  public closeDb(): void {\r\n    this._sqliteStatementCache.clear();\r\n    this.nativeDb.closeDb();\r\n  }\r\n\r\n  /** Commit the outermost transaction, writing changes to the file. Then, restart the transaction. */\r\n  public saveChanges(): void {\r\n    this.nativeDb.saveChanges();\r\n  }\r\n\r\n  /** Abandon (cancel) the outermost transaction, discarding all changes since last save. Then, restart the transaction. */\r\n  public abandonChanges(): void {\r\n    this.nativeDb.abandonChanges();\r\n  }\r\n\r\n  /**\r\n     * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist\r\n     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved\r\n     * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be\r\n     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding\r\n     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].\r\n     * @param sql The SQLite SQL statement to execute\r\n     * @param callback the callback to invoke on the prepared statement\r\n     * @returns the value returned by `callback`.\r\n     * @see [[withPreparedStatement]]\r\n     * @public\r\n     */\r\n  public withPreparedSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T {\r\n    const stmt = this._sqliteStatementCache.findAndRemove(sql) ?? this.prepareSqliteStatement(sql);\r\n    const release = () => this._sqliteStatementCache.addOrDispose(stmt);\r\n    try {\r\n      const val: T = callback(stmt);\r\n      if (val instanceof Promise) {\r\n        val.then(release, release);\r\n      } else {\r\n        release();\r\n      }\r\n      return val;\r\n    } catch (err) {\r\n      release();\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n     * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.\r\n     * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.\r\n     * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].\r\n     * @param sql The SQLite SQL statement to execute\r\n     * @param callback the callback to invoke on the prepared statement\r\n     * @returns the value returned by `callback`.\r\n     * @public\r\n     */\r\n  public withSqliteStatement<T>(sql: string, callback: (stmt: SqliteStatement) => T): T {\r\n    const stmt = this.prepareSqliteStatement(sql);\r\n    const release = () => stmt.dispose();\r\n    try {\r\n      const val: T = callback(stmt);\r\n      if (val instanceof Promise) {\r\n        val.then(release, release);\r\n      } else {\r\n        release();\r\n      }\r\n      return val;\r\n    } catch (err) {\r\n      release();\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /** Prepare an SQL statement.\r\n     * @param sql The SQLite SQL statement to prepare\r\n     * @param logErrors Determine if errors are logged or not\r\n     * @internal\r\n     */\r\n  public prepareSqliteStatement(sql: string, logErrors = true): SqliteStatement {\r\n    const stmt = new SqliteStatement(sql);\r\n    stmt.prepare(this.nativeDb, logErrors);\r\n    return stmt;\r\n  }\r\n\r\n  /** execute an SQL statement */\r\n  public executeSQL(sql: string): DbResult {\r\n    const stmt = this.prepareSqliteStatement(sql);\r\n    try {\r\n      return stmt.step();\r\n    } finally {\r\n      stmt.dispose();\r\n    }\r\n  }\r\n}\r\n"]}

package/lib/cjs/Schema.d.ts

@@ -0,0 +1,56 @@
+/** @packageDocumentation
+ * @module Schema
+ */
+/** Base class for all schema classes - see [working with schemas and elements in TypeScript]($docs/learning/backend/SchemasAndElementsInTypeScript.md).
+ * @public
+ */
+export declare class Schema {
+    /** The name of the BIS schema handled by this Schema.
+     * @note Every subclass of Schema ** MUST ** override this method to identify its BIS schema.
+     * Failure to do so will ordinarily result in an error when the schema is registered, since there may only
+     * be one JavaScript class for a given BIS schema (usually the errant schema will collide with its superclass.)
+     */
+    static get schemaName(): string;
+    /** if true, this Schema is a proxy for a missing Domain marked with the `BisCore.SchemaHasBehavior` customAttribute.
+     * Classes generated for this Schema will disallow protected operations.
+     * @internal
+     */
+    static get missingRequiredBehavior(): boolean;
+    /** Get a semver-compatible string from a padded version string.
+     * works on unpadded version strings as well
+     * if there is no write version, it will be added
+     * @example Schema.toSemverString("1.02.03") === "1.2.3"
+     * @example Schema.toSemverString("1.01") === "1.0.1" // write version was added
+     * @beta
+     */
+    static toSemverString(paddedVersion: string): string;
+    /** Schemas may not be instantiated. The method is not private only because that precludes subclassing. It throws an
+     * error if it is ever called.
+     * @internal
+     */
+    protected constructor();
+}
+/** Manages registered schemas
+ * @public
+ */
+export declare class Schemas {
+    private static readonly _registeredSchemas;
+    private constructor();
+    /** Register a schema prior to using it.
+     * @throws [[IModelError]] if a schema of the same name is already registered.
+     */
+    static registerSchema(schema: typeof Schema): void;
+    /** Unregister a schema, by name, if one is already registered.
+     * This function is not normally needed, but is useful for cases where a generated *proxy* schema needs to be replaced by the *real* schema.
+     * @param schemaName Name of the schema to unregister
+     * @return true if the schema was unregistered
+     * @internal
+     */
+    static unregisterSchema(schemaName: string): boolean;
+    /** Look up a previously registered schema
+     * @param schemaName The name of the schema
+     * @returns the previously registered schema or undefined if not registered.
+     */
+    static getRegisteredSchema(schemaName: string): typeof Schema | undefined;
+}
+//# sourceMappingURL=Schema.d.ts.map

package/lib/cjs/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../../src/Schema.ts"],"names":[],"mappings":"AAIA;;GAEG;AAMH;;GAEG;AACH,qBAAa,MAAM;IACjB;;;;OAIG;IACH,WAAkB,UAAU,IAAI,MAAM,CAA4E;IAElH;;;OAGG;IACH,WAAkB,uBAAuB,IAAI,OAAO,CAAkB;IAEtE;;;;;;OAMG;WACW,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAQ3D;;;OAGG;IACH,SAAS;CACV;AAED;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAoC;IAC9E,OAAO;IAEP;;OAEG;WACW,cAAc,CAAC,MAAM,EAAE,OAAO,MAAM;IAOlD;;;;;OAKG;WACW,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQ3D;;;OAGG;WACW,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,MAAM,GAAG,SAAS;CACjF"}

package/lib/cjs/Schema.js

@@ -0,0 +1,84 @@
+"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 Schema
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schemas = exports.Schema = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+const ClassRegistry_1 = require("./ClassRegistry");
+/** Base class for all schema classes - see [working with schemas and elements in TypeScript]($docs/learning/backend/SchemasAndElementsInTypeScript.md).
+ * @public
+ */
+class Schema {
+    /** The name of the BIS schema handled by this Schema.
+     * @note Every subclass of Schema ** MUST ** override this method to identify its BIS schema.
+     * Failure to do so will ordinarily result in an error when the schema is registered, since there may only
+     * be one JavaScript class for a given BIS schema (usually the errant schema will collide with its superclass.)
+     */
+    static get schemaName() { throw new Error(`you must override static schemaName in ${this.name}`); }
+    /** if true, this Schema is a proxy for a missing Domain marked with the `BisCore.SchemaHasBehavior` customAttribute.
+     * Classes generated for this Schema will disallow protected operations.
+     * @internal
+     */
+    static get missingRequiredBehavior() { return false; }
+    /** Get a semver-compatible string from a padded version string.
+     * works on unpadded version strings as well
+     * if there is no write version, it will be added
+     * @example Schema.toSemverString("1.02.03") === "1.2.3"
+     * @example Schema.toSemverString("1.01") === "1.0.1" // write version was added
+     * @beta
+     */
+    static toSemverString(paddedVersion) {
+        const tuple = paddedVersion.split(".").map(Number);
+        const noWriteVersion = tuple.length === 2;
+        if (noWriteVersion)
+            tuple.splice(1, 0, 0); // insert 0 before the second element
+        return tuple.join(".");
+    }
+    /** Schemas may not be instantiated. The method is not private only because that precludes subclassing. It throws an
+     * error if it is ever called.
+     * @internal
+     */
+    constructor() { throw new Error(`cannot create an instance of a Schema ${this.constructor.name}`); }
+}
+exports.Schema = Schema;
+/** Manages registered schemas
+ * @public
+ */
+class Schemas {
+    constructor() { } // this is a singleton
+    /** Register a schema prior to using it.
+     * @throws [[IModelError]] if a schema of the same name is already registered.
+     */
+    static registerSchema(schema) {
+        const key = schema.schemaName.toLowerCase();
+        if (this.getRegisteredSchema(key))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.DuplicateName, `Schema "${schema.schemaName}" is already registered`);
+        this._registeredSchemas.set(key, schema);
+    }
+    /** Unregister a schema, by name, if one is already registered.
+     * This function is not normally needed, but is useful for cases where a generated *proxy* schema needs to be replaced by the *real* schema.
+     * @param schemaName Name of the schema to unregister
+     * @return true if the schema was unregistered
+     * @internal
+     */
+    static unregisterSchema(schemaName) {
+        const schema = this.getRegisteredSchema(schemaName);
+        if (undefined !== schema)
+            ClassRegistry_1.ClassRegistry.unregisterClassesFrom(schema);
+        return this._registeredSchemas.delete(schemaName.toLowerCase());
+    }
+    /** Look up a previously registered schema
+     * @param schemaName The name of the schema
+     * @returns the previously registered schema or undefined if not registered.
+     */
+    static getRegisteredSchema(schemaName) { return this._registeredSchemas.get(schemaName.toLowerCase()); }
+}
+exports.Schemas = Schemas;
+Schemas._registeredSchemas = new Map();
+//# sourceMappingURL=Schema.js.map

package/lib/cjs/Schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.js","sourceRoot":"","sources":["../../src/Schema.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAAmD;AACnD,oDAAiD;AACjD,mDAAgD;AAEhD;;GAEG;AACH,MAAa,MAAM;IACjB;;;;OAIG;IACI,MAAM,KAAK,UAAU,KAAa,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAElH;;;OAGG;IACI,MAAM,KAAK,uBAAuB,KAAc,OAAO,KAAK,CAAC,CAAC,CAAC;IAEtE;;;;;;OAMG;IACI,MAAM,CAAC,cAAc,CAAC,aAAqB;QAChD,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnD,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;QAC1C,IAAI,cAAc;YAChB,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,qCAAqC;QAC9D,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,gBAA0B,MAAM,IAAI,KAAK,CAAC,yCAAyC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CAC/G;AAlCD,wBAkCC;AAED;;GAEG;AACH,MAAa,OAAO;IAElB,gBAAwB,CAAC,CAAC,sBAAsB;IAEhD;;OAEG;IACI,MAAM,CAAC,cAAc,CAAC,MAAqB;QAChD,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;YAC/B,MAAM,IAAI,yBAAW,CAAC,2BAAY,CAAC,aAAa,EAAE,WAAW,MAAM,CAAC,UAAU,yBAAyB,CAAC,CAAC;QAC3G,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,gBAAgB,CAAC,UAAkB;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;QACpD,IAAI,SAAS,KAAK,MAAM;YACtB,6BAAa,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAE9C,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,mBAAmB,CAAC,UAAkB,IAA+B,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;;AAhCpJ,0BAiCC;AAhCyB,0BAAkB,GAAG,IAAI,GAAG,EAAyB,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Schema\r\n */\r\n\r\nimport { IModelStatus } from \"@itwin/core-bentley\";\r\nimport { IModelError } from \"@itwin/core-common\";\r\nimport { ClassRegistry } from \"./ClassRegistry\";\r\n\r\n/** Base class for all schema classes - see [working with schemas and elements in TypeScript]($docs/learning/backend/SchemasAndElementsInTypeScript.md).\r\n * @public\r\n */\r\nexport class Schema {\r\n  /** The name of the BIS schema handled by this Schema.\r\n   * @note Every subclass of Schema ** MUST ** override this method to identify its BIS schema.\r\n   * Failure to do so will ordinarily result in an error when the schema is registered, since there may only\r\n   * be one JavaScript class for a given BIS schema (usually the errant schema will collide with its superclass.)\r\n   */\r\n  public static get schemaName(): string { throw new Error(`you must override static schemaName in ${this.name}`); }\r\n\r\n  /** if true, this Schema is a proxy for a missing Domain marked with the `BisCore.SchemaHasBehavior` customAttribute.\r\n   * Classes generated for this Schema will disallow protected operations.\r\n   * @internal\r\n   */\r\n  public static get missingRequiredBehavior(): boolean { return false; }\r\n\r\n  /** Get a semver-compatible string from a padded version string.\r\n   * works on unpadded version strings as well\r\n   * if there is no write version, it will be added\r\n   * @example Schema.toSemverString(\"1.02.03\") === \"1.2.3\"\r\n   * @example Schema.toSemverString(\"1.01\") === \"1.0.1\" // write version was added\r\n   * @beta\r\n   */\r\n  public static toSemverString(paddedVersion: string): string {\r\n    const tuple = paddedVersion.split(\".\").map(Number);\r\n    const noWriteVersion = tuple.length === 2;\r\n    if (noWriteVersion)\r\n      tuple.splice(1, 0, 0); // insert 0 before the second element\r\n    return tuple.join(\".\");\r\n  }\r\n\r\n  /** Schemas may not be instantiated. The method is not private only because that precludes subclassing. It throws an\r\n   * error if it is ever called.\r\n   * @internal\r\n   */\r\n  protected constructor() { throw new Error(`cannot create an instance of a Schema ${this.constructor.name}`); }\r\n}\r\n\r\n/** Manages registered schemas\r\n * @public\r\n */\r\nexport class Schemas {\r\n  private static readonly _registeredSchemas = new Map<string, typeof Schema>();\r\n  private constructor() { } // this is a singleton\r\n\r\n  /** Register a schema prior to using it.\r\n   * @throws [[IModelError]] if a schema of the same name is already registered.\r\n   */\r\n  public static registerSchema(schema: typeof Schema) {\r\n    const key = schema.schemaName.toLowerCase();\r\n    if (this.getRegisteredSchema(key))\r\n      throw new IModelError(IModelStatus.DuplicateName, `Schema \"${schema.schemaName}\" is already registered`);\r\n    this._registeredSchemas.set(key, schema);\r\n  }\r\n\r\n  /** Unregister a schema, by name, if one is already registered.\r\n   * This function is not normally needed, but is useful for cases where a generated *proxy* schema needs to be replaced by the *real* schema.\r\n   * @param schemaName Name of the schema to unregister\r\n   * @return true if the schema was unregistered\r\n   * @internal\r\n   */\r\n  public static unregisterSchema(schemaName: string): boolean {\r\n    const schema = this.getRegisteredSchema(schemaName);\r\n    if (undefined !== schema)\r\n      ClassRegistry.unregisterClassesFrom(schema);\r\n\r\n    return this._registeredSchemas.delete(schemaName.toLowerCase());\r\n  }\r\n\r\n  /** Look up a previously registered schema\r\n   * @param schemaName The name of the schema\r\n   * @returns the previously registered schema or undefined if not registered.\r\n   */\r\n  public static getRegisteredSchema(schemaName: string): typeof Schema | undefined { return this._registeredSchemas.get(schemaName.toLowerCase()); }\r\n}\r\n"]}

package/lib/cjs/ServerBasedLocks.d.ts

@@ -0,0 +1,64 @@
+/** @packageDocumentation
+ * @module iModels
+ */
+import { Id64Arg, Id64String } from "@itwin/core-bentley";
+import { LockState } from "./BackendHubAccess";
+import { BriefcaseDb, LockControl } from "./IModelDb";
+import { SQLiteDb } from "./SQLiteDb";
+/**
+ * Both the Model and Parent of an element are considered "owners" of their member elements. That means:
+ * 1) they must hold at least a shared lock before an exclusive lock can be acquired for their members
+ * 2) if they hold an exclusive lock, then all of their members are exclusively locked implicitly.
+ * @internal
+ */
+export interface ElementOwners {
+    readonly modelId: Id64String;
+    readonly parentId: Id64String | undefined;
+}
+/** @internal */
+export declare class ServerBasedLocks implements LockControl {
+    get isServerBased(): boolean;
+    protected readonly lockDb: SQLiteDb;
+    protected readonly briefcase: BriefcaseDb;
+    constructor(iModel: BriefcaseDb);
+    close(): void;
+    private getOwners;
+    private getLockState;
+    /** Clear the cache of locally held locks.
+     * Note: does *not* release locks from server.
+     */
+    private clearAllLocks;
+    /** only for tests */
+    getLockCount(state: LockState): number;
+    releaseAllLocks(): Promise<void>;
+    private insertLock;
+    private ownerHoldsExclusiveLock;
+    /** Determine whether an the exclusive lock is already held by an element (or one of its owners) */
+    holdsExclusiveLock(id: Id64String): boolean;
+    holdsSharedLock(id: Id64String): boolean;
+    /** if the shared lock on the element supplied is not already held, add it to the set of shared locks required. Then, check owners. */
+    private addSharedLock;
+    /** add owners (recursively) of an element to a list of required shared locks, if not already held. */
+    private addOwnerSharedLocks;
+    /** attempt to acquire all necessary locks for a set of elements */
+    private acquireAllLocks;
+    /**
+     * Acquire the exclusive lock on one or more elements. This also attempts to acquire a shared lock on all of the element's owners, recursively.
+     * If *any* lock cannot be obtained, no locks are acquired.
+     */
+    acquireExclusiveLock(ids: Id64Arg): Promise<void>;
+    /**
+     * Acquire a shared lock on one or more elements. This also attempts to acquire a shared lock on all of the element's owners, recursively.
+     * If *any* lock cannot be obtained, no locks are acquired.
+     */
+    acquireSharedLock(ids: Id64Arg): Promise<void>;
+    /** When an element is newly created in a session, we hold the lock on it implicitly. Save that fact. */
+    elementWasCreated(id: Id64String): void;
+    /** locks are not necessary during change propagation. */
+    private get _locksAreRequired();
+    /** throw if locks are currently required and the exclusive lock is not held on the supplied element */
+    checkExclusiveLock(id: Id64String, type: string, operation: string): void;
+    /** throw if locks are currently required and a shared lock is not held on the supplied element */
+    checkSharedLock(id: Id64String, type: string, operation: string): void;
+}
+//# sourceMappingURL=ServerBasedLocks.d.ts.map

package/lib/cjs/ServerBasedLocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerBasedLocks.d.ts","sourceRoot":"","sources":["../../src/ServerBasedLocks.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH,OAAO,EAAkB,OAAO,EAAE,UAAU,EAA0B,MAAM,qBAAqB,CAAC;AAElG,OAAO,EAAW,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,SAAS,CAAC;CAC3C;AASD,gBAAgB;AAChB,qBAAa,gBAAiB,YAAW,WAAW;IAClD,IAAW,aAAa,YAAmB;IAC3C,SAAS,CAAC,QAAQ,CAAC,MAAM,WAAkB;IAC3C,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;gBAEvB,MAAM,EAAE,WAAW;IAY/B,KAAK;IAKZ,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAKrB,qBAAqB;IACd,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IAQhC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAK7C,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,uBAAuB;IAgB/B,mGAAmG;IAC5F,kBAAkB,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO;IAK3C,eAAe,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO;IAM/C,sIAAsI;IACtI,OAAO,CAAC,aAAa;IAUrB,sGAAsG;IACtG,OAAO,CAAC,mBAAmB;IAM3B,mEAAmE;YACrD,eAAe;IAmB7B;;;OAGG;IACU,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAS9D;;;OAGG;IACU,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAS3D,wGAAwG;IACjG,iBAAiB,CAAC,EAAE,EAAE,UAAU;IAKvC,yDAAyD;IACzD,OAAO,KAAK,iBAAiB,GAAqD;IAElF,uGAAuG;IAChG,kBAAkB,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKzE,kGAAkG;IAC3F,eAAe,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAKvE"}

package/lib/cjs/ServerBasedLocks.js

@@ -0,0 +1,177 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerBasedLocks = void 0;
+/** @packageDocumentation
+ * @module iModels
+ */
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+const BackendHubAccess_1 = require("./BackendHubAccess");
+const IModelHost_1 = require("./IModelHost");
+const SQLiteDb_1 = require("./SQLiteDb");
+/** @internal */
+class ServerBasedLocks {
+    constructor(iModel) {
+        this.lockDb = new SQLiteDb_1.SQLiteDb();
+        this.briefcase = iModel;
+        const dbName = `${iModel.nativeDb.getTempFileBaseName()}-locks`;
+        try {
+            this.lockDb.openDb(dbName, core_bentley_1.OpenMode.ReadWrite);
+        }
+        catch (_e) {
+            this.lockDb.createDb(dbName);
+            this.lockDb.executeSQL("CREATE TABLE locks(id INTEGER PRIMARY KEY NOT NULL,state INTEGER NOT NULL,origin INTEGER)");
+            this.lockDb.saveChanges();
+        }
+    }
+    get isServerBased() { return true; }
+    close() {
+        if (this.lockDb.isOpen)
+            this.lockDb.closeDb();
+    }
+    getOwners(id) {
+        return this.briefcase.withPreparedSqliteStatement("SELECT ModelId,ParentId FROM bis_Element WHERE id=?", (stmt) => {
+            stmt.bindId(1, id);
+            const rc = stmt.step();
+            if (core_bentley_1.DbResult.BE_SQLITE_ROW !== rc)
+                throw new core_common_1.IModelError(rc, `element ${id} not found`);
+            return { modelId: stmt.getValueId(0), parentId: stmt.getValueId(1) };
+        });
+    }
+    getLockState(id) {
+        return (id === undefined || !core_bentley_1.Id64.isValid(id)) ? undefined : this.lockDb.withPreparedSqliteStatement("SELECT state FROM locks WHERE id=?", (stmt) => {
+            stmt.bindId(1, id);
+            return (core_bentley_1.DbResult.BE_SQLITE_ROW === stmt.step()) ? stmt.getValueInteger(0) : undefined;
+        });
+    }
+    /** Clear the cache of locally held locks.
+     * Note: does *not* release locks from server.
+     */
+    clearAllLocks() {
+        this.lockDb.executeSQL("DELETE FROM locks");
+        this.lockDb.saveChanges();
+    }
+    /** only for tests */
+    getLockCount(state) {
+        return this.lockDb.withSqliteStatement("SELECT count(*) FROM locks WHERE state=?", (stmt) => {
+            stmt.bindInteger(1, state);
+            stmt.step();
+            return stmt.getValueInteger(0);
+        });
+    }
+    async releaseAllLocks() {
+        await IModelHost_1.IModelHost.hubAccess.releaseAllLocks(this.briefcase); // throws if unsuccessful
+        this.clearAllLocks();
+    }
+    insertLock(id, state, origin) {
+        this.lockDb.withPreparedSqliteStatement("INSERT INTO locks(id,state,origin) VALUES (?,?,?) ON CONFLICT(id) DO UPDATE SET state=excluded.state,origin=excluded.origin", (stmt) => {
+            stmt.bindId(1, id);
+            stmt.bindInteger(2, state);
+            stmt.bindInteger(3, origin);
+            const rc = stmt.step();
+            if (core_bentley_1.DbResult.BE_SQLITE_DONE !== rc)
+                throw new core_common_1.IModelError(rc, "can't insert lock into database");
+        });
+        return true;
+    }
+    ownerHoldsExclusiveLock(id) {
+        if (id === undefined || id === core_common_1.IModel.rootSubjectId)
+            return false; // has no owners
+        const { modelId, parentId } = this.getOwners(id);
+        if (this.getLockState(modelId) === BackendHubAccess_1.LockState.Exclusive || this.getLockState(parentId) === BackendHubAccess_1.LockState.Exclusive)
+            return true;
+        // see if this model is exclusively locked by one of its owners. If so, save that fact on modelId so future tests won't have to descend.
+        if (this.ownerHoldsExclusiveLock(modelId))
+            return this.insertLock(modelId, BackendHubAccess_1.LockState.Exclusive, 2 /* Discovered */);
+        // see if the parent is exclusively locked by one of its owners. If so, save that fact on parentId so future tests won't have to descend.
+        return this.ownerHoldsExclusiveLock(parentId) ? this.insertLock(parentId, BackendHubAccess_1.LockState.Exclusive, 2 /* Discovered */) : false;
+    }
+    /** Determine whether an the exclusive lock is already held by an element (or one of its owners) */
+    holdsExclusiveLock(id) {
+        // see if we hold the exclusive lock. or if one of the element's owners is exclusively locked (recursively)
+        return this.getLockState(id) === BackendHubAccess_1.LockState.Exclusive || this.ownerHoldsExclusiveLock(id);
+    }
+    holdsSharedLock(id) {
+        const state = this.getLockState(id);
+        // see if we hold shared or exclusive lock, or if an owner has exclusive lock. If so we implicitly have shared lock, but owner holding shared lock doesn't help.
+        return (state === BackendHubAccess_1.LockState.Shared || state === BackendHubAccess_1.LockState.Exclusive) || this.ownerHoldsExclusiveLock(id);
+    }
+    /** if the shared lock on the element supplied is not already held, add it to the set of shared locks required. Then, check owners. */
+    addSharedLock(id, locks) {
+        // if the id is not valid, or of the lock is already in the set, or if we already hold a shared lock, we're done
+        // Note: if we hold a shared lock, it is guaranteed that we also hold all required shared locks on owners.
+        if (id === undefined || !core_bentley_1.Id64.isValid(id) || locks.has(id) || this.holdsSharedLock(id))
+            return;
+        locks.add(id); // add to set of needed shared locks
+        this.addOwnerSharedLocks(id, locks); // check parent models and groups
+    }
+    /** add owners (recursively) of an element to a list of required shared locks, if not already held. */
+    addOwnerSharedLocks(id, locks) {
+        const el = this.getOwners(id);
+        this.addSharedLock(el.parentId, locks); // if this element is in a group
+        this.addSharedLock(el.modelId, locks); // check its model
+    }
+    /** attempt to acquire all necessary locks for a set of elements */
+    async acquireAllLocks(locks) {
+        if (locks.size === 0) // no locks are required.
+            return;
+        const sharedLocks = new Set();
+        for (const lock of locks)
+            this.addOwnerSharedLocks(lock[0], sharedLocks);
+        for (const shared of sharedLocks) {
+            if (!locks.has(shared)) // we may already be asking for exclusive lock
+                locks.set(shared, BackendHubAccess_1.LockState.Shared);
+        }
+        await IModelHost_1.IModelHost.hubAccess.acquireLocks(this.briefcase, locks); // throws if unsuccessful
+        for (const lock of locks)
+            this.insertLock(lock[0], lock[1], 0 /* Acquired */);
+        this.lockDb.saveChanges();
+    }
+    /**
+     * Acquire the exclusive lock on one or more elements. This also attempts to acquire a shared lock on all of the element's owners, recursively.
+     * If *any* lock cannot be obtained, no locks are acquired.
+     */
+    async acquireExclusiveLock(ids) {
+        const locks = new Map();
+        for (const id of core_bentley_1.Id64.iterable(ids)) {
+            if (!this.holdsExclusiveLock(id))
+                locks.set(id, BackendHubAccess_1.LockState.Exclusive);
+        }
+        return this.acquireAllLocks(locks);
+    }
+    /**
+     * Acquire a shared lock on one or more elements. This also attempts to acquire a shared lock on all of the element's owners, recursively.
+     * If *any* lock cannot be obtained, no locks are acquired.
+     */
+    async acquireSharedLock(ids) {
+        const locks = new Map();
+        for (const id of core_bentley_1.Id64.iterable(ids)) {
+            if (!this.holdsSharedLock(id))
+                locks.set(id, BackendHubAccess_1.LockState.Shared);
+        }
+        return this.acquireAllLocks(locks);
+    }
+    /** When an element is newly created in a session, we hold the lock on it implicitly. Save that fact. */
+    elementWasCreated(id) {
+        this.insertLock(id, BackendHubAccess_1.LockState.Exclusive, 1 /* NewElement */);
+        this.lockDb.saveChanges();
+    }
+    /** locks are not necessary during change propagation. */
+    get _locksAreRequired() { return !this.briefcase.txns.isIndirectChanges; }
+    /** throw if locks are currently required and the exclusive lock is not held on the supplied element */
+    checkExclusiveLock(id, type, operation) {
+        if (this._locksAreRequired && !this.holdsExclusiveLock(id))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.LockNotHeld, `exclusive lock not held on ${type} for ${operation} (id=${id})`);
+    }
+    /** throw if locks are currently required and a shared lock is not held on the supplied element */
+    checkSharedLock(id, type, operation) {
+        if (this._locksAreRequired && !this.holdsSharedLock(id))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.LockNotHeld, `shared lock not held on ${type} for ${operation} (id=${id})`);
+    }
+}
+exports.ServerBasedLocks = ServerBasedLocks;
+//# sourceMappingURL=ServerBasedLocks.js.map