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

package/lib/cjs/internal/workspace/WorkspaceImpl.js

@@ -6,23 +6,16 @@
 /** @packageDocumentation
  * @module Workspace
  */
-var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workspaceManifestProperty = exports.workspaceDbFileExt = void 0;
 exports.constructWorkspaceDb = constructWorkspaceDb;
 exports.constructWorkspace = constructWorkspace;
 exports.constructWorkspaceEditor = constructWorkspaceEditor;
-exports.noLeadingOrTrailingSpaces = noLeadingOrTrailingSpaces;
-exports.validateWorkspaceDbName = validateWorkspaceDbName;
 exports.validateWorkspaceContainerId = validateWorkspaceContainerId;
-exports.validateWorkspaceDbVersion = validateWorkspaceDbVersion;
-exports.parseWorkspaceDbFileName = parseWorkspaceDbFileName;
-exports.makeWorkspaceDbFileName = makeWorkspaceDbFileName;
 exports.throwWorkspaceDbLoadErrors = throwWorkspaceDbLoadErrors;
 const crypto_1 = require("crypto");
 const fs = require("fs-extra");
 const path_1 = require("path");
-const semver = require("semver");
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_common_1 = require("@itwin/core-common");
 const CloudSqlite_1 = require("../../CloudSqlite");
@@ -43,7 +36,7 @@ exports.workspaceDbFileExt = "itwin-workspace";
 function makeWorkspaceCloudCache(arg) {
     const cache = CloudSqlite_1.CloudSqlite.CloudCaches.getCache(arg);
     if (undefined === cache.workspaceContainers) // if we just created this container, add the map.
-        cache.workspaceContainers = new Map();
+        CloudSqlite_1.CloudSqlite.addHiddenProperty(cache, "workspaceContainers", new Map());
     return cache;
 }
 function getContainerFullId(props) {
@@ -57,30 +50,35 @@ function getWorkspaceCloudContainer(props, cache) {
     cloudContainer = CloudSqlite_1.CloudSqlite.createCloudContainer(props);
     cache.workspaceContainers.set(id, cloudContainer);
     cloudContainer.connectCount = 0;
-    cloudContainer.sharedConnect = function () {
+    CloudSqlite_1.CloudSqlite.addHiddenProperty(cloudContainer, "sharedConnect", function () {
         if (this.connectCount++ === 0) {
             this.connect(cache);
             return true;
         }
         return false;
-    };
-    cloudContainer.sharedDisconnect = function () {
+    });
+    CloudSqlite_1.CloudSqlite.addHiddenProperty(cloudContainer, "sharedDisconnect", function () {
         if (--this.connectCount <= 0) {
             this.disconnect();
             cache.workspaceContainers.delete(id);
             this.connectCount = 0;
         }
-    };
+    });
     return cloudContainer;
 }
 class WorkspaceContainerImpl {
+    [Symbols_1._implementationProhibited] = undefined;
+    workspace;
+    filesDir;
+    id;
+    fromProps;
+    _cloudContainer;
     get cloudContainer() {
         return this._cloudContainer;
     }
+    _wsDbs = new Map();
     get dirName() { return (0, path_1.join)(this.workspace.containerDir, this.id); }
     constructor(workspace, props) {
-        this[_a] = undefined;
-        this._wsDbs = new Map();
         validateWorkspaceContainerId(props.containerId);
         this.workspace = workspace;
         this.id = props.containerId;
@@ -103,31 +101,14 @@ class WorkspaceContainerImpl {
         }
     }
     resolveDbFileName(props) {
-        const cloudContainer = this.cloudContainer;
-        if (undefined === cloudContainer)
+        const container = this.cloudContainer;
+        if (undefined === container)
             return (0, path_1.join)(this.dirName, `${props.dbName}.${exports.workspaceDbFileExt}`); // local file, versions not allowed
-        const dbName = workspaceDbNameWithDefault(props.dbName);
-        const dbs = cloudContainer.queryDatabases(`${dbName}*`); // get all databases that start with dbName
-        const versions = [];
-        for (const db of dbs) {
-            const thisDb = parseWorkspaceDbFileName(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 { }
-        throwWorkspaceDbLoadError(`No version of '${dbName}' available for "${range}"`, props);
+        return CloudSqlite_1.CloudSqlite.querySemverMatch({ ...props, container, dbName: workspaceDbNameWithDefault(props.dbName) });
     }
     addWorkspaceDb(toAdd) {
         if (undefined !== this._wsDbs.get(toAdd.dbName))
-            throw new Error(`workspaceDb '${toAdd.dbName}' already exists in workspace`);
+            core_common_1.WorkspaceError.throwError("already-exists", { message: `workspaceDb '${toAdd.dbName}' already exists in workspace` });
         this._wsDbs.set(toAdd.dbName, toAdd);
     }
     getWorkspaceDb(props) {
@@ -148,9 +129,15 @@ class WorkspaceContainerImpl {
         this.cloudContainer?.sharedDisconnect();
     }
 }
-_a = Symbols_1._implementationProhibited;
 /** Implementation of WorkspaceDb */
 class WorkspaceDbImpl {
+    [Symbols_1._implementationProhibited] = undefined;
+    sqliteDb = new WorkspaceSqliteDb_1.WorkspaceSqliteDb();
+    dbName;
+    _container;
+    onClose = new core_bentley_1.BeEvent();
+    dbFileName;
+    _manifest;
     /** true if this WorkspaceDb is currently open */
     get isOpen() { return this.sqliteDb.isOpen; }
     get container() { return this._container; }
@@ -165,11 +152,8 @@ class WorkspaceDbImpl {
         return { localFileName, info };
     }
     constructor(props, container) {
-        this[_b] = undefined;
-        this.sqliteDb = new WorkspaceSqliteDb_1.WorkspaceSqliteDb();
-        this.onClose = new core_bentley_1.BeEvent();
         this.dbName = workspaceDbNameWithDefault(props.dbName);
-        validateWorkspaceDbName(this.dbName);
+        CloudSqlite_1.CloudSqlite.validateDbName(this.dbName);
         this._container = container;
         this.dbFileName = container.resolveDbFileName(props);
         container.addWorkspaceDb(this);
@@ -190,7 +174,7 @@ class WorkspaceDbImpl {
         const cloudContainer = this.container.cloudContainer;
         if (undefined === cloudContainer)
             return "1.0.0"; // local file, no versioning. return default
-        return parseWorkspaceDbFileName(this.dbFileName).version;
+        return CloudSqlite_1.CloudSqlite.parseDbFileName(this.dbFileName).version;
     }
     get manifest() {
         return this._manifest ??= this.withOpenDb((db) => {
@@ -257,7 +241,7 @@ class WorkspaceDbImpl {
     prefetch(opts) {
         const cloudContainer = this._container.cloudContainer;
         if (cloudContainer === undefined)
-            throw new Error("no cloud container to prefetch");
+            core_common_1.WorkspaceError.throwError("no-cloud-container", { message: "no cloud container to prefetch" });
         return CloudSqlite_1.CloudSqlite.startCloudPrefetch(cloudContainer, this.dbFileName, opts);
     }
     queryResources(args) {
@@ -278,15 +262,17 @@ class WorkspaceDbImpl {
         });
     }
 }
-_b = Symbols_1._implementationProhibited;
 /** Implementation of Workspace */
 class WorkspaceImpl {
+    [Symbols_1._implementationProhibited] = undefined;
+    _containers = new Map();
+    containerDir;
+    settings;
+    _cloudCache;
     getCloudCache() {
         return this._cloudCache ??= makeWorkspaceCloudCache({ cacheName: "Workspace", cacheSize: "20G" });
     }
     constructor(settings, opts) {
-        this[_c] = undefined;
-        this._containers = new Map();
         this.settings = settings;
         this.containerDir = opts?.containerDir ?? (0, path_1.join)(IModelHost_1.IModelHost.cacheDir, "Workspace");
         let settingsFiles = opts?.settingsFiles;
@@ -298,7 +284,7 @@ class WorkspaceImpl {
     }
     addContainer(toAdd) {
         if (undefined !== this._containers.get(toAdd.id))
-            throw new Error("container already exists in workspace");
+            core_common_1.WorkspaceError.throwError("container-exists", { message: `container ${toAdd.id} already exists in workspace` });
         this._containers.set(toAdd.id, toAdd);
     }
     findContainer(containerId) {
@@ -401,7 +387,6 @@ class WorkspaceImpl {
         return result;
     }
 }
-_c = Symbols_1._implementationProhibited;
 const workspaceEditorName = "WorkspaceEditor"; // name of the cache for the editor workspace
 class EditorWorkspaceImpl extends WorkspaceImpl {
     getCloudCache() {
@@ -409,20 +394,18 @@ class EditorWorkspaceImpl extends WorkspaceImpl {
     }
 }
 class EditorImpl {
-    constructor() {
-        this[_d] = undefined;
-        this.workspace = new EditorWorkspaceImpl(new SettingsImpl_1.SettingsImpl(), { containerDir: (0, path_1.join)(IModelHost_1.IModelHost.cacheDir, workspaceEditorName) });
-    }
+    [Symbols_1._implementationProhibited] = undefined;
+    workspace = new EditorWorkspaceImpl(new SettingsImpl_1.SettingsImpl(), { containerDir: (0, path_1.join)(IModelHost_1.IModelHost.cacheDir, workspaceEditorName) });
     async initializeContainer(args) {
         class CloudAccess extends CloudSqlite_1.CloudSqlite.DbAccess {
+            static _cacheName = workspaceEditorName;
             static async initializeWorkspace(args) {
                 const props = await this.createBlobContainer({ scope: args.scope, metadata: { ...args.metadata, containerType: "workspace" } });
-                const dbFullName = makeWorkspaceDbFileName(workspaceDbNameWithDefault(args.dbName), "0.0.0");
+                const dbFullName = CloudSqlite_1.CloudSqlite.makeSemverName(workspaceDbNameWithDefault(args.dbName), "0.0.0");
                 await super._initializeDb({ ...args, props, dbName: dbFullName, dbType: WorkspaceSqliteDb_1.WorkspaceSqliteDb, blockSize: "4M" });
                 return props;
             }
         }
-        CloudAccess._cacheName = workspaceEditorName;
         return CloudAccess.initializeWorkspace(args);
     }
     async createNewCloudContainer(args) {
@@ -442,7 +425,6 @@ class EditorImpl {
         this.workspace.close();
     }
 }
-_d = Symbols_1._implementationProhibited;
 class EditorContainerImpl extends WorkspaceContainerImpl {
     get cloudContainer() {
         return super.cloudContainer;
@@ -459,28 +441,20 @@ class EditorContainerImpl extends WorkspaceContainerImpl {
         };
     }
     async createNewWorkspaceDbVersion(args) {
-        const cloudContainer = this.cloudContainer;
-        if (undefined === cloudContainer)
-            throw new Error("versions require cloud containers");
-        const oldName = this.resolveDbFileName(args.fromProps ?? {});
-        const oldDb = parseWorkspaceDbFileName(oldName);
-        const newVersion = semver.inc(oldDb.version, args.versionType, args.identifier);
-        if (!newVersion)
-            throwWorkspaceDbLoadError("invalid version", args.fromProps ?? {});
-        const newName = makeWorkspaceDbFileName(oldDb.dbName, newVersion);
-        await cloudContainer.copyDatabase(oldName, newName);
-        // return the old and new db names and versions
-        return { oldDb, newDb: { dbName: oldDb.dbName, version: newVersion } };
+        const container = this.cloudContainer;
+        if (undefined === container)
+            core_common_1.WorkspaceError.throwError("no-cloud-container", { message: "versions require cloud containers" });
+        const fromDb = { ...args.fromProps, dbName: workspaceDbNameWithDefault(args.fromProps?.dbName) };
+        return CloudSqlite_1.CloudSqlite.createNewDbVersion(container, { ...args, fromDb });
     }
     getWorkspaceDb(props) {
         return this.getEditableDb(props);
     }
     getEditableDb(props) {
         const db = this._wsDbs.get(workspaceDbNameWithDefault(props.dbName)) ?? new EditableDbImpl(props, this);
-        const isPrerelease = semver.major(db.version) === 0 || semver.prerelease(db.version);
-        if (!isPrerelease && this.cloudContainer && this.cloudContainer.queryDatabase(db.dbFileName)?.state !== "copied") {
+        if (this.cloudContainer && !CloudSqlite_1.CloudSqlite.isSemverEditable(db.dbFileName, this.cloudContainer)) {
             this._wsDbs.delete(workspaceDbNameWithDefault(props.dbName));
-            throw new Error(`${db.dbFileName} has been published and is not editable. Make a new version first.`);
+            core_common_1.CloudSqliteError.throwError("already-published", { message: `${db.dbFileName} has been published and is not editable. Make a new version first.` });
         }
         return db;
     }
@@ -512,7 +486,7 @@ class EditorContainerImpl extends WorkspaceContainerImpl {
             if (fs.existsSync(tempDbFile))
                 IModelJsFs_1.IModelJsFs.removeSync(tempDbFile);
             WorkspaceEditor_1.WorkspaceEditor.createEmptyDb({ localFileName: tempDbFile, manifest: args.manifest });
-            await CloudSqlite_1.CloudSqlite.uploadDb(this.cloudContainer, { localFileName: tempDbFile, dbName: makeWorkspaceDbFileName(workspaceDbNameWithDefault(args.dbName)) });
+            await CloudSqlite_1.CloudSqlite.uploadDb(this.cloudContainer, { localFileName: tempDbFile, dbName: CloudSqlite_1.CloudSqlite.makeSemverName(workspaceDbNameWithDefault(args.dbName)) });
             IModelJsFs_1.IModelJsFs.removeSync(tempDbFile);
         }
         return this.getWorkspaceDb(args);
@@ -524,23 +498,22 @@ class EditableDbImpl extends WorkspaceDbImpl {
         return this._container;
     }
     static validateResourceName(name) {
-        if (name.trim() !== name) {
-            throw new Error("resource name may not have leading or trailing spaces");
-        }
+        if (name.trim() !== name)
+            core_common_1.WorkspaceError.throwError("invalid-name", { message: "resource name may not have leading or trailing spaces" });
         if (name.length > 1024) {
-            throw new Error("resource name too long");
+            core_common_1.WorkspaceError.throwError("invalid-name", { message: "resource name too long" });
         }
     }
     validateResourceSize(val) {
         const len = typeof val === "string" ? val.length : val.byteLength;
         if (len > (1024 * 1024 * 1024)) // one gigabyte
-            throw new Error("value is too large");
+            core_common_1.WorkspaceError.throwError("too-large", { message: "value is too large" });
     }
     get cloudProps() {
         const props = this._container.cloudProps;
         if (props === undefined)
             return undefined;
-        const parsed = parseWorkspaceDbFileName(this.dbFileName);
+        const parsed = CloudSqlite_1.CloudSqlite.parseDbFileName(this.dbFileName);
         return { ...props, dbName: parsed.dbName, version: parsed.version };
     }
     open() {
@@ -567,8 +540,8 @@ class EditableDbImpl extends WorkspaceDbImpl {
             const rc = stmt.step();
             if (core_bentley_1.DbResult.BE_SQLITE_DONE !== rc) {
                 if (core_bentley_1.DbResult.BE_SQLITE_CONSTRAINT_PRIMARYKEY === rc)
-                    throw new core_common_1.IModelError(rc, `resource "${rscName}" already exists`);
-                throw new core_common_1.IModelError(rc, `workspace [${sql}]`);
+                    core_common_1.WorkspaceError.throwError("resource-exists", { message: `resource "${rscName}" already exists` });
+                core_common_1.WorkspaceError.throwError("write-error", { message: `workspace [${sql}], rc=${rc}` });
             }
         });
         this.sqliteDb.saveChanges();
@@ -626,7 +599,7 @@ class EditableDbImpl extends WorkspaceDbImpl {
     removeFile(rscName) {
         const file = this.queryFileResource(rscName);
         if (undefined === file)
-            throw new Error(`file resource "${rscName}" does not exist`);
+            core_common_1.WorkspaceError.throwError("does-not-exist", { message: `file resource "${rscName}" does not exist` });
         if (file && fs.existsSync(file.localFileName))
             fs.unlinkSync(file.localFileName);
         this.sqliteDb[Symbols_1._nativeDb].removeEmbeddedFile(rscName);
@@ -641,15 +614,6 @@ function constructWorkspace(settings, opts) {
 function constructWorkspaceEditor() {
     return new EditorImpl();
 }
-function noLeadingOrTrailingSpaces(name, msg) {
-    if (name.trim() !== name)
-        throw new Error(`${msg} [${name}] may not have leading or trailing spaces`);
-}
-function validateWorkspaceDbName(dbName) {
-    if (dbName === "" || dbName.length > 255 || /[#\.<>:"/\\"`'|?*\u0000-\u001F]/g.test(dbName) || /^(con|prn|aux|nul|com\d|lpt\d)$/i.test(dbName))
-        throw new Error(`invalid dbName: [${dbName}]`);
-    noLeadingOrTrailingSpaces(dbName, "dbName");
-}
 /**
  * Validate that a WorkspaceContainer.Id is valid.
  * The rules for ContainerIds (from Azure, see https://docs.microsoft.com/en-us/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata):
@@ -659,41 +623,13 @@ function validateWorkspaceDbName(dbName) {
  */
 function validateWorkspaceContainerId(id) {
     if (!/^(?=.{3,63}$)[a-z0-9]+(-[a-z0-9]+)*$/g.test(id))
-        throw new Error(`invalid containerId: [${id}]`);
-}
-function validateWorkspaceDbVersion(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)
-        throw new Error("invalid version specification");
-    version = semVersion;
-    return version;
-}
-/**
- * Parse the name stored in a WorkspaceContainer into the dbName and version number. A single WorkspaceContainer may hold
- * many versions of the same WorkspaceDb. The name of the Db in the WorkspaceContainer is in the format "name:version". This
- * function splits them into separate strings.
- */
-function parseWorkspaceDbFileName(dbFileName) {
-    const parts = dbFileName.split(":");
-    return { dbName: parts[0], version: parts[1] };
-}
-/** Create a dbName for a WorkspaceDb from its base name and version. This will be in the format "name:version" */
-function makeWorkspaceDbFileName(dbName, version) {
-    return `${dbName}:${validateWorkspaceDbVersion(version)}`;
+        core_common_1.WorkspaceError.throwError("invalid-name", { message: `invalid containerId: [${id}]` });
 }
 exports.workspaceManifestProperty = { namespace: "workspace", name: "manifest" };
-function throwWorkspaceDbLoadError(msg, wsDbProps, db) {
-    const error = new Error(msg);
-    error.wsDbProps = wsDbProps;
-    error.wsDb = db;
-    throw error;
+function throwWorkspaceDbLoadError(message, wsDbProps, wsDb) {
+    core_common_1.WorkspaceError.throwError("load-error", { message, wsDb, wsDbProps });
 }
-function throwWorkspaceDbLoadErrors(msg, errors) {
-    const error = new Error(msg);
-    error.wsLoadErrors = errors;
-    throw error;
+function throwWorkspaceDbLoadErrors(message, wsLoadErrors) {
+    core_common_1.WorkspaceError.throwError("load-errors", { message, wsLoadErrors });
 }
 //# sourceMappingURL=WorkspaceImpl.js.map