@itwin/core-backend 5.0.0-dev.11 → 5.0.0-dev.110

package/lib/cjs/CloudSqlite.js

@@ -8,15 +8,17 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloudSqlite = void 0;
+const semver = require("semver");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const imodeljs_native_1 = require("@bentley/imodeljs-native");
 const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
 const BlobContainerService_1 = require("./BlobContainerService");
 const IModelHost_1 = require("./IModelHost");
 const IModelJsFs_1 = require("./IModelJsFs");
 const tracing_1 = require("./rpc/tracing");
-// spell:ignore logmsg httpcode daemonless cachefile cacheslots ddthh
+// spell:ignore logmsg httpcode daemonless cachefile cacheslots ddthh cloudsqlite premajor preminor prepatch
 /**
  * Types for accessing SQLite databases stored in cloud containers.
  * @beta
@@ -25,6 +27,24 @@ var CloudSqlite;
 (function (CloudSqlite) {
     const logInfo = (msg) => core_bentley_1.Logger.logInfo("CloudSqlite", msg);
     const logError = (msg) => core_bentley_1.Logger.logError("CloudSqlite", msg);
+    /** Add (or replace) a property to an object that is not enumerable.
+     * This is important so this member will be skipped when the object is the target of
+     * [structuredClone](https://developer.mozilla.org/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+     * (e.g. when the object is part of an exception that is marshalled across process boundaries.)
+     */
+    function addHiddenProperty(o, p, value) {
+        return Object.defineProperty(o, p, { enumerable: false, writable: true, value });
+    }
+    CloudSqlite.addHiddenProperty = addHiddenProperty;
+    function verifyService(serviceName, service) {
+        if (undefined === service)
+            core_common_1.CloudSqliteError.throwError("service-not-available", { message: `${serviceName} service is not available` });
+        return service;
+    }
+    function getBlobService() {
+        return verifyService("BlobContainer", BlobContainerService_1.BlobContainer.service);
+    }
+    CloudSqlite.getBlobService = getBlobService;
     /**
      * Request a new AccessToken for a cloud container using the [[BlobContainer]] service.
      * If the service is unavailable or returns an error, an empty token is returned.
@@ -34,13 +54,21 @@ var CloudSqlite;
         let userToken = args.userToken ? args.userToken : await IModelHost_1.IModelHost.getAccessToken();
         if (userToken === "")
             userToken = tracing_1.RpcTrace.currentActivity?.accessToken ?? "";
-        if (BlobContainerService_1.BlobContainer.service === undefined) {
-            throw new Error(`BlobContainer.service is not defined`);
-        }
-        const response = await BlobContainerService_1.BlobContainer.service.requestToken({ ...args, userToken });
+        const response = await getBlobService().requestToken({ ...args, userToken });
         return response?.token ?? "";
     }
     CloudSqlite.requestToken = requestToken;
+    function noLeadingOrTrailingSpaces(name, msg) {
+        if (name.trim() !== name)
+            core_common_1.CloudSqliteError.throwError("invalid-name", { message: `${msg} [${name}] may not have leading or trailing spaces` });
+    }
+    CloudSqlite.noLeadingOrTrailingSpaces = noLeadingOrTrailingSpaces;
+    function validateDbName(dbName) {
+        if (dbName === "" || dbName.length > 255 || /[#\.<>:"/\\"`'|?*\u0000-\u001F]/g.test(dbName) || /^(con|prn|aux|nul|com\d|lpt\d)$/i.test(dbName))
+            core_common_1.CloudSqliteError.throwError("invalid-name", { message: "invalid dbName", dbName });
+        noLeadingOrTrailingSpaces(dbName, "dbName");
+    }
+    CloudSqlite.validateDbName = validateDbName;
     /**
      * Create a new CloudContainer from a ContainerAccessProps. For non-public containers, a valid accessToken must be provided before the container
      * can be used (e.g. via [[CloudSqlite.requestToken]]).
@@ -49,6 +77,10 @@ var CloudSqlite;
      */
     function createCloudContainer(args) {
         const container = new imodeljs_native_1.NativeLibrary.nativeLib.CloudContainer(args);
+        // we're going to add these fields to the newly created object. They should *not* be enumerable so they are not copied
+        // when the object is cloned (e.g. when included in an exception across processes).
+        addHiddenProperty(container, "timer");
+        addHiddenProperty(container, "refreshPromise");
         const refreshSeconds = (undefined !== args.tokenRefreshSeconds) ? args.tokenRefreshSeconds : 60 * 60; // default is 1 hour
         container.lockExpireSeconds = args.lockExpireSeconds ?? 60 * 60; // default is 1 hour
         // don't refresh tokens for public containers or if refreshSeconds<=0
@@ -74,13 +106,13 @@ var CloudSqlite;
                     tokenRefreshFn(); // schedule next refresh
                 }, refreshSeconds * 1000);
             };
-            container.onConnected = tokenRefreshFn; // schedule the first refresh when the container is connected
-            container.onDisconnect = () => {
+            addHiddenProperty(container, "onConnected", tokenRefreshFn); // schedule the first refresh when the container is connected
+            addHiddenProperty(container, "onDisconnect", () => {
                 if (container.timer !== undefined) {
                     clearTimeout(container.timer);
                     container.timer = undefined;
                 }
-            };
+            });
         }
         return container;
     }
@@ -90,6 +122,7 @@ var CloudSqlite;
         return new imodeljs_native_1.NativeLibrary.nativeLib.CloudPrefetch(container, dbName, args);
     }
     CloudSqlite.startCloudPrefetch = startCloudPrefetch;
+    ;
     /** Logging categories for `CloudCache.setLogMask` */
     let LoggingMask;
     (function (LoggingMask) {
@@ -212,50 +245,60 @@ var CloudSqlite;
         const container = args.container;
         while (true) {
             try {
-                if (container.hasWriteLock) {
-                    if (container.writeLockHeldBy === args.user) {
-                        return container.acquireWriteLock(args.user); // refresh the write lock's expiry time.
-                    }
-                    const err = new Error(); // lock held by another user within this process
-                    err.errorNumber = 5;
-                    err.lockedBy = container.writeLockHeldBy;
-                    err.expires = container.writeLockExpires;
-                    throw err;
-                }
-                return container.acquireWriteLock(args.user);
+                // if the write is already held:
+                // - by the same user, just update the write lock expiry (by calling acquireWriteLock).
+                // - by another user, throw an error
+                if (container.hasWriteLock && container.writeLockHeldBy !== args.user)
+                    core_common_1.CloudSqliteError.throwError("write-lock-held", {
+                        message: "lock in use", errorNumber: 5,
+                        lockedBy: container.writeLockHeldBy ?? "",
+                        expires: container.writeLockExpires
+                    });
+                container.acquireWriteLock(args.user);
+                container.writeLockHeldBy = args.user;
+                return;
             }
             catch (e) {
                 if (e.errorNumber === 5 && args.busyHandler && "stop" !== await args.busyHandler(e.lockedBy, e.expires)) // 5 === BE_SQLITE_BUSY
                     continue; // busy handler wants to try again
-                throw e;
+                core_common_1.CloudSqliteError.throwError("write-lock-held", { message: e.message, ...e });
             }
         }
     }
     CloudSqlite.acquireWriteLock = acquireWriteLock;
+    function getWriteLockHeldBy(container) {
+        return container.writeLockHeldBy;
+    }
+    CloudSqlite.getWriteLockHeldBy = getWriteLockHeldBy;
+    /** release the write lock on a container. */
+    function releaseWriteLock(container) {
+        container.releaseWriteLock();
+        container.writeLockHeldBy = undefined;
+    }
+    CloudSqlite.releaseWriteLock = releaseWriteLock;
     /**
-   * Perform an asynchronous write operation on a CloudContainer with the write lock held.
-   * 1. if write lock is already held by the current user, refresh write lock's expiry time, call operation and return.
-   * 2. attempt to acquire the write lock, with retries. Throw if unable to obtain write lock.
-   * 3. perform the operation
-   * 3.a if the operation throws, abandon all changes and re-throw
-   * 4. release the write lock.
-   * 5. return value from operation
-   * @param user the name to be displayed to other users in the event they attempt to obtain the lock while it is held by us
-   * @param container the CloudContainer for which the lock is to be acquired
-   * @param operation an asynchronous operation performed with the write lock held.
-   * @param busyHandler if present, function called when the write lock is currently held by another user.
-   * @returns a Promise with the result of `operation`
-   */
+    * Perform an asynchronous write operation on a CloudContainer with the write lock held.
+    * 1. if write lock is already held by the current user, refresh write lock's expiry time, call operation and return.
+    * 2. attempt to acquire the write lock, with retries. Throw if unable to obtain write lock.
+    * 3. perform the operation
+    * 3.a if the operation throws, abandon all changes and re-throw
+    * 4. release the write lock.
+    * 5. return value from operation
+    * @param user the name to be displayed to other users in the event they attempt to obtain the lock while it is held by us
+    * @param container the CloudContainer for which the lock is to be acquired
+    * @param operation an asynchronous operation performed with the write lock held.
+    * @param busyHandler if present, function called when the write lock is currently held by another user.
+    * @returns a Promise with the result of `operation`
+    */
     async function withWriteLock(args, operation) {
-        await acquireWriteLock(args);
         const containerInternal = args.container;
+        const wasLockedBy = containerInternal.writeLockHeldBy;
+        await acquireWriteLock(args);
         try {
-            if (containerInternal.writeLockHeldBy === args.user) // If the user already had the write lock, then don't release it.
+            if (wasLockedBy === args.user) // If the user already had the write lock, then don't release it.
                 return await operation();
-            containerInternal.writeLockHeldBy = args.user;
             const val = await operation(); // wait for work to finish or fail
-            containerInternal.releaseWriteLock();
-            containerInternal.writeLockHeldBy = undefined;
+            releaseWriteLock(containerInternal);
             return val;
         }
         catch (e) {
@@ -265,8 +308,82 @@ var CloudSqlite;
         }
     }
     CloudSqlite.withWriteLock = withWriteLock;
+    /**
+     * Parse the name of a Db stored in a CloudContainer into the dbName and version number. A single CloudContainer may hold
+     * many versions of the same Db. The name of the Db in the CloudContainer is in the format "name:version". This
+     * function splits them into separate strings.
+     */
+    function parseDbFileName(dbFileName) {
+        const parts = dbFileName.split(":");
+        return { dbName: parts[0], version: parts[1] ?? "" };
+    }
+    CloudSqlite.parseDbFileName = parseDbFileName;
+    function validateDbVersion(version) {
+        version = version ?? "0.0.0";
+        const opts = { loose: true, includePrerelease: true };
+        // clean allows prerelease, so try it first. If that fails attempt to coerce it (coerce strips prerelease even if you say not to.)
+        const semVersion = semver.clean(version, opts) ?? semver.coerce(version, opts)?.version;
+        if (!semVersion)
+            core_common_1.CloudSqliteError.throwError("invalid-name", { message: "invalid version specification" });
+        version = semVersion;
+        return version;
+    }
+    CloudSqlite.validateDbVersion = validateDbVersion;
+    function isSemverPrerelease(version) {
+        return semver.major(version) === 0 || semver.prerelease(version);
+    }
+    CloudSqlite.isSemverPrerelease = isSemverPrerelease;
+    function isSemverEditable(dbFullName, container) {
+        return isSemverPrerelease(parseDbFileName(dbFullName).version) || container.queryDatabase(dbFullName)?.state === "copied";
+    }
+    CloudSqlite.isSemverEditable = isSemverEditable;
+    /** Create a dbName for a database from its base name and version. This will be in the format "name:version" */
+    function makeSemverName(dbName, version) {
+        return `${dbName}:${validateDbVersion(version)}`;
+    }
+    CloudSqlite.makeSemverName = makeSemverName;
+    /** query the databases in the supplied container for the highest SemVer match according to the version range. Throws if no version available for the range. */
+    function querySemverMatch(props) {
+        const dbName = props.dbName;
+        const dbs = props.container.queryDatabases(`${dbName}*`); // get all databases that start with dbName
+        const versions = [];
+        for (const db of dbs) {
+            const thisDb = parseDbFileName(db);
+            if (thisDb.dbName === dbName && "string" === typeof thisDb.version && thisDb.version.length > 0)
+                versions.push(thisDb.version);
+        }
+        if (versions.length === 0)
+            versions[0] = "0.0.0";
+        const range = props.version ?? "*";
+        try {
+            const version = semver.maxSatisfying(versions, range, { loose: true, includePrerelease: props.includePrerelease });
+            if (version)
+                return `${dbName}:${version}`;
+        }
+        catch { }
+        core_common_1.CloudSqliteError.throwError("no-version-available", { message: `No version of '${dbName}' available for "${range}"`, ...props });
+    }
+    CloudSqlite.querySemverMatch = querySemverMatch;
+    async function createNewDbVersion(container, args) {
+        const oldFullName = CloudSqlite.querySemverMatch({ container, ...args.fromDb });
+        const oldDb = CloudSqlite.parseDbFileName(oldFullName);
+        const newVersion = semver.inc(oldDb.version, args.versionType, args.identifier);
+        if (!newVersion)
+            core_common_1.CloudSqliteError.throwError("invalid-name", { message: `cannot create new version for ${oldFullName}`, dbName: oldFullName, ...args });
+        const newName = makeSemverName(oldDb.dbName, newVersion);
+        try {
+            await container.copyDatabase(oldFullName, newName);
+        }
+        catch (e) {
+            core_common_1.CloudSqliteError.throwError("copy-error", { message: `Error attempting to create new version ${newName} from ${oldFullName}`, ...args, cause: e });
+        }
+        // return the old and new db names and versions
+        return { oldDb, newDb: { dbName: oldDb.dbName, version: newVersion } };
+    }
+    CloudSqlite.createNewDbVersion = createNewDbVersion;
     /** The collection of currently extant `CloudCache`s, by name. */
     class CloudCaches {
+        static cloudCaches = new Map();
         /** create a new CloudCache */
         static makeCache(args) {
             const cacheName = args.cacheName;
@@ -301,15 +418,28 @@ var CloudSqlite;
             return this.cloudCaches.get(args.cacheName) ?? this.makeCache(args);
         }
     }
-    CloudCaches.cloudCaches = new Map();
     CloudSqlite.CloudCaches = CloudCaches;
     /** Class that provides convenient local access to a SQLite database in a CloudContainer.  */
     class DbAccess {
+        /** The name of the database within the cloud container. */
+        dbName;
+        /** Parameters for obtaining the write lock for this container.  */
+        lockParams = {
+            user: "",
+            nRetries: 20,
+            retryDelayMs: 100,
+        };
+        static _cacheName = "default-64k";
+        _container;
+        _cloudDb;
+        _writeLockProxy;
+        _readerProxy;
         get _ctor() { return this.constructor; }
         /** @internal */
         static getCacheForClass() {
             return CloudCaches.getCache({ cacheName: this._cacheName });
         }
+        _cache;
         /** only for tests
          * @internal
          */
@@ -343,12 +473,6 @@ var CloudSqlite;
         }
         /** Create a new DbAccess for a database stored in a cloud container. */
         constructor(args) {
-            /** Parameters for obtaining the write lock for this container.  */
-            this.lockParams = {
-                user: "",
-                nRetries: 20,
-                retryDelayMs: 100,
-            };
             this._container = createCloudContainer({ writeable: true, ...args.props });
             this._cloudDb = new args.dbType(args.props);
             this.dbName = args.dbName;
@@ -387,14 +511,9 @@ var CloudSqlite;
          * @note the current user must have administrator rights to create containers.
          */
         static async createBlobContainer(args) {
-            const service = BlobContainerService_1.BlobContainer.service;
-            if (undefined === service)
-                throw new Error("no BlobContainer service available");
-            const auth = IModelHost_1.IModelHost.authorizationClient;
-            if (undefined === auth)
-                throw new Error("no authorization client available");
+            const auth = verifyService("Authorization Client", IModelHost_1.IModelHost.authorizationClient);
             const userToken = await auth.getAccessToken();
-            const cloudContainer = await service.create({ scope: args.scope, metadata: args.metadata, userToken });
+            const cloudContainer = await getBlobService().create({ scope: args.scope, metadata: args.metadata, userToken });
             return { baseUri: cloudContainer.baseUri, containerId: cloudContainer.containerId, storageType: cloudContainer.provider };
         }
         /**
@@ -464,7 +583,7 @@ var CloudSqlite;
         getDbMethod(methodName) {
             const fn = this._cloudDb[methodName];
             if (typeof fn !== "function")
-                throw new Error(`illegal method name ${methodName}`);
+                core_common_1.CloudSqliteError.throwError("not-a-function", { message: `illegal method name ${methodName}`, dbName: this.dbName });
             return fn;
         }
         /**
@@ -501,7 +620,6 @@ var CloudSqlite;
             });
         }
     }
-    DbAccess._cacheName = "default-64k";
     CloudSqlite.DbAccess = DbAccess;
 })(CloudSqlite || (exports.CloudSqlite = CloudSqlite = {}));
 //# sourceMappingURL=CloudSqlite.js.map