@itwin/core-backend 3.3.0-dev.7 → 3.3.0-dev.72

package/lib/cjs/workspace/Workspace.js

@@ -7,89 +7,180 @@
  * @module Workspace
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EditableWorkspaceDb = exports.ITwinWorkspaceDb = exports.ITwinWorkspaceContainer = exports.ITwinWorkspace = void 0;
+exports.EditableWorkspaceDb = exports.ITwinWorkspaceDb = exports.ITwinWorkspaceContainer = exports.ITwinWorkspace = exports.WorkspaceSetting = void 0;
 const crypto_1 = require("crypto");
 const fs = require("fs-extra");
 const path_1 = require("path");
+const semver = require("semver");
 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 IModelHost_1 = require("../IModelHost");
 const IModelJsFs_1 = require("../IModelJsFs");
 const SQLiteDb_1 = require("../SQLiteDb");
-// cspell:ignore rowid
-/** The names of Settings used by Workspace
+const Settings_1 = require("./Settings");
+const SettingsSchemas_1 = require("./SettingsSchemas");
+/* eslint-disable @typescript-eslint/naming-convention */
+// cspell:ignore rowid primarykey
+/** The Settings used by Workspace api
  * @beta
  */
-var WorkspaceSetting;
-(function (WorkspaceSetting) {
-    WorkspaceSetting["ContainerAlias"] = "workspace/container/alias";
-})(WorkspaceSetting || (WorkspaceSetting = {}));
-const workspaceDbFileExt = "itwin-workspace";
+exports.WorkspaceSetting = {
+    Accounts: "cloud/accounts",
+    Containers: "cloud/containers",
+    Databases: "workspace/databases",
+};
 /** @internal */
 class ITwinWorkspace {
     constructor(settings, opts) {
         var _a;
         this._containers = new Map();
         this.settings = settings;
-        this.containerDir = (_a = opts === null || opts === void 0 ? void 0 : opts.containerDir) !== null && _a !== void 0 ? _a : (0, path_1.join)(imodeljs_native_1.NativeLibrary.defaultLocalDir, "iTwin", "Workspace");
+        this.containerDir = (_a = opts === null || opts === void 0 ? void 0 : opts.containerDir) !== null && _a !== void 0 ? _a : (0, path_1.join)(IModelHost_1.IModelHost.cacheDir, "Workspace");
+        this._cloudCacheProps = opts === null || opts === void 0 ? void 0 : opts.cloudCacheProps;
+        let settingsFiles = opts === null || opts === void 0 ? void 0 : opts.settingsFiles;
+        if (settingsFiles) {
+            if (typeof settingsFiles === "string")
+                settingsFiles = [settingsFiles];
+            settingsFiles.forEach((file) => settings.addFile(file, Settings_1.SettingsPriority.application));
+        }
+    }
+    get cloudCache() {
+        var _a, _b, _c, _d, _e, _f;
+        if (undefined === this._cloudCache) {
+            const cacheProps = {
+                ...this._cloudCacheProps,
+                rootDir: (_b = (_a = this._cloudCacheProps) === null || _a === void 0 ? void 0 : _a.rootDir) !== null && _b !== void 0 ? _b : (0, path_1.join)(this.containerDir, "cloud"),
+                cacheSize: (_d = (_c = this._cloudCacheProps) === null || _c === void 0 ? void 0 : _c.cacheSize) !== null && _d !== void 0 ? _d : "20G",
+                name: (_f = (_e = this._cloudCacheProps) === null || _e === void 0 ? void 0 : _e.name) !== null && _f !== void 0 ? _f : "workspace",
+            };
+            IModelJsFs_1.IModelJsFs.recursiveMkDirSync(cacheProps.rootDir);
+            if (cacheProps.clearContents)
+                fs.emptyDirSync(cacheProps.rootDir);
+            try {
+                this._cloudCache = new IModelHost_1.IModelHost.platform.CloudCache(cacheProps);
+            }
+            catch (e) {
+                core_bentley_1.Logger.logError("workspace", `error creating workspace cloud cache in ${cacheProps.rootDir}`);
+                throw e;
+            }
+        }
+        return this._cloudCache;
     }
     addContainer(toAdd) {
         if (undefined !== this._containers.get(toAdd.id))
             throw new Error("container already exists in workspace");
         this._containers.set(toAdd.id, toAdd);
     }
-    getContainer(props) {
-        var _a;
-        const id = this.resolveContainerId(props);
-        if (undefined === id)
-            throw new Error(`can't resolve workspace container name [${props.containerName}]`);
-        return (_a = this._containers.get(id)) !== null && _a !== void 0 ? _a : new ITwinWorkspaceContainer(this, id);
+    findContainer(containerId) {
+        return this._containers.get(containerId);
     }
-    async getWorkspaceDb(props) {
-        return this.getContainer(props).getWorkspaceDb(props);
+    getContainer(props, account) {
+        var _a;
+        return (_a = this.findContainer(props.containerId)) !== null && _a !== void 0 ? _a : new ITwinWorkspaceContainer(this, props, account);
+    }
+    getWorkspaceDbFromProps(dbProps, containerProps, account) {
+        return this.getContainer(containerProps, account).getWorkspaceDb(dbProps);
+    }
+    getWorkspaceDb(dbAlias) {
+        const dbProps = this.resolveDatabase(dbAlias);
+        const containerProps = this.resolveContainer(dbProps.containerName);
+        const account = containerProps.accountName !== "" ? this.resolveAccount(containerProps.accountName) : undefined;
+        let container = this.findContainer(containerProps.containerId);
+        if (undefined === container) {
+            container = this.getContainer(containerProps, account);
+        }
+        return container === null || container === void 0 ? void 0 : container.getWorkspaceDb(dbProps);
     }
-    async loadSettingsDictionary(settingRsc, priority) {
-        const db = await this.getWorkspaceDb(settingRsc);
-        const setting = db.getString(settingRsc.rscName);
+    loadSettingsDictionary(settingRsc, db, priority) {
+        const setting = db.getString(settingRsc);
         if (undefined === setting)
-            throw new Error(`could not load setting resource ${settingRsc.rscName}`);
-        this.settings.addJson(`${db.container.id}/${db.dbName}/${settingRsc.rscName}`, priority, setting);
+            throw new Error(`could not load setting resource ${settingRsc}`);
+        this.settings.addJson(`${db.container.id}/${db.dbName}/${settingRsc}`, priority, setting);
     }
     close() {
         this.settings.close();
         for (const [_id, container] of this._containers)
             container.close();
         this._containers.clear();
+        if (this._cloudCache) {
+            this._cloudCache.destroy();
+            this._cloudCache = undefined;
+        }
+    }
+    resolveAccount(accountName) {
+        const resolved = this.settings.resolveSetting(exports.WorkspaceSetting.Accounts, (val) => {
+            if (Array.isArray(val)) {
+                for (const entry of val) {
+                    if (typeof entry === "object" && entry.name === accountName)
+                        return SettingsSchemas_1.SettingsSchemas.validateArrayObject(entry, exports.WorkspaceSetting.Accounts, accountName);
+                }
+            }
+            return undefined; // keep going through all settings dictionaries
+        });
+        if (resolved === undefined)
+            throw new Error(`no setting "${exports.WorkspaceSetting.Accounts}" entry for "${accountName}"`);
+        return resolved;
+    }
+    resolveContainer(containerName) {
+        const resolved = this.settings.resolveSetting(exports.WorkspaceSetting.Containers, (val) => {
+            if (Array.isArray(val)) {
+                for (const entry of val) {
+                    if (typeof entry === "object" && entry.name === containerName)
+                        return SettingsSchemas_1.SettingsSchemas.validateArrayObject(entry, exports.WorkspaceSetting.Containers, containerName);
+                }
+            }
+            return undefined; // keep going through all settings dictionaries
+        });
+        if (resolved === undefined)
+            throw new Error(`no setting "${exports.WorkspaceSetting.Containers}" entry for "${containerName}"`);
+        return resolved;
     }
-    resolveContainerId(props) {
-        if (props.containerId)
-            return props.containerId; // if the container id is supplied, just use it
-        const id = this.settings.resolveSetting(WorkspaceSetting.ContainerAlias, (val) => {
+    resolveDatabase(databaseName) {
+        const resolved = this.settings.resolveSetting(exports.WorkspaceSetting.Databases, (val) => {
             if (Array.isArray(val)) {
                 for (const entry of val) {
-                    if (typeof entry === "object" && entry.name === props.containerName && typeof entry.id === "string")
-                        return entry.id;
+                    if (typeof entry === "object" && entry.name === databaseName)
+                        return SettingsSchemas_1.SettingsSchemas.validateArrayObject(entry, exports.WorkspaceSetting.Databases, databaseName);
                 }
             }
             return undefined; // keep going through all settings dictionaries
-        }, props.containerName);
-        if (undefined === id)
-            throw new Error("Unable to resolve container id.");
-        return id;
+        });
+        if (resolved === undefined)
+            throw new Error(`no setting "${exports.WorkspaceSetting.Databases}" entry for "${databaseName}"`);
+        return resolved;
     }
 }
 exports.ITwinWorkspace = ITwinWorkspace;
 /** @internal */
 class ITwinWorkspaceContainer {
-    constructor(workspace, id) {
+    constructor(workspace, props, account) {
         this._wsDbs = new Map();
-        ITwinWorkspaceContainer.validateContainerId(id);
+        ITwinWorkspaceContainer.validateContainerId(props.containerId);
         this.workspace = workspace;
-        this.id = id;
+        this.id = props.containerId;
+        if ((account === null || account === void 0 ? void 0 : account.accessName) && account.storageType)
+            this.cloudContainer = new IModelHost_1.IModelHost.platform.CloudContainer({ accessToken: "", ...props, ...account });
         workspace.addContainer(this);
         this.filesDir = (0, path_1.join)(this.dirName, "Files");
+        const cloudContainer = this.cloudContainer;
+        if (undefined === cloudContainer)
+            return;
+        cloudContainer.connect(this.workspace.cloudCache);
+        if (props.syncOnConnect) {
+            try {
+                cloudContainer.checkForChanges();
+            }
+            catch (e) {
+                // must be offline
+            }
+        }
     }
     get dirName() { return (0, path_1.join)(this.workspace.containerDir, this.id); }
+    static noLeadingOrTrailingSpaces(name, msg) {
+        if (name.trim() !== name)
+            throw new Error(`${msg} [${name}] may not have leading or tailing spaces`);
+    }
     /** rules for ContainerIds (from Azure, see https://docs.microsoft.com/en-us/rest/api/storageservices/naming-and-referencing-containers--blobs--and-metadata)
      *  - may only contain lower case letters, numbers or dashes
      *  - may not start or end with with a dash nor have more than one dash in a row
@@ -99,79 +190,148 @@ class ITwinWorkspaceContainer {
         if (!/^(?=.{3,63}$)[a-z0-9]+(-[a-z0-9]+)*$/g.test(id))
             throw new Error(`invalid containerId: [${id}]`);
     }
+    static validateDbName(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}]`);
+        this.noLeadingOrTrailingSpaces(dbName, "dbName");
+    }
+    static validateVersion(version) {
+        var _a, _b;
+        version = version !== null && version !== void 0 ? version : "1.0.0";
+        if (version) {
+            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 = (_a = semver.clean(version, opts)) !== null && _a !== void 0 ? _a : (_b = semver.coerce(version, opts)) === null || _b === void 0 ? void 0 : _b.version;
+            if (!semVersion)
+                throw new Error("invalid version specification");
+            version = semVersion;
+        }
+        return version;
+    }
+    static parseDbFileName(dbFileName) {
+        const parts = dbFileName.split(":");
+        return { dbName: parts[0], version: parts[1] };
+    }
+    static makeDbFileName(dbName, version) {
+        return `${dbName}:${this.validateVersion(version)}`;
+    }
+    static resolveCloudFileName(cloudContainer, props) {
+        var _a;
+        const dbName = props.dbName;
+        const dbs = cloudContainer.queryDatabases(`${dbName}*`); // get all databases that start with dbName
+        const versions = [];
+        for (const db of dbs) {
+            const thisDb = ITwinWorkspaceContainer.parseDbFileName(db);
+            if (thisDb.dbName === dbName && "string" === typeof thisDb.version && thisDb.version.length > 0)
+                versions.push(thisDb.version);
+        }
+        if (versions.length === 0)
+            versions[0] = "1.0.0";
+        const range = (_a = props.version) !== null && _a !== void 0 ? _a : "*";
+        try {
+            const version = semver.maxSatisfying(versions, range, { loose: true, includePrerelease: props.includePrerelease });
+            if (version)
+                return `${dbName}:${version}`;
+        }
+        catch (e) {
+        }
+        throw new Error(`No version of [${dbName}] available for "${range}"`);
+    }
+    /**
+     * Create a copy of an existing [[WorkspaceDb]] in a cloud container with a new version number.
+     * @param cloudContainer The attached cloud container holding the existing WorkspaceDb
+     * @param fromProps Properties that describe the source WorkspaceDb for the new version
+     * @param versionType The type of version increment to apply to the existing version.
+     * @note This requires that the cloudContainer is attached and the write lock on the container be held. The copy should be modified with
+     * new content before the write lock is released, and thereafter should never be modified again.
+     */
+    static async makeNewVersion(cloudContainer, fromProps, versionType) {
+        const oldName = this.resolveCloudFileName(cloudContainer, fromProps);
+        const oldDb = this.parseDbFileName(oldName);
+        const newVersion = semver.inc(oldDb.version, versionType);
+        if (!newVersion)
+            throw new Error("invalid version");
+        const newName = this.makeDbFileName(oldDb.dbName, newVersion);
+        await cloudContainer.copyDatabase(oldName, newName);
+        return { oldName, newName };
+    }
+    /**
+     * Convert a WorkspaceDb.Props specification into a DbFileName. For cloud-based containers, this resolves to the dbName, incorporating the appropriate
+     * version. For file-based containers, this returns a local filename of a WorkspaceDb file with the extension ".itwin-workspace"
+     */
+    resolveDbFileName(props) {
+        const cloudContainer = this.cloudContainer;
+        if (undefined === cloudContainer)
+            return (0, path_1.join)(this.dirName, `${props.dbName}.${ITwinWorkspaceDb.fileExt}`); // local file, versions not allowed
+        return ITwinWorkspaceContainer.resolveCloudFileName(cloudContainer, props);
+    }
     addWorkspaceDb(toAdd) {
         if (undefined !== this._wsDbs.get(toAdd.dbName))
-            throw new Error("dbName already exists in workspace");
+            throw new Error(`workspaceDb ${toAdd.dbName} already exists in workspace`);
         this._wsDbs.set(toAdd.dbName, toAdd);
     }
-    async getWorkspaceDb(props) {
+    getWorkspaceDb(props) {
         var _a;
-        const db = (_a = this._wsDbs.get(props.dbName)) !== null && _a !== void 0 ? _a : new ITwinWorkspaceDb(props.dbName, this);
-        if (!db.isOpen) {
-            if (props.cloudProps)
-                await imodeljs_native_1.CloudSqlite.downloadDb({ ...db, ...props.cloudProps, containerId: this.id });
+        const db = (_a = this._wsDbs.get(props.dbName)) !== null && _a !== void 0 ? _a : new ITwinWorkspaceDb(props, this);
+        if (!db.isOpen)
             db.open();
-        }
         return db;
     }
     dropWorkspaceDb(toDrop) {
         const name = toDrop.dbName;
         const wsDb = this._wsDbs.get(name);
         if (wsDb === toDrop) {
-            wsDb.close();
             this._wsDbs.delete(name);
+            wsDb.close();
         }
     }
     close() {
+        var _a;
         for (const [_name, db] of this._wsDbs)
             db.close();
         this._wsDbs.clear();
+        (_a = this.cloudContainer) === null || _a === void 0 ? void 0 : _a.disconnect();
     }
+    /** Delete all local files extracted by [[WorkspaceDb.getFile]] for this container. */
     purgeContainerFiles() {
         IModelJsFs_1.IModelJsFs.purgeDirSync(this.filesDir);
     }
 }
 exports.ITwinWorkspaceContainer = ITwinWorkspaceContainer;
 /**
- * A local file holding a WorkspaceDb.
+ * Implementation of WorkspaceDb
  * @beta
  */
 class ITwinWorkspaceDb {
-    constructor(dbName, container) {
-        this.sqliteDb = new SQLiteDb_1.SQLiteDb(); // eslint-disable-line @typescript-eslint/naming-convention
-        this.onClosed = new core_bentley_1.BeEvent();
-        ITwinWorkspaceDb.validateDbName(dbName);
-        this.dbName = dbName;
+    constructor(props, container) {
+        /** the SQLiteDb for this WorkspaceDb*/
+        this.sqliteDb = new SQLiteDb_1.SQLiteDb();
+        /** called before db is closed */
+        this.onClose = new core_bentley_1.BeEvent();
+        ITwinWorkspaceContainer.validateDbName(props.dbName);
+        this.dbName = props.dbName;
         this.container = container;
-        this.localFile = (0, path_1.join)(container.dirName, `${dbName}.${workspaceDbFileExt}`);
+        this.dbFileName = container.resolveDbFileName(props);
         container.addWorkspaceDb(this);
     }
-    static noLeadingOrTrailingSpaces(name, msg) {
-        if (name.trim() !== name)
-            throw new Error(`${msg} [${name}] may not have leading or tailing spaces`);
-    }
-    static validateDbName(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}]`);
-        this.noLeadingOrTrailingSpaces(dbName, "dbName");
-    }
+    /** true if this WorkspaceDb is currently open */
     get isOpen() { return this.sqliteDb.isOpen; }
     queryFileResource(rscName) {
         const info = this.sqliteDb.nativeDb.queryEmbeddedFile(rscName);
         if (undefined === info)
             return undefined;
         // since resource names can contain illegal characters, path separators, etc., we make the local file name from its hash, in hex.
-        let localFileName = (0, path_1.join)(this.container.filesDir, (0, crypto_1.createHash)("sha1").update(rscName).digest("hex"));
+        let localFileName = (0, path_1.join)(this.container.filesDir, (0, crypto_1.createHash)("sha1").update(this.dbFileName).update(rscName).digest("hex"));
         if (info.fileExt !== "") // since some applications may expect to see the extension, append it here if it was supplied.
             localFileName = `${localFileName}.${info.fileExt}`;
         return { localFileName, info };
     }
     open() {
-        this.sqliteDb.openDb(this.localFile, core_bentley_1.OpenMode.Readonly);
+        this.sqliteDb.openDb(this.dbFileName, core_bentley_1.OpenMode.Readonly, this.container.cloudContainer);
     }
     close() {
         if (this.isOpen) {
-            this.onClosed.raiseEvent();
+            this.onClose.raiseEvent();
             this.sqliteDb.closeDb();
             this.container.dropWorkspaceDb(this);
         }
@@ -183,7 +343,7 @@ class ITwinWorkspaceDb {
         });
     }
     /** Get a BlobIO reader for a blob WorkspaceResource.
-     * @note when finished, caller must call `close` on the BlobIO.
+     * @note when finished, caller *must* call `close` on the BlobIO.
      */
     getBlobReader(rscName) {
         return this.sqliteDb.withSqliteStatement("SELECT rowid from blobs WHERE id=?", (stmt) => {
@@ -220,8 +380,14 @@ class ITwinWorkspaceDb {
         fs.chmodSync(localFileName, "0444"); // set file readonly
         return localFileName;
     }
+    prefetch(opts) {
+        const cloudContainer = this.container.cloudContainer;
+        return (cloudContainer !== undefined) ? new IModelHost_1.IModelHost.platform.CloudPrefetch(cloudContainer, this.dbFileName, opts) : undefined;
+    }
 }
 exports.ITwinWorkspaceDb = ITwinWorkspaceDb;
+/** file extension for local WorkspaceDbs */
+ITwinWorkspaceDb.fileExt = "itwin-workspace";
 /**
  * An editable [[WorkspaceDb]]. This is used by administrators for creating and modifying `WorkspaceDb`s.
  * For cloud-backed containers, the write token must be obtained before this class may be used. Only one user at at time
@@ -229,12 +395,8 @@ exports.ITwinWorkspaceDb = ITwinWorkspaceDb;
  * @beta
  */
 class EditableWorkspaceDb extends ITwinWorkspaceDb {
-    constructor() {
-        super(...arguments);
-        this._isCloudOpen = false;
-    }
     static validateResourceName(name) {
-        ITwinWorkspaceDb.noLeadingOrTrailingSpaces(name, "resource name");
+        ITwinWorkspaceContainer.noLeadingOrTrailingSpaces(name, "resource name");
         if (name.length > 1024)
             throw new Error("resource name too long");
     }
@@ -244,14 +406,7 @@ class EditableWorkspaceDb extends ITwinWorkspaceDb {
             throw new Error("value is too large");
     }
     open() {
-        this.sqliteDb.openDb(this.localFile, core_bentley_1.OpenMode.ReadWrite);
-    }
-    close() {
-        if (this._isCloudOpen) {
-            //  this.db.nativeDb.flushCloudUpload(); TODO: add back when available
-            this._isCloudOpen = false;
-        }
-        super.close();
+        this.sqliteDb.openDb(this.dbFileName, core_bentley_1.OpenMode.ReadWrite, this.container.cloudContainer);
     }
     getFileModifiedTime(localFileName) {
         return Math.round(fs.statSync(localFileName).mtimeMs);
@@ -261,24 +416,40 @@ class EditableWorkspaceDb extends ITwinWorkspaceDb {
             stmt.bindString(1, rscName);
             bind === null || bind === void 0 ? void 0 : bind(stmt);
             const rc = stmt.step();
-            if (core_bentley_1.DbResult.BE_SQLITE_DONE !== rc)
-                throw new core_common_1.IModelError(rc, "workspace write error");
+            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}]`);
+            }
         });
         this.sqliteDb.saveChanges();
     }
-    /** Create a new, empty, EditableWorkspaceDb for importing Workspace resources. */
-    create() {
-        IModelJsFs_1.IModelJsFs.recursiveMkDirSync((0, path_1.dirname)(this.localFile));
-        this.sqliteDb.createDb(this.localFile);
-        this.sqliteDb.executeSQL("CREATE TABLE strings(id TEXT PRIMARY KEY NOT NULL,value TEXT)");
-        this.sqliteDb.executeSQL("CREATE TABLE blobs(id TEXT PRIMARY KEY NOT NULL,value BLOB)");
-        this.sqliteDb.saveChanges();
-    }
-    static async cloneVersion(oldVersion, newVersion, cloudProps) {
-        return imodeljs_native_1.CloudSqlite.copyDb(oldVersion, newVersion, cloudProps);
+    /** @internal */
+    async createDb(version) {
+        if (!this.container.cloudContainer) {
+            EditableWorkspaceDb.createEmpty(this.dbFileName);
+        }
+        else {
+            // currently the only way to create a workspaceDb in a cloud container is to create a temporary workspaceDb and upload it.
+            const tempDbFile = (0, path_1.join)(IModelHost_1.KnownLocations.tmpdir, `empty.${ITwinWorkspaceDb.fileExt}`);
+            if (fs.existsSync(tempDbFile))
+                fs.rmSync(tempDbFile);
+            EditableWorkspaceDb.createEmpty(tempDbFile);
+            this.dbFileName = ITwinWorkspaceContainer.makeDbFileName(this.dbName, version);
+            await imodeljs_native_1.CloudSqlite.uploadDb(this.container.cloudContainer, { localFileName: tempDbFile, dbName: this.dbFileName });
+            fs.rmSync(tempDbFile);
+        }
+        this.open();
     }
-    async upload(cloudProps) {
-        return imodeljs_native_1.CloudSqlite.uploadDb({ ...cloudProps, ...this });
+    /** Create a new, empty, EditableWorkspaceDb for importing Workspace resources. */
+    static createEmpty(fileName) {
+        const db = new SQLiteDb_1.SQLiteDb();
+        IModelJsFs_1.IModelJsFs.recursiveMkDirSync((0, path_1.dirname)(fileName));
+        db.createDb(fileName);
+        db.executeSQL("CREATE TABLE strings(id TEXT PRIMARY KEY NOT NULL,value TEXT)");
+        db.executeSQL("CREATE TABLE blobs(id TEXT PRIMARY KEY NOT NULL,value BLOB)");
+        db.saveChanges();
+        db.closeDb();
     }
     /** Add a new string resource to this WorkspaceDb.
      * @param rscName The name of the string resource.
@@ -349,7 +520,7 @@ class EditableWorkspaceDb extends ITwinWorkspaceDb {
             fileExt = fileExt.slice(1);
         this.sqliteDb.nativeDb.embedFile({ name: rscName, localFileName, date: this.getFileModifiedTime(localFileName), fileExt });
     }
-    /** Replace an existing file resource with the contents of a local file.
+    /** Replace an existing file resource with the contents of another local file.
      * @param rscName The name of the file resource.
      * @param localFileName The name of a local file to be read.
      * @throws if rscName does not exist