sqlite-hub 2.0.1 → 2.2.0

package/server/services/storage/appStateStore.js

@@ -40,10 +40,11 @@ const CONNECTION_LOGO_DIRECTORY = "db_logos";
 const LEGACY_STATE_FILENAME = "app-state.json";
 const STATE_DATABASE_FILENAME = "sqlite-hub-state.db";
 const MAX_CONNECTION_LOGO_SIZE_BYTES = 5 * 1024 * 1024;
+const MAX_CONNECTION_TAG_NAME_LENGTH = 40;
 const MAX_DOCUMENT_CONTENT_BYTES = 5 * 1024 * 1024;
 const MAX_DOCUMENT_FILENAME_LENGTH = 160;
 const QUERY_EXECUTION_SOURCES = new Set(["api", "cli", "user", "mcp"]);
-const ACCESS_LOG_SOURCES = new Set(["api", "cli"]);
+const ACCESS_LOG_SOURCES = new Set(["api", "cli", "user"]);
 const ACCESS_LOG_STATUSES = new Set(["success", "error"]);
 const MAX_ACCESS_LOG_TEXT_LENGTH = 500;
 const MAX_ACCESS_LOG_METADATA_BYTES = 16 * 1024;
@@ -77,6 +78,32 @@ function normalizeDocumentId(documentId) {
   return normalizedDocumentId;
 }
 
+function normalizeDocumentFolderId(folderId) {
+  const normalizedFolderId = String(folderId ?? "").trim();
+
+  return normalizedFolderId || null;
+}
+
+function normalizeDocumentFolderName(name) {
+  const normalizedName = String(name ?? "")
+    .trim()
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/[\\/]+/g, " ")
+    .replace(/\s+/g, " ")
+    .replace(/^\.+/, "")
+    .trim();
+
+  if (!normalizedName) {
+    throw new ValidationError("Folder name is required.");
+  }
+
+  if (normalizedName.length > 80) {
+    throw new ValidationError("Folder name must not exceed 80 characters.");
+  }
+
+  return normalizedName;
+}
+
 function splitMarkdownFilename(filename) {
   const normalizedFilename = String(filename ?? "");
   const extensionMatch = normalizedFilename.match(/\.md$/i);
@@ -251,6 +278,44 @@ const CONNECTION_LOGO_EXTENSION_BY_FILE_EXTENSION = {
   ".png": "png",
   ".webp": "webp",
 };
+
+function normalizeConnectionTagName(value) {
+  const normalizedName = String(value ?? "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .trim();
+
+  if (!normalizedName) {
+    throw new ValidationError("Tag name is required.");
+  }
+
+  if (normalizedName.length > MAX_CONNECTION_TAG_NAME_LENGTH) {
+    throw new ValidationError(
+      `Tag name must be ${MAX_CONNECTION_TAG_NAME_LENGTH} characters or fewer.`
+    );
+  }
+
+  return normalizedName;
+}
+
+function normalizeConnectionTagNames(values = []) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+
+  const namesByKey = new Map();
+
+  for (const value of values) {
+    const name = normalizeConnectionTagName(value);
+    const key = name.toLowerCase();
+
+    if (!namesByKey.has(key)) {
+      namesByKey.set(key, name);
+    }
+  }
+
+  return [...namesByKey.values()];
+}
+
 const MEDIA_TAGGING_CONFIG_FIELDS = [
   {
     column: "tag_table",
@@ -464,6 +529,29 @@ class AppStateStore {
       CREATE INDEX IF NOT EXISTS idx_recent_connections_last_opened
       ON recent_connections(lastOpenedAt DESC, id ASC);
 
+      CREATE TABLE IF NOT EXISTS tags (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL COLLATE NOCASE UNIQUE,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS connection_tags (
+        connectionId TEXT NOT NULL,
+        tagId INTEGER NOT NULL,
+        PRIMARY KEY (connectionId, tagId),
+        FOREIGN KEY (connectionId)
+          REFERENCES recent_connections(id)
+          ON UPDATE CASCADE
+          ON DELETE CASCADE,
+        FOREIGN KEY (tagId)
+          REFERENCES tags(id)
+          ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_connection_tags_tag
+      ON connection_tags(tagId, connectionId);
+
       CREATE TABLE IF NOT EXISTS query_history (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         database_key TEXT NOT NULL,
@@ -559,6 +647,7 @@ class AppStateStore {
       CREATE TABLE IF NOT EXISTS database_documents (
         id TEXT PRIMARY KEY,
         database_key TEXT NOT NULL,
+        folder_id TEXT,
         title TEXT NOT NULL,
         filename TEXT NOT NULL,
         content TEXT NOT NULL DEFAULT '',
@@ -570,6 +659,18 @@ class AppStateStore {
       CREATE INDEX IF NOT EXISTS idx_database_documents_database_updated
       ON database_documents(database_key, updated_at DESC, id ASC);
 
+      CREATE TABLE IF NOT EXISTS database_document_folders (
+        id TEXT PRIMARY KEY,
+        database_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(database_key, name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_database_document_folders_database_name
+      ON database_document_folders(database_key, name COLLATE NOCASE, id ASC);
+
       CREATE TABLE IF NOT EXISTS api_tokens (
         id TEXT PRIMARY KEY,
         database_key TEXT NOT NULL,
@@ -585,7 +686,7 @@ class AppStateStore {
 
       CREATE TABLE IF NOT EXISTS access_log (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source TEXT NOT NULL CHECK(source IN ('api', 'cli')),
+        source TEXT NOT NULL CHECK(source IN ('api', 'cli', 'user')),
         action TEXT NOT NULL,
         database_key TEXT,
         target_type TEXT,
@@ -665,9 +766,113 @@ class AppStateStore {
     }
 
     this.ensureQueryRunsSchema();
+    this.ensureAccessLogSchema();
+    this.ensureDatabaseDocumentsSchema();
     this.ensureMediaTaggingConfigSchema();
   }
 
+  ensureDatabaseDocumentsSchema() {
+    const columns = new Set(
+      this.db
+        .prepare("PRAGMA table_info(database_documents)")
+        .all()
+        .map((column) => column.name)
+    );
+
+    if (!columns.has("folder_id")) {
+      this.db.exec("ALTER TABLE database_documents ADD COLUMN folder_id TEXT");
+    }
+
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_database_documents_folder_updated
+      ON database_documents(database_key, folder_id, updated_at DESC, id ASC);
+
+      CREATE TABLE IF NOT EXISTS database_document_folders (
+        id TEXT PRIMARY KEY,
+        database_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(database_key, name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_database_document_folders_database_name
+      ON database_document_folders(database_key, name COLLATE NOCASE, id ASC);
+    `);
+  }
+
+  ensureAccessLogSchema() {
+    const row = this.db
+      .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'access_log'")
+      .get();
+    const tableSql = String(row?.sql ?? "");
+
+    if (tableSql.includes("'user'")) {
+      return;
+    }
+
+    this.db.exec(`
+      DROP TABLE IF EXISTS access_log_source_migration;
+      DROP INDEX IF EXISTS idx_access_log_started;
+      DROP INDEX IF EXISTS idx_access_log_source_started;
+      DROP INDEX IF EXISTS idx_access_log_database_started;
+
+      ALTER TABLE access_log RENAME TO access_log_source_migration;
+
+      CREATE TABLE access_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source TEXT NOT NULL CHECK(source IN ('api', 'cli', 'user')),
+        action TEXT NOT NULL,
+        database_key TEXT,
+        target_type TEXT,
+        target_name TEXT,
+        status TEXT NOT NULL CHECK(status IN ('success', 'error')),
+        started_at TEXT NOT NULL,
+        duration_ms INTEGER,
+        error_message TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      );
+
+      INSERT INTO access_log (
+        id,
+        source,
+        action,
+        database_key,
+        target_type,
+        target_name,
+        status,
+        started_at,
+        duration_ms,
+        error_message,
+        metadata_json
+      )
+      SELECT
+        id,
+        source,
+        action,
+        database_key,
+        target_type,
+        target_name,
+        status,
+        started_at,
+        duration_ms,
+        error_message,
+        metadata_json
+      FROM access_log_source_migration;
+
+      DROP TABLE access_log_source_migration;
+
+      CREATE INDEX IF NOT EXISTS idx_access_log_started
+      ON access_log(started_at DESC, id DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_access_log_source_started
+      ON access_log(source, started_at DESC, id DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_access_log_database_started
+      ON access_log(database_key, started_at DESC, id DESC);
+    `);
+  }
+
   ensureQueryRunsSchema() {
     const queryRunColumns = new Set(
       this.db
@@ -2182,7 +2387,7 @@ class AppStateStore {
     }
 
     if (actor) {
-      if (actor !== "api" && actor !== "cli") {
+      if (actor !== "api" && actor !== "cli" && actor !== "user") {
         return {
           whereSql: "WHERE 1 = 0",
           params: [],
@@ -2347,6 +2552,16 @@ class AppStateStore {
     };
   }
 
+  getLatestActivityLogTimestamp(databaseKey) {
+    const result = this.listActivityLogs({
+      databaseKey,
+      limit: 1,
+      offset: 0,
+    });
+
+    return result.items[0]?.occurredAt ?? null;
+  }
+
   updateQueryHistoryField(historyId, fieldName, value, databaseKey) {
     const normalizedDatabaseKey = this.normalizeQueryHistoryText(databaseKey);
 
@@ -2917,8 +3132,142 @@ class AppStateStore {
     });
   }
 
-  getRecentConnections() {
+  decorateConnectionTag(row = {}) {
+    return {
+      id: Number(row.id),
+      name: String(row.name ?? ""),
+      createdAt: row.createdAt ?? null,
+      updatedAt: row.updatedAt ?? null,
+      ...(row.connectionCount === undefined
+        ? {}
+        : { connectionCount: Number(row.connectionCount ?? 0) }),
+    };
+  }
+
+  getConnectionTagsByConnectionIds(connectionIds = []) {
+    const ids = connectionIds
+      .map((id) => String(id ?? "").trim())
+      .filter(Boolean)
+      .filter((id, index, values) => values.indexOf(id) === index);
+
+    if (!ids.length) {
+      return new Map();
+    }
+
+    const placeholders = ids.map(() => "?").join(", ");
+    const rows = this.db
+      .prepare(
+        `
+          SELECT
+            ct.connectionId,
+            t.id,
+            t.name,
+            t.createdAt,
+            t.updatedAt
+          FROM connection_tags ct
+          INNER JOIN tags t
+            ON t.id = ct.tagId
+          WHERE ct.connectionId IN (${placeholders})
+          ORDER BY t.name COLLATE NOCASE ASC, t.id ASC
+        `
+      )
+      .all(...ids);
+    const tagsByConnectionId = new Map(ids.map((id) => [id, []]));
+
+    for (const row of rows) {
+      tagsByConnectionId
+        .get(row.connectionId)
+        ?.push(this.decorateConnectionTag(row));
+    }
+
+    return tagsByConnectionId;
+  }
+
+  getConnectionTags(connectionId) {
+    const normalizedConnectionId = String(connectionId ?? "").trim();
+
+    if (!normalizedConnectionId) {
+      return [];
+    }
+
+    return this.getConnectionTagsByConnectionIds([normalizedConnectionId]).get(
+      normalizedConnectionId
+    ) ?? [];
+  }
+
+  listConnectionTags() {
     return this.db
+      .prepare(
+        `
+          SELECT
+            t.id,
+            t.name,
+            t.createdAt,
+            t.updatedAt,
+            COUNT(ct.connectionId) AS connectionCount
+          FROM tags t
+          LEFT JOIN connection_tags ct
+            ON ct.tagId = t.id
+          GROUP BY t.id
+          ORDER BY t.name COLLATE NOCASE ASC, t.id ASC
+        `
+      )
+      .all()
+      .map((row) => this.decorateConnectionTag(row));
+  }
+
+  getConnectionTagById(tagId) {
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, name, createdAt, updatedAt
+          FROM tags
+          WHERE id = ?
+        `
+      )
+      .get(Number(tagId));
+
+    return row ? this.decorateConnectionTag(row) : null;
+  }
+
+  getConnectionTagByName(name) {
+    const normalizedName = normalizeConnectionTagName(name);
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, name, createdAt, updatedAt
+          FROM tags
+          WHERE name = ? COLLATE NOCASE
+        `
+      )
+      .get(normalizedName);
+
+    return row ? this.decorateConnectionTag(row) : null;
+  }
+
+  getOrCreateConnectionTag(name) {
+    const normalizedName = normalizeConnectionTagName(name);
+    const existingTag = this.getConnectionTagByName(normalizedName);
+
+    if (existingTag) {
+      return existingTag;
+    }
+
+    const timestamp = new Date().toISOString();
+    const result = this.db
+      .prepare(
+        `
+          INSERT INTO tags (name, createdAt, updatedAt)
+          VALUES (?, ?, ?)
+        `
+      )
+      .run(normalizedName, timestamp, timestamp);
+
+    return this.getConnectionTagById(result.lastInsertRowid);
+  }
+
+  getRecentConnections() {
+    const rows = this.db
       .prepare(`
         SELECT
           id,
@@ -2932,8 +3281,108 @@ class AppStateStore {
         FROM recent_connections
         ORDER BY lastOpenedAt DESC, id ASC
       `)
-      .all()
-      .map((connection) => this.decorateConnection(connection));
+      .all();
+    const tagsByConnectionId = this.getConnectionTagsByConnectionIds(
+      rows.map((connection) => connection.id)
+    );
+
+    return rows.map((connection) =>
+      this.decorateConnection(
+        connection,
+        tagsByConnectionId.get(connection.id) ?? []
+      )
+    );
+  }
+
+  getRecentConnection(id) {
+    return (
+      this.getRecentConnections().find(
+        (connection) => connection.id === String(id ?? "").trim()
+      ) ?? null
+    );
+  }
+
+  assertRecentConnectionExists(id) {
+    const normalizedConnectionId = String(id ?? "").trim();
+
+    if (!normalizedConnectionId) {
+      throw new ValidationError("Connection id is required.");
+    }
+
+    const row = this.db
+      .prepare("SELECT id FROM recent_connections WHERE id = ?")
+      .get(normalizedConnectionId);
+
+    if (!row) {
+      throw new NotFoundError(`Recent connection not found: ${normalizedConnectionId}`);
+    }
+
+    return normalizedConnectionId;
+  }
+
+  setConnectionTags(connectionId, tagNames = []) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+    const normalizedTagNames = normalizeConnectionTagNames(tagNames);
+
+    this.db.transaction(() => {
+      this.db
+        .prepare("DELETE FROM connection_tags WHERE connectionId = ?")
+        .run(normalizedConnectionId);
+
+      for (const tagName of normalizedTagNames) {
+        const tag = this.getOrCreateConnectionTag(tagName);
+
+        this.db
+          .prepare(
+            `
+              INSERT OR IGNORE INTO connection_tags (connectionId, tagId)
+              VALUES (?, ?)
+            `
+          )
+          .run(normalizedConnectionId, tag.id);
+      }
+    })();
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  addConnectionTag(connectionId, tagName) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+    const tag = this.getOrCreateConnectionTag(tagName);
+
+    this.db
+      .prepare(
+        `
+          INSERT OR IGNORE INTO connection_tags (connectionId, tagId)
+          VALUES (?, ?)
+        `
+      )
+      .run(normalizedConnectionId, tag.id);
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  removeConnectionTag(connectionId, tagId) {
+    const normalizedConnectionId = this.assertRecentConnectionExists(connectionId);
+
+    this.db
+      .prepare(
+        `
+          DELETE FROM connection_tags
+          WHERE connectionId = ? AND tagId = ?
+        `
+      )
+      .run(normalizedConnectionId, Number(tagId));
+
+    return this.getConnectionTags(normalizedConnectionId);
+  }
+
+  deleteConnectionTag(tagId) {
+    const result = this.db
+      .prepare("DELETE FROM tags WHERE id = ?")
+      .run(Number(tagId));
+
+    return result.changes > 0;
   }
 
   upsertRecentConnection(connection, options = {}) {
@@ -3121,7 +3570,7 @@ class AppStateStore {
     );
   }
 
-  decorateConnection(connection = {}) {
+  decorateConnection(connection = {}, tags = []) {
     const logoPath = this.normalizeLogoPath(connection.logoPath);
 
     return {
@@ -3129,6 +3578,7 @@ class AppStateStore {
       readOnly: Boolean(connection.readOnly),
       logoPath,
       logoUrl: this.getConnectionLogoUrl(logoPath),
+      tags: Array.isArray(tags) ? tags : [],
     };
   }
 
@@ -3395,6 +3845,7 @@ class AppStateStore {
     return {
       id: String(row.id ?? ""),
       databaseKey: row.database_key ?? row.databaseKey ?? "",
+      folderId: row.folder_id ?? row.folderId ?? null,
       title: String(row.title ?? ""),
       filename: String(row.filename ?? ""),
       content: row.content === undefined ? undefined : String(row.content ?? ""),
@@ -3404,6 +3855,115 @@ class AppStateStore {
     };
   }
 
+  decorateDatabaseDocumentFolderRow(row = {}) {
+    return {
+      id: String(row.id ?? ""),
+      databaseKey: row.database_key ?? row.databaseKey ?? "",
+      name: String(row.name ?? ""),
+      createdAt: row.created_at ?? row.createdAt ?? null,
+      updatedAt: row.updated_at ?? row.updatedAt ?? null,
+    };
+  }
+
+  listDatabaseDocumentFolders(databaseKey) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+
+    return this.db
+      .prepare(
+        `
+          SELECT
+            id,
+            database_key,
+            name,
+            created_at,
+            updated_at
+          FROM database_document_folders
+          WHERE database_key = ?
+          ORDER BY name COLLATE NOCASE ASC, id ASC
+        `
+      )
+      .all(normalizedDatabaseKey)
+      .map((row) => this.decorateDatabaseDocumentFolderRow(row));
+  }
+
+  getDatabaseDocumentFolder(databaseKey, folderId) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const normalizedFolderId = normalizeDocumentFolderId(folderId);
+
+    if (!normalizedFolderId) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(
+        `
+          SELECT
+            id,
+            database_key,
+            name,
+            created_at,
+            updated_at
+          FROM database_document_folders
+          WHERE database_key = ?
+            AND id = ?
+        `
+      )
+      .get(normalizedDatabaseKey, normalizedFolderId);
+
+    if (!row) {
+      throw new NotFoundError("Document folder was not found.");
+    }
+
+    return this.decorateDatabaseDocumentFolderRow(row);
+  }
+
+  createDatabaseDocumentFolder(databaseKey, folder = {}) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const name = normalizeDocumentFolderName(folder.name);
+    const now = new Date().toISOString();
+    const id = crypto.randomUUID();
+    const existingFolder = this.db
+      .prepare(
+        `
+          SELECT id
+          FROM database_document_folders
+          WHERE database_key = ?
+            AND name = ? COLLATE NOCASE
+          LIMIT 1
+        `
+      )
+      .get(normalizedDatabaseKey, name);
+
+    if (existingFolder) {
+      throw new ConflictError("A folder with this name already exists.");
+    }
+
+    try {
+      this.db
+        .prepare(
+          `
+            INSERT INTO database_document_folders (
+              id,
+              database_key,
+              name,
+              created_at,
+              updated_at
+            )
+            VALUES (?, ?, ?, ?, ?)
+          `
+        )
+        .run(id, normalizedDatabaseKey, name, now, now);
+    } catch (error) {
+      if (error?.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        throw new ConflictError("A folder with this name already exists.");
+      }
+
+      throw error;
+    }
+
+    return this.getDatabaseDocumentFolder(normalizedDatabaseKey, id);
+  }
+
   documentFilenameExists(databaseKey, filename, ignoredDocumentId = null) {
     const row = this.db
       .prepare(
@@ -3452,6 +4012,7 @@ class AppStateStore {
           SELECT
             id,
             database_key,
+            folder_id,
             title,
             filename,
             LENGTH(content) AS content_length,
@@ -3475,6 +4036,7 @@ class AppStateStore {
           SELECT
             id,
             database_key,
+            folder_id,
             title,
             filename,
             content,
@@ -3501,6 +4063,11 @@ class AppStateStore {
       normalizedDatabaseKey,
       normalizeDocumentFilename(document.filename)
     );
+    const folderId = normalizeDocumentFolderId(document.folderId);
+    if (folderId) {
+      this.getDatabaseDocumentFolder(normalizedDatabaseKey, folderId);
+    }
+
     const title = normalizeDocumentTitle(document.title, filename);
     const content = normalizeDocumentContent(document.content);
     const now = new Date().toISOString();
@@ -3512,16 +4079,17 @@ class AppStateStore {
           INSERT INTO database_documents (
             id,
             database_key,
+            folder_id,
             title,
             filename,
             content,
             created_at,
             updated_at
           )
-          VALUES (?, ?, ?, ?, ?, ?, ?)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         `
       )
-      .run(id, normalizedDatabaseKey, title, filename, content, now, now);
+      .run(id, normalizedDatabaseKey, folderId, title, filename, content, now, now);
 
     return this.getDatabaseDocument(normalizedDatabaseKey, id);
   }
@@ -3532,6 +4100,15 @@ class AppStateStore {
     const hasFilename = Object.prototype.hasOwnProperty.call(patch, "filename");
     const hasTitle = Object.prototype.hasOwnProperty.call(patch, "title");
     const hasContent = Object.prototype.hasOwnProperty.call(patch, "content");
+    const hasFolderId = Object.prototype.hasOwnProperty.call(patch, "folderId");
+    const folderId = hasFolderId
+      ? normalizeDocumentFolderId(patch.folderId)
+      : existingDocument.folderId;
+
+    if (folderId) {
+      this.getDatabaseDocumentFolder(normalizedDatabaseKey, folderId);
+    }
+
     const filename = hasFilename
       ? this.resolveUniqueDocumentFilename(
           normalizedDatabaseKey,
@@ -3554,6 +4131,7 @@ class AppStateStore {
         `
           UPDATE database_documents
           SET
+            folder_id = ?,
             title = ?,
             filename = ?,
             content = ?,
@@ -3562,7 +4140,7 @@ class AppStateStore {
             AND id = ?
         `
       )
-      .run(title, filename, content, updatedAt, normalizedDatabaseKey, existingDocument.id);
+      .run(folderId, title, filename, content, updatedAt, normalizedDatabaseKey, existingDocument.id);
 
     return this.getDatabaseDocument(normalizedDatabaseKey, existingDocument.id);
   }
@@ -3696,4 +4274,6 @@ class AppStateStore {
 module.exports = {
   AppStateStore,
   DEFAULT_STATE,
+  MAX_CONNECTION_TAG_NAME_LENGTH,
+  normalizeConnectionTagName,
 };