@itwin/core-backend 5.0.0-dev.9 → 5.0.0-dev.92

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

@@ -0,0 +1,691 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Workspace
+ */
+import { createHash } from "crypto";
+import * as fs from "fs-extra";
+import { dirname, extname, join } from "path";
+import * as semver from "semver";
+import { assert, BeEvent, DbResult, OpenMode } from "@itwin/core-bentley";
+import { IModelError } from "@itwin/core-common";
+import { CloudSqlite } from "../../CloudSqlite";
+import { IModelHost, KnownLocations } from "../../IModelHost";
+import { IModelJsFs } from "../../IModelJsFs";
+import { SQLiteDb } from "../../SQLiteDb";
+import { SettingsPriority } from "../../workspace/Settings";
+import { Workspace, WorkspaceSettingNames, } from "../../workspace/Workspace";
+import { WorkspaceEditor } from "../../workspace/WorkspaceEditor";
+import { WorkspaceSqliteDb } from "./WorkspaceSqliteDb";
+import { SettingsImpl } from "./SettingsImpl";
+import { _implementationProhibited, _nativeDb } from "../Symbols";
+function workspaceDbNameWithDefault(dbName) {
+    return dbName ?? "workspace-db";
+}
+/** file extension for local WorkspaceDbs */
+export const workspaceDbFileExt = "itwin-workspace";
+function makeWorkspaceCloudCache(arg) {
+    const cache = CloudSqlite.CloudCaches.getCache(arg);
+    if (undefined === cache.workspaceContainers) // if we just created this container, add the map.
+        cache.workspaceContainers = new Map();
+    return cache;
+}
+function getContainerFullId(props) {
+    return `${props.baseUri}/${props.containerId}`;
+}
+function getWorkspaceCloudContainer(props, cache) {
+    const id = getContainerFullId(props);
+    let cloudContainer = cache.workspaceContainers.get(id);
+    if (undefined !== cloudContainer)
+        return cloudContainer;
+    cloudContainer = CloudSqlite.createCloudContainer(props);
+    cache.workspaceContainers.set(id, cloudContainer);
+    cloudContainer.connectCount = 0;
+    cloudContainer.sharedConnect = function () {
+        if (this.connectCount++ === 0) {
+            this.connect(cache);
+            return true;
+        }
+        return false;
+    };
+    cloudContainer.sharedDisconnect = function () {
+        if (--this.connectCount <= 0) {
+            this.disconnect();
+            cache.workspaceContainers.delete(id);
+            this.connectCount = 0;
+        }
+    };
+    return cloudContainer;
+}
+class WorkspaceContainerImpl {
+    [_implementationProhibited] = undefined;
+    workspace;
+    filesDir;
+    id;
+    fromProps;
+    _cloudContainer;
+    get cloudContainer() {
+        return this._cloudContainer;
+    }
+    _wsDbs = new Map();
+    get dirName() { return join(this.workspace.containerDir, this.id); }
+    constructor(workspace, props) {
+        validateWorkspaceContainerId(props.containerId);
+        this.workspace = workspace;
+        this.id = props.containerId;
+        this.fromProps = props;
+        if (props.baseUri !== "")
+            this._cloudContainer = getWorkspaceCloudContainer(props, this.workspace.getCloudCache());
+        workspace.addContainer(this);
+        this.filesDir = join(this.dirName, "Files");
+        const cloudContainer = this.cloudContainer;
+        if (undefined === cloudContainer)
+            return;
+        // sharedConnect returns true if we just connected (if the container is shared, it may have already been connected)
+        if (cloudContainer.sharedConnect() && false !== props.syncOnConnect) {
+            try {
+                cloudContainer.checkForChanges();
+            }
+            catch {
+                // must be offline
+            }
+        }
+    }
+    resolveDbFileName(props) {
+        const cloudContainer = this.cloudContainer;
+        if (undefined === cloudContainer)
+            return join(this.dirName, `${props.dbName}.${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);
+    }
+    addWorkspaceDb(toAdd) {
+        if (undefined !== this._wsDbs.get(toAdd.dbName))
+            throw new Error(`workspaceDb '${toAdd.dbName}' already exists in workspace`);
+        this._wsDbs.set(toAdd.dbName, toAdd);
+    }
+    getWorkspaceDb(props) {
+        return this._wsDbs.get(workspaceDbNameWithDefault(props?.dbName)) ?? new WorkspaceDbImpl(props ?? {}, this);
+    }
+    closeWorkspaceDb(toDrop) {
+        const name = toDrop.dbName;
+        const wsDb = this._wsDbs.get(name);
+        if (wsDb === toDrop) {
+            this._wsDbs.delete(name);
+            wsDb.close();
+        }
+    }
+    close() {
+        for (const [_name, db] of this._wsDbs)
+            db.close();
+        this._wsDbs.clear();
+        this.cloudContainer?.sharedDisconnect();
+    }
+}
+/** Implementation of WorkspaceDb */
+class WorkspaceDbImpl {
+    [_implementationProhibited] = undefined;
+    sqliteDb = new WorkspaceSqliteDb();
+    dbName;
+    _container;
+    onClose = new BeEvent();
+    dbFileName;
+    _manifest;
+    /** true if this WorkspaceDb is currently open */
+    get isOpen() { return this.sqliteDb.isOpen; }
+    get container() { return this._container; }
+    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 = join(this._container.filesDir, 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 };
+    }
+    constructor(props, container) {
+        this.dbName = workspaceDbNameWithDefault(props.dbName);
+        validateWorkspaceDbName(this.dbName);
+        this._container = container;
+        this.dbFileName = container.resolveDbFileName(props);
+        container.addWorkspaceDb(this);
+        if (true === props.prefetch)
+            this.prefetch();
+    }
+    open() {
+        this.sqliteDb.openDb(this.dbFileName, OpenMode.Readonly, this._container.cloudContainer);
+    }
+    close() {
+        if (this.isOpen) {
+            this.onClose.raiseEvent();
+            this.sqliteDb.closeDb();
+            this._container.closeWorkspaceDb(this);
+        }
+    }
+    get version() {
+        const cloudContainer = this.container.cloudContainer;
+        if (undefined === cloudContainer)
+            return "1.0.0"; // local file, no versioning. return default
+        return parseWorkspaceDbFileName(this.dbFileName).version;
+    }
+    get manifest() {
+        return this._manifest ??= this.withOpenDb((db) => {
+            const manifestJson = db[_nativeDb].queryFileProperty(workspaceManifestProperty, true);
+            return manifestJson ? JSON.parse(manifestJson) : { workspaceName: this.dbName };
+        });
+    }
+    withOpenDb(operation) {
+        const done = this.isOpen ? () => { } : (this.open(), () => this.close());
+        try {
+            return operation(this.sqliteDb);
+        }
+        finally {
+            done();
+        }
+    }
+    getString(rscName) {
+        return this.withOpenDb((db) => {
+            return db.withSqliteStatement("SELECT value from strings WHERE id=?", (stmt) => {
+                stmt.bindString(1, rscName);
+                return DbResult.BE_SQLITE_ROW === stmt.step() ? stmt.getValueString(0) : undefined;
+            });
+        });
+    }
+    getBlobReader(rscName) {
+        return this.sqliteDb.withSqliteStatement("SELECT rowid from blobs WHERE id=?", (stmt) => {
+            stmt.bindString(1, rscName);
+            const blobReader = SQLiteDb.createBlobIO();
+            blobReader.open(this.sqliteDb[_nativeDb], { tableName: "blobs", columnName: "value", row: stmt.getValueInteger(0) });
+            return blobReader;
+        });
+    }
+    getBlob(rscName) {
+        return this.withOpenDb((db) => {
+            return db.withSqliteStatement("SELECT value from blobs WHERE id=?", (stmt) => {
+                stmt.bindString(1, rscName);
+                return DbResult.BE_SQLITE_ROW === stmt.step() ? stmt.getValueBlob(0) : undefined;
+            });
+        });
+    }
+    getFile(rscName, targetFileName) {
+        return this.withOpenDb((db) => {
+            const file = this.queryFileResource(rscName);
+            if (!file)
+                return undefined;
+            const info = file.info;
+            const localFileName = targetFileName ?? file.localFileName;
+            // check whether the file is already up to date.
+            const stat = fs.existsSync(localFileName) && fs.statSync(localFileName);
+            if (stat && Math.round(stat.mtimeMs) === info.date && stat.size === info.size)
+                return localFileName; // yes, we're done
+            // extractEmbeddedFile fails if the file exists or if the directory does not exist
+            if (stat)
+                fs.removeSync(localFileName);
+            else
+                IModelJsFs.recursiveMkDirSync(dirname(localFileName));
+            db[_nativeDb].extractEmbeddedFile({ name: rscName, localFileName });
+            const date = new Date(info.date);
+            fs.utimesSync(localFileName, date, date); // set the last-modified date of the file to match date in container
+            fs.chmodSync(localFileName, "0444"); // set file readonly
+            return localFileName;
+        });
+    }
+    prefetch(opts) {
+        const cloudContainer = this._container.cloudContainer;
+        if (cloudContainer === undefined)
+            throw new Error("no cloud container to prefetch");
+        return CloudSqlite.startCloudPrefetch(cloudContainer, this.dbFileName, opts);
+    }
+    queryResources(args) {
+        const table = "blob" !== args.type ? "strings" : "blobs";
+        this.withOpenDb((db) => {
+            const where = undefined !== args.namePattern ? ` WHERE id ${args.nameCompare ?? "="} ?` : "";
+            db.withSqliteStatement(`SELECT id from ${table}${where}`, (stmt) => {
+                function* makeIterable() {
+                    while (DbResult.BE_SQLITE_ROW === stmt.step()) {
+                        yield stmt.getValueString(0);
+                    }
+                }
+                if (undefined !== args.namePattern) {
+                    stmt.bindString(1, args.namePattern);
+                }
+                args.callback(makeIterable());
+            });
+        });
+    }
+}
+/** Implementation of Workspace */
+class WorkspaceImpl {
+    [_implementationProhibited] = undefined;
+    _containers = new Map();
+    containerDir;
+    settings;
+    _cloudCache;
+    getCloudCache() {
+        return this._cloudCache ??= makeWorkspaceCloudCache({ cacheName: "Workspace", cacheSize: "20G" });
+    }
+    constructor(settings, opts) {
+        this.settings = settings;
+        this.containerDir = opts?.containerDir ?? join(IModelHost.cacheDir, "Workspace");
+        let settingsFiles = opts?.settingsFiles;
+        if (settingsFiles) {
+            if (typeof settingsFiles === "string")
+                settingsFiles = [settingsFiles];
+            settingsFiles.forEach((file) => settings.addFile(file, SettingsPriority.application));
+        }
+    }
+    addContainer(toAdd) {
+        if (undefined !== this._containers.get(toAdd.id))
+            throw new Error("container already exists in workspace");
+        this._containers.set(toAdd.id, toAdd);
+    }
+    findContainer(containerId) {
+        return this._containers.get(containerId);
+    }
+    getContainer(props) {
+        return this.findContainer(props.containerId) ?? new WorkspaceContainerImpl(this, props);
+    }
+    async getContainerAsync(props) {
+        const accessToken = props.accessToken ?? ((props.baseUri === "") || props.isPublic) ? "" : await CloudSqlite.requestToken({ ...props, accessLevel: "read" });
+        return this.getContainer({ ...props, accessToken });
+    }
+    async getWorkspaceDb(props) {
+        let container = this.findContainer(props.containerId);
+        if (undefined === container) {
+            const accessToken = props.isPublic ? "" : await CloudSqlite.requestToken({ accessLevel: "read", ...props });
+            container = new WorkspaceContainerImpl(this, { ...props, accessToken });
+        }
+        return container.getWorkspaceDb(props);
+    }
+    async loadSettingsDictionary(props, problems) {
+        if (!Array.isArray(props))
+            props = [props];
+        for (const prop of props) {
+            const db = await this.getWorkspaceDb(prop);
+            db.open();
+            try {
+                const manifest = db.manifest;
+                const dictProps = { name: prop.resourceName, workspaceDb: db, priority: prop.priority };
+                // don't load if we already have this dictionary. Happens if the same WorkspaceDb is in more than one list
+                if (undefined === this.settings.getDictionary(dictProps)) {
+                    const settingsJson = db.getString(prop.resourceName);
+                    if (undefined === settingsJson)
+                        throwWorkspaceDbLoadError(`could not load setting dictionary resource '${prop.resourceName}' from: '${manifest.workspaceName}'`, prop, db);
+                    db.close(); // don't leave this db open in case we're going to find another dictionary in it recursively.
+                    this.settings.addJson(dictProps, settingsJson);
+                    const dict = this.settings.getDictionary(dictProps);
+                    if (dict) {
+                        Workspace.onSettingsDictionaryLoadedFn({ dict, from: db });
+                        // if the dictionary we just loaded has a "settingsWorkspaces" entry, load them too, recursively
+                        const nested = dict.getSetting(WorkspaceSettingNames.settingsWorkspaces);
+                        if (nested !== undefined) {
+                            IModelHost.settingsSchemas.validateSetting(nested, WorkspaceSettingNames.settingsWorkspaces);
+                            await this.loadSettingsDictionary(nested, problems);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                db.close();
+                problems?.push(e);
+            }
+        }
+    }
+    close() {
+        this.settings.close();
+        for (const [_id, container] of this._containers)
+            container.close();
+        this._containers.clear();
+    }
+    resolveWorkspaceDbSetting(settingName, filter) {
+        const settingDef = IModelHost.settingsSchemas.settingDefs.get(settingName);
+        const combine = settingDef?.combineArray === true;
+        filter = filter ?? (() => true);
+        const result = [];
+        for (const entry of this.settings.getSettingEntries(settingName)) {
+            for (const dbProp of entry.value) {
+                if (filter(dbProp, entry.dictionary)) {
+                    result.push(dbProp);
+                }
+            }
+            if (!combine) {
+                break;
+            }
+        }
+        return result;
+    }
+    async getWorkspaceDbs(args) {
+        const dbList = (args.settingName !== undefined) ? this.resolveWorkspaceDbSetting(args.settingName, args.filter) : args.dbs;
+        const result = [];
+        const pushUnique = (wsDb) => {
+            for (const db of result) {
+                // if we already have this db, skip it. The test below also has to consider that we create a separate WorkspaceDb object for the same
+                // database from more than one Workspace (though then they must use a "shared" CloudContainer).
+                if (db === wsDb || ((db.container.cloudContainer === wsDb.container.cloudContainer) && (db.dbFileName === wsDb.dbFileName)))
+                    return; // this db is redundant
+            }
+            result.push(wsDb);
+        };
+        for (const dbProps of dbList) {
+            try {
+                pushUnique(await this.getWorkspaceDb(dbProps));
+            }
+            catch (e) {
+                const loadErr = e;
+                loadErr.wsDbProps = dbProps;
+                args.problems?.push(loadErr);
+            }
+        }
+        return result;
+    }
+}
+const workspaceEditorName = "WorkspaceEditor"; // name of the cache for the editor workspace
+class EditorWorkspaceImpl extends WorkspaceImpl {
+    getCloudCache() {
+        return this._cloudCache ??= makeWorkspaceCloudCache({ cacheName: workspaceEditorName, cacheSize: "20G" });
+    }
+}
+class EditorImpl {
+    [_implementationProhibited] = undefined;
+    workspace = new EditorWorkspaceImpl(new SettingsImpl(), { containerDir: join(IModelHost.cacheDir, workspaceEditorName) });
+    async initializeContainer(args) {
+        class CloudAccess extends 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");
+                await super._initializeDb({ ...args, props, dbName: dbFullName, dbType: WorkspaceSqliteDb, blockSize: "4M" });
+                return props;
+            }
+        }
+        return CloudAccess.initializeWorkspace(args);
+    }
+    async createNewCloudContainer(args) {
+        const cloudContainer = await this.initializeContainer(args);
+        const userToken = await IModelHost.authorizationClient?.getAccessToken();
+        const accessToken = await CloudSqlite.requestToken({ ...cloudContainer, accessLevel: "write", userToken });
+        return this.getContainer({ accessToken, ...cloudContainer, writeable: true, description: args.metadata.description });
+    }
+    getContainer(props) {
+        return this.workspace.findContainer(props.containerId) ?? new EditorContainerImpl(this.workspace, props);
+    }
+    async getContainerAsync(props) {
+        const accessToken = props.accessToken ?? (props.baseUri === "") ? "" : await CloudSqlite.requestToken({ ...props, accessLevel: "write" });
+        return this.getContainer({ ...props, accessToken });
+    }
+    close() {
+        this.workspace.close();
+    }
+}
+class EditorContainerImpl extends WorkspaceContainerImpl {
+    get cloudContainer() {
+        return super.cloudContainer;
+    }
+    get cloudProps() {
+        const cloudContainer = this.cloudContainer;
+        if (undefined === cloudContainer)
+            return undefined;
+        return {
+            baseUri: cloudContainer.baseUri,
+            containerId: cloudContainer.containerId,
+            storageType: cloudContainer.storageType,
+            isPublic: cloudContainer.isPublic,
+        };
+    }
+    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 } };
+    }
+    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") {
+            this._wsDbs.delete(workspaceDbNameWithDefault(props.dbName));
+            throw new Error(`${db.dbFileName} has been published and is not editable. Make a new version first.`);
+        }
+        return db;
+    }
+    acquireWriteLock(user) {
+        if (this.cloudContainer) {
+            this.cloudContainer.acquireWriteLock(user);
+            this.cloudContainer.writeLockHeldBy = user;
+        }
+    }
+    releaseWriteLock() {
+        if (this.cloudContainer) {
+            this.cloudContainer.releaseWriteLock();
+            this.cloudContainer.writeLockHeldBy = undefined;
+        }
+    }
+    abandonChanges() {
+        if (this.cloudContainer) {
+            this.cloudContainer.abandonChanges();
+            this.cloudContainer.writeLockHeldBy = undefined;
+        }
+    }
+    async createDb(args) {
+        if (!this.cloudContainer) {
+            WorkspaceEditor.createEmptyDb({ localFileName: this.resolveDbFileName(args), manifest: args.manifest });
+        }
+        else {
+            // currently the only way to create a workspaceDb in a cloud container is to create a temporary workspaceDb and upload it.
+            const tempDbFile = join(KnownLocations.tmpdir, `empty.${workspaceDbFileExt}`);
+            if (fs.existsSync(tempDbFile))
+                IModelJsFs.removeSync(tempDbFile);
+            WorkspaceEditor.createEmptyDb({ localFileName: tempDbFile, manifest: args.manifest });
+            await CloudSqlite.uploadDb(this.cloudContainer, { localFileName: tempDbFile, dbName: makeWorkspaceDbFileName(workspaceDbNameWithDefault(args.dbName)) });
+            IModelJsFs.removeSync(tempDbFile);
+        }
+        return this.getWorkspaceDb(args);
+    }
+}
+class EditableDbImpl extends WorkspaceDbImpl {
+    get container() {
+        assert(this._container instanceof EditorContainerImpl);
+        return this._container;
+    }
+    static validateResourceName(name) {
+        if (name.trim() !== name) {
+            throw new Error("resource name may not have leading or trailing spaces");
+        }
+        if (name.length > 1024) {
+            throw new Error("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");
+    }
+    get cloudProps() {
+        const props = this._container.cloudProps;
+        if (props === undefined)
+            return undefined;
+        const parsed = parseWorkspaceDbFileName(this.dbFileName);
+        return { ...props, dbName: parsed.dbName, version: parsed.version };
+    }
+    open() {
+        this.sqliteDb.openDb(this.dbFileName, OpenMode.ReadWrite, this._container.cloudContainer);
+    }
+    close() {
+        if (this.isOpen) {
+            // whenever we close an EditableDb, update the name of the last editor in the manifest
+            const lastEditedBy = this._container.cloudContainer?.writeLockHeldBy;
+            if (lastEditedBy !== undefined)
+                this.updateManifest({ ...this.manifest, lastEditedBy });
+            // make sure all changes were saved before we close
+            this.sqliteDb.saveChanges();
+        }
+        super.close();
+    }
+    getFileModifiedTime(localFileName) {
+        return Math.round(fs.statSync(localFileName).mtimeMs);
+    }
+    performWriteSql(rscName, sql, bind) {
+        this.sqliteDb.withSqliteStatement(sql, (stmt) => {
+            stmt.bindString(1, rscName);
+            bind?.(stmt);
+            const rc = stmt.step();
+            if (DbResult.BE_SQLITE_DONE !== rc) {
+                if (DbResult.BE_SQLITE_CONSTRAINT_PRIMARYKEY === rc)
+                    throw new IModelError(rc, `resource "${rscName}" already exists`);
+                throw new IModelError(rc, `workspace [${sql}]`);
+            }
+        });
+        this.sqliteDb.saveChanges();
+    }
+    updateManifest(manifest) {
+        this.sqliteDb[_nativeDb].saveFileProperty(workspaceManifestProperty, JSON.stringify(manifest));
+        this._manifest = undefined;
+    }
+    updateSettingsResource(settings, rscName) {
+        this.updateString(rscName ?? "settingsDictionary", JSON.stringify(settings));
+    }
+    addString(rscName, val) {
+        EditableDbImpl.validateResourceName(rscName);
+        this.validateResourceSize(val);
+        this.performWriteSql(rscName, "INSERT INTO strings(id,value) VALUES(?,?)", (stmt) => stmt.bindString(2, val));
+    }
+    updateString(rscName, val) {
+        this.validateResourceSize(val);
+        this.performWriteSql(rscName, "INSERT INTO strings(id,value) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET value=excluded.value WHERE value!=excluded.value", (stmt) => stmt.bindString(2, val));
+    }
+    removeString(rscName) {
+        this.performWriteSql(rscName, "DELETE FROM strings WHERE id=?");
+    }
+    addBlob(rscName, val) {
+        EditableDbImpl.validateResourceName(rscName);
+        this.validateResourceSize(val);
+        this.performWriteSql(rscName, "INSERT INTO blobs(id,value) VALUES(?,?)", (stmt) => stmt.bindBlob(2, val));
+    }
+    updateBlob(rscName, val) {
+        this.validateResourceSize(val);
+        this.performWriteSql(rscName, "INSERT INTO blobs(id,value) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET value=excluded.value WHERE value!=excluded.value", (stmt) => stmt.bindBlob(2, val));
+    }
+    getBlobWriter(rscName) {
+        return this.sqliteDb.withSqliteStatement("SELECT rowid from blobs WHERE id=?", (stmt) => {
+            stmt.bindString(1, rscName);
+            const blobWriter = SQLiteDb.createBlobIO();
+            blobWriter.open(this.sqliteDb[_nativeDb], { tableName: "blobs", columnName: "value", row: stmt.getValueInteger(0), writeable: true });
+            return blobWriter;
+        });
+    }
+    removeBlob(rscName) {
+        this.performWriteSql(rscName, "DELETE FROM blobs WHERE id=?");
+    }
+    addFile(rscName, localFileName, fileExt) {
+        EditableDbImpl.validateResourceName(rscName);
+        fileExt = fileExt ?? extname(localFileName);
+        if (fileExt?.[0] === ".")
+            fileExt = fileExt.slice(1);
+        this.sqliteDb[_nativeDb].embedFile({ name: rscName, localFileName, date: this.getFileModifiedTime(localFileName), fileExt });
+    }
+    updateFile(rscName, localFileName) {
+        this.queryFileResource(rscName); // throws if not present
+        this.sqliteDb[_nativeDb].replaceEmbeddedFile({ name: rscName, localFileName, date: this.getFileModifiedTime(localFileName) });
+    }
+    removeFile(rscName) {
+        const file = this.queryFileResource(rscName);
+        if (undefined === file)
+            throw new Error(`file resource "${rscName}" does not exist`);
+        if (file && fs.existsSync(file.localFileName))
+            fs.unlinkSync(file.localFileName);
+        this.sqliteDb[_nativeDb].removeEmbeddedFile(rscName);
+    }
+}
+export function constructWorkspaceDb(props, container) {
+    return new WorkspaceDbImpl(props, container);
+}
+export function constructWorkspace(settings, opts) {
+    return new WorkspaceImpl(settings, opts);
+}
+export function constructWorkspaceEditor() {
+    return new EditorImpl();
+}
+export function noLeadingOrTrailingSpaces(name, msg) {
+    if (name.trim() !== name)
+        throw new Error(`${msg} [${name}] may not have leading or trailing spaces`);
+}
+export 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):
+ *  - 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
+ *  - may not be shorter than 3 or longer than 63 characters
+ */
+export function validateWorkspaceContainerId(id) {
+    if (!/^(?=.{3,63}$)[a-z0-9]+(-[a-z0-9]+)*$/g.test(id))
+        throw new Error(`invalid containerId: [${id}]`);
+}
+export 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.
+ */
+export 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" */
+export function makeWorkspaceDbFileName(dbName, version) {
+    return `${dbName}:${validateWorkspaceDbVersion(version)}`;
+}
+export const workspaceManifestProperty = { namespace: "workspace", name: "manifest" };
+function throwWorkspaceDbLoadError(msg, wsDbProps, db) {
+    const error = new Error(msg);
+    error.wsDbProps = wsDbProps;
+    error.wsDb = db;
+    throw error;
+}
+export function throwWorkspaceDbLoadErrors(msg, errors) {
+    const error = new Error(msg);
+    error.wsLoadErrors = errors;
+    throw error;
+}
+//# sourceMappingURL=WorkspaceImpl.js.map