@surveilr/bootstrap-sql 0.0.1

package/dist/chunk-QTY32BJY.js

@@ -0,0 +1,844 @@
+import {
+  codeNotebookCell,
+  codeNotebookState,
+  device,
+  orchestrationNature,
+  orchestrationSession,
+  orchestrationSessionEntry,
+  orchestrationSessionExec,
+  orchestrationSessionIssue,
+  orchestrationSessionLog,
+  orchestrationSessionState,
+  uniformResource,
+  uniformResourceEdge,
+  uniformResourceGraph,
+  urIngestSession,
+  urIngestSessionFsPath,
+  urIngestSessionFsPathEntry,
+  urIngestSessionImapAccount,
+  urIngestSessionImapAcctFolder,
+  urIngestSessionImapAcctFolderMessage,
+  urIngestSessionTask
+} from "./chunk-HZLAQ5XF.js";
+
+// views.ts
+import { sqliteView } from "drizzle-orm/sqlite-core";
+import { sql, count, min, max, sum, eq, and } from "drizzle-orm";
+var codeNotebookCellVersions = sqliteView("code_notebook_cell_versions").as((qb) => {
+  return qb.select({
+    notebookName: codeNotebookCell.notebookName,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    cellName: codeNotebookCell.cellName,
+    versions: sql`COUNT(*) OVER(PARTITION BY ${codeNotebookCell.notebookName}, ${codeNotebookCell.cellName})`.as("versions"),
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId
+  }).from(codeNotebookCell).orderBy(codeNotebookCell.notebookName, codeNotebookCell.cellName);
+});
+var codeNotebookCellLatest = sqliteView("code_notebook_cell_latest").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    versionTimestamp: sql`COALESCE(${codeNotebookCell.updatedAt}, ${codeNotebookCell.createdAt})`.as("version_timestamp")
+  }).from(codeNotebookCell).where(sql`${codeNotebookCell.codeNotebookCellId} IN (
+      SELECT code_notebook_cell_id 
+      FROM (
+        SELECT code_notebook_cell_id,
+               ROW_NUMBER() OVER (
+                 PARTITION BY code_notebook_cell_id
+                 ORDER BY COALESCE(updated_at, created_at) DESC
+               ) AS rn
+        FROM code_notebook_cell
+      ) ranked WHERE rn = 1
+    )`);
+});
+var codeNotebookSqlCellMigratableVersion = sqliteView("code_notebook_sql_cell_migratable_version").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    isIdempotent: sql`CASE WHEN ${codeNotebookCell.cellName} LIKE '%_once_%' THEN FALSE ELSE TRUE END`.as("is_idempotent"),
+    versionTimestamp: sql`COALESCE(${codeNotebookCell.updatedAt}, ${codeNotebookCell.createdAt})`.as("version_timestamp")
+  }).from(codeNotebookCell).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratable = sqliteView("code_notebook_sql_cell_migratable").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    isIdempotent: sql`CASE WHEN ${codeNotebookCell.cellName} LIKE '%_once_%' THEN FALSE ELSE TRUE END`.as("is_idempotent")
+  }).from(codeNotebookCell).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratableState = sqliteView("code_notebook_sql_cell_migratable_state").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    fromState: codeNotebookState.fromState,
+    toState: codeNotebookState.toState,
+    transitionReason: codeNotebookState.transitionReason,
+    transitionResult: codeNotebookState.transitionResult,
+    transitionedAt: codeNotebookState.transitionedAt
+  }).from(codeNotebookCell).innerJoin(codeNotebookState, eq(codeNotebookCell.codeNotebookCellId, codeNotebookState.codeNotebookCellId)).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratableNotExecuted = sqliteView("code_notebook_sql_cell_migratable_not_executed").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog
+  }).from(codeNotebookCell).leftJoin(codeNotebookState, and(
+    eq(codeNotebookCell.codeNotebookCellId, codeNotebookState.codeNotebookCellId),
+    eq(codeNotebookState.toState, "EXECUTED")
+  )).where(
+    and(
+      eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook"),
+      sql`${codeNotebookState.codeNotebookCellId} IS NULL`
+    )
+  ).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookMigrationSql = sqliteView("code_notebook_migration_sql", {}).as(sql`
+  SELECT 'BEGIN TRANSACTION;
+
+  ' ||
+        'CREATE TEMP TABLE IF NOT EXISTS "session_state_ephemeral" (
+      "key" TEXT PRIMARY KEY NOT NULL,
+      "value" TEXT NOT NULL
+    );
+
+    ' ||
+        GROUP_CONCAT(
+          CASE
+            -- Case 1: Non-idempotent and already executed
+            WHEN c.is_idempotent = FALSE AND s.code_notebook_cell_id IS NOT NULL THEN
+              '-- ' || c.notebook_name || '.' || c.cell_name || ' not included because it is non-idempotent and was already executed on ' || s.transitioned_at || '
+
+  '
+            -- Case 2: Idempotent and not yet executed, idempotent and being reapplied, or non-idempotent and being run for the first time
+            ELSE
+              '-- ' || c.notebook_name || '.' || c.cell_name || '
+  ' ||
+              CASE
+                -- First execution (non-idempotent or idempotent)
+                WHEN s.code_notebook_cell_id IS NULL THEN
+                  '-- Executing for the first time.
+  '
+                -- Reapplying execution (idempotent)
+                ELSE
+                  '-- Reapplying execution. Last executed on ' || s.transitioned_at || '
+  '
+              END ||
+              c.interpretable_code || '
+  ' ||
+              'INSERT INTO code_notebook_state (code_notebook_state_id, code_notebook_cell_id, from_state, to_state, transition_reason, created_at) ' ||
+              'VALUES (' ||
+              '''' || c.code_notebook_cell_id || '__' || strftime('%Y%m%d%H%M%S', 'now') || '''' || ', ' ||
+              '''' || c.code_notebook_cell_id || '''' || ', ' ||
+              '''MIGRATION_CANDIDATE''' || ', ' ||
+              '''EXECUTED''' || ', ' ||
+              CASE
+                WHEN s.code_notebook_cell_id IS NULL THEN '''Migration'''
+                ELSE '''Reapplication'''
+              END || ', ' ||
+              'CURRENT_TIMESTAMP' || ')' || '
+  ' ||
+              'ON CONFLICT(code_notebook_cell_id, from_state, to_state) DO UPDATE SET updated_at = CURRENT_TIMESTAMP, ' ||
+                'transition_reason = ''Reapplied ' || datetime('now', 'localtime') || ''';' || '
+  '
+          END,
+          '
+  '
+        ) || '
+
+  COMMIT;' as migration_sql 
+  FROM code_notebook_sql_cell_migratable c
+  LEFT JOIN code_notebook_state s
+    ON c.code_notebook_cell_id = s.code_notebook_cell_id AND s.to_state = 'EXECUTED'
+  ORDER BY c.cell_name`);
+var imapGraph = sqliteView("imap_graph").as((qb) => {
+  return qb.select({
+    graphName: uniformResourceEdge.graphName,
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    uri: uniformResource.uri,
+    content: uniformResource.content,
+    urIngestSessionImapAcctFolderMessageId: urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId,
+    ingestImapAcctFolderId: urIngestSessionImapAcctFolderMessage.ingestImapAcctFolderId,
+    messageId: urIngestSessionImapAcctFolderMessage.messageId
+  }).from(uniformResourceEdge).innerJoin(uniformResource, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(urIngestSessionImapAcctFolderMessage, eq(uniformResourceEdge.nodeId, urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId)).where(eq(uniformResourceEdge.graphName, "imap"));
+});
+var filesystemGraph = sqliteView("filesystem_graph").as((qb) => {
+  return qb.select({
+    graphName: uniformResourceEdge.graphName,
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    uri: uniformResource.uri,
+    urIngestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    rootPath: urIngestSessionFsPath.rootPath
+  }).from(uniformResourceEdge).innerJoin(uniformResource, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(urIngestSessionFsPath, eq(uniformResourceEdge.nodeId, urIngestSessionFsPath.urIngestSessionFsPathId)).where(eq(uniformResourceEdge.graphName, "filesystem"));
+});
+var consoleInformationSchemaTable = sqliteView("console_information_schema_table", {}).as(sql`
+  SELECT
+    tbl.name AS table_name,
+    col.name AS column_name,
+    col.type AS data_type,
+    CASE WHEN col.pk = 1 THEN 'Yes' ELSE 'No' END AS is_primary_key,
+    CASE WHEN col."notnull" = 1 THEN 'Yes' ELSE 'No' END AS is_not_null,
+    col.dflt_value AS default_value,
+    'console/info-schema/table.sql?name=' || tbl.name || '&stats=yes' as info_schema_web_ui_path,
+    '[Content](console/info-schema/table.sql?name=' || tbl.name || '&stats=yes)' as info_schema_link_abbrev_md,
+    '[' || tbl.name || ' (table) Schema](console/info-schema/table.sql?name=' || tbl.name || '&stats=yes)' as info_schema_link_full_md,
+    'console/content/table/' || tbl.name || '.sql?stats=yes' as content_web_ui_path,
+    '[Content]($SITE_PREFIX_URL/console/content/table/' || tbl.name || '.sql?stats=yes)' as content_web_ui_link_abbrev_md,
+    '[' || tbl.name || ' (table) Content](console/content/table/' || tbl.name || '.sql?stats=yes)' as content_web_ui_link_full_md,
+    tbl.sql as sql_ddl
+  FROM sqlite_master tbl
+  JOIN pragma_table_info(tbl.name) col
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var consoleInformationSchemaView = sqliteView("console_information_schema_view", {}).as(sql`
+  SELECT
+    vw.name AS view_name,
+    col.name AS column_name,
+    col.type AS data_type,
+    '/console/info-schema/view.sql?name=' || vw.name || '&stats=yes' as info_schema_web_ui_path,
+    '[Content](console/info-schema/view.sql?name=' || vw.name || '&stats=yes)' as info_schema_link_abbrev_md,
+    '[' || vw.name || ' (view) Schema](console/info-schema/view.sql?name=' || vw.name || '&stats=yes)' as info_schema_link_full_md,
+    '/console/content/view/' || vw.name || '.sql?stats=yes' as content_web_ui_path,
+    '[Content]($SITE_PREFIX_URL/console/content/view/' || vw.name || '.sql?stats=yes)' as content_web_ui_link_abbrev_md,
+    '[' || vw.name || ' (view) Content](console/content/view/' || vw.name || '.sql?stats=yes)' as content_web_ui_link_full_md,
+    vw.sql as sql_ddl
+  FROM sqlite_master vw
+  JOIN pragma_table_info(vw.name) col
+  WHERE vw.type = 'view' AND vw.name NOT LIKE 'sqlite_%'
+`);
+var consoleContentTabular = sqliteView("console_content_tabular").as((qb) => {
+  const tableQuery = qb.select({
+    tabularNature: sql`'table'`.as("tabular_nature"),
+    tabularName: sql`table_name`.as("tabular_name"),
+    infoSchemaWebUiPath: sql`info_schema_web_ui_path`.as("info_schema_web_ui_path"),
+    infoSchemaLinkAbbrevMd: sql`info_schema_link_abbrev_md`.as("info_schema_link_abbrev_md"),
+    infoSchemaLinkFullMd: sql`info_schema_link_full_md`.as("info_schema_link_full_md"),
+    contentWebUiPath: sql`content_web_ui_path`.as("content_web_ui_path"),
+    contentWebUiLinkAbbrevMd: sql`content_web_ui_link_abbrev_md`.as("content_web_ui_link_abbrev_md"),
+    contentWebUiLinkFullMd: sql`content_web_ui_link_full_md`.as("content_web_ui_link_full_md")
+  }).from(consoleInformationSchemaTable);
+  const viewQuery = qb.select({
+    tabularNature: sql`'view'`.as("tabular_nature"),
+    tabularName: sql`view_name`.as("tabular_name"),
+    infoSchemaWebUiPath: sql`info_schema_web_ui_path`.as("info_schema_web_ui_path"),
+    infoSchemaLinkAbbrevMd: sql`info_schema_link_abbrev_md`.as("info_schema_link_abbrev_md"),
+    infoSchemaLinkFullMd: sql`info_schema_link_full_md`.as("info_schema_link_full_md"),
+    contentWebUiPath: sql`content_web_ui_path`.as("content_web_ui_path"),
+    contentWebUiLinkAbbrevMd: sql`content_web_ui_link_abbrev_md`.as("content_web_ui_link_abbrev_md"),
+    contentWebUiLinkFullMd: sql`content_web_ui_link_full_md`.as("content_web_ui_link_full_md")
+  }).from(consoleInformationSchemaView);
+  return tableQuery.unionAll(viewQuery);
+});
+var consoleInformationSchemaTableColFkey = sqliteView("console_information_schema_table_col_fkey", {}).as(sql`
+  SELECT
+    tbl.name AS table_name,
+    f."from" AS column_name,
+    f."from" || ' references ' || f."table" || '.' || f."to" AS foreign_key
+  FROM sqlite_master tbl
+  JOIN pragma_foreign_key_list(tbl.name) f
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var consoleInformationSchemaTableColIndex = sqliteView("console_information_schema_table_col_index", {}).as(sql`
+  SELECT
+    tbl.name AS table_name,
+    pi.name AS column_name,
+    idx.name AS index_name
+  FROM sqlite_master tbl
+  JOIN pragma_index_list(tbl.name) idx
+  JOIN pragma_index_info(idx.name) pi
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var rssdStatisticsOverview = sqliteView("rssd_statistics_overview").as((qb) => {
+  return qb.select({
+    dbSizeMb: sql`(SELECT ROUND(page_count * page_size / (1024.0 * 1024), 2) FROM pragma_page_count(), pragma_page_size())`.as("db_size_mb"),
+    dbSizeGb: sql`(SELECT ROUND(page_count * page_size / (1024.0 * 1024 * 1024), 4) FROM pragma_page_count(), pragma_page_size())`.as("db_size_gb"),
+    totalTables: sql`(SELECT COUNT(*) FROM sqlite_master WHERE type = 'table')`.as("total_tables"),
+    totalIndexes: sql`(SELECT COUNT(*) FROM sqlite_master WHERE type = 'index')`.as("total_indexes"),
+    totalRows: sql`(SELECT SUM(tbl_rows) FROM (SELECT name, (SELECT COUNT(*) FROM sqlite_master sm WHERE sm.type='table' AND sm.name=t.name) AS tbl_rows FROM sqlite_master t WHERE type='table'))`.as("total_rows"),
+    pageSize: sql`(SELECT page_size FROM pragma_page_size())`.as("page_size"),
+    totalPages: sql`(SELECT page_count FROM pragma_page_count())`.as("total_pages")
+  }).from(sql`(SELECT 1) AS dummy`);
+});
+var rssdTableStatistic = sqliteView("rssd_table_statistic", {}).as(sql`
+  SELECT 
+    m.name AS table_name,
+    (SELECT COUNT(*) FROM pragma_table_info(m.name)) AS total_columns,
+    (SELECT COUNT(*) FROM pragma_index_list(m.name)) AS total_indexes,
+    (SELECT COUNT(*) FROM pragma_foreign_key_list(m.name)) AS foreign_keys,
+    (SELECT COUNT(*) FROM pragma_table_info(m.name) WHERE pk != 0) AS primary_keys,
+    (SELECT table_size_mb FROM surveilr_table_size WHERE table_name = m.name) AS table_size_mb
+  FROM sqlite_master m
+  WHERE m.type = 'table'
+`);
+var uniformResourceFile = sqliteView("uniform_resource_file").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    sourcePath: urIngestSessionFsPath.rootPath,
+    filePathRel: urIngestSessionFsPathEntry.filePathRel,
+    sizeBytes: uniformResource.sizeBytes
+  }).from(uniformResource).leftJoin(
+    uniformResourceEdge,
+    and(
+      eq(uniformResource.uniformResourceId, uniformResourceEdge.uniformResourceId),
+      eq(uniformResourceEdge.nature, "ingest_fs_path")
+    )
+  ).leftJoin(urIngestSessionFsPath, eq(uniformResourceEdge.nodeId, urIngestSessionFsPath.urIngestSessionFsPathId)).leftJoin(urIngestSessionFsPathEntry, eq(uniformResource.uniformResourceId, urIngestSessionFsPathEntry.uniformResourceId));
+});
+var uniformResourceImap = sqliteView("uniform_resource_imap").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResource.uniformResourceId,
+    graphName: uniformResourceGraph.name,
+    urIngestSessionImapAccountId: urIngestSessionImapAccount.urIngestSessionImapAccountId,
+    email: urIngestSessionImapAccount.email,
+    host: urIngestSessionImapAccount.host,
+    subject: urIngestSessionImapAcctFolderMessage.subject,
+    from: urIngestSessionImapAcctFolderMessage.from,
+    message: urIngestSessionImapAcctFolderMessage.message,
+    date: urIngestSessionImapAcctFolderMessage.date,
+    urIngestSessionImapAcctFolderId: urIngestSessionImapAcctFolder.urIngestSessionImapAcctFolderId,
+    ingestAccountId: urIngestSessionImapAcctFolder.ingestAccountId,
+    folderName: urIngestSessionImapAcctFolder.folderName,
+    sizeBytes: uniformResource.sizeBytes,
+    nature: uniformResource.nature,
+    content: uniformResource.content
+  }).from(uniformResource).innerJoin(uniformResourceEdge, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(uniformResourceGraph, eq(uniformResourceGraph.name, uniformResourceEdge.graphName)).innerJoin(urIngestSessionImapAcctFolderMessage, eq(urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId, uniformResourceEdge.nodeId)).innerJoin(urIngestSessionImapAcctFolder, eq(urIngestSessionImapAcctFolderMessage.ingestImapAcctFolderId, urIngestSessionImapAcctFolder.urIngestSessionImapAcctFolderId)).leftJoin(urIngestSessionImapAccount, eq(urIngestSessionImapAccount.urIngestSessionImapAccountId, urIngestSessionImapAcctFolder.ingestAccountId)).where(and(
+    eq(uniformResource.nature, "text"),
+    eq(uniformResourceGraph.name, "imap"),
+    sql`${uniformResource.ingestSessionImapAcctFolderMessage} IS NOT NULL`
+  ));
+});
+var uniformResourceImapContent = sqliteView("uniform_resource_imap_content").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResourceImap.uniformResourceId,
+    baseId: sql`base_ur.uniform_resource_id`.as("base_id"),
+    extId: sql`ext_ur.uniform_resource_id`.as("ext_id"),
+    baseUri: sql`base_ur.uri`.as("base_uri"),
+    extUri: sql`ext_ur.uri`.as("ext_uri"),
+    baseNature: sql`base_ur.nature`.as("base_nature"),
+    extNature: sql`ext_ur.nature`.as("ext_nature"),
+    htmlContent: sql`json_extract(part.value, '$.body.Html')`.as("html_content")
+  }).from(uniformResourceImap).innerJoin(sql`uniform_resource base_ur`, sql`base_ur.uniform_resource_id = ${uniformResourceImap.uniformResourceId}`).innerJoin(sql`uniform_resource ext_ur`, sql`ext_ur.uri = base_ur.uri || '/json' AND ext_ur.nature = 'json'`).crossJoin(sql`json_each(ext_ur.content, '$.parts') AS part`).where(and(
+    sql`ext_ur.nature = 'json'`,
+    sql`json_extract(part.value, '$.body.Html') IS NOT NULL`
+  ));
+});
+var urIngestSessionFilesStats = sqliteView("ur_ingest_session_files_stats").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    ingestSessionId: urIngestSession.urIngestSessionId,
+    ingestSessionStartedAt: urIngestSession.ingestStartedAt,
+    ingestSessionFinishedAt: urIngestSession.ingestFinishedAt,
+    fileExtension: sql`COALESCE(${urIngestSessionFsPathEntry.fileExtn}, '')`.as("file_extension"),
+    ingestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    ingestSessionRootFsPath: urIngestSessionFsPath.rootPath,
+    totalFileCount: count(urIngestSessionFsPathEntry.uniformResourceId).as("total_file_count"),
+    fileCountWithContent: sum(sql`CASE WHEN ${uniformResource.content} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_content"),
+    fileCountWithFrontmatter: sum(sql`CASE WHEN ${uniformResource.frontmatter} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_frontmatter"),
+    minFileSizeBytes: min(uniformResource.sizeBytes).as("min_file_size_bytes"),
+    averageFileSizeBytes: sql`CAST(ROUND(AVG(${uniformResource.sizeBytes})) AS INTEGER)`.as("average_file_size_bytes"),
+    maxFileSizeBytes: max(uniformResource.sizeBytes).as("max_file_size_bytes"),
+    oldestFileLastModifiedDatetime: min(uniformResource.lastModifiedAt).as("oldest_file_last_modified_datetime"),
+    youngestFileLastModifiedDatetime: max(uniformResource.lastModifiedAt).as("youngest_file_last_modified_datetime")
+  }).from(urIngestSession).innerJoin(device, eq(urIngestSession.deviceId, device.deviceId)).leftJoin(urIngestSessionFsPath, eq(urIngestSession.urIngestSessionId, urIngestSessionFsPath.ingestSessionId)).leftJoin(urIngestSessionFsPathEntry, eq(urIngestSessionFsPath.urIngestSessionFsPathId, urIngestSessionFsPathEntry.ingestFsPathId)).leftJoin(uniformResource, eq(urIngestSessionFsPathEntry.uniformResourceId, uniformResource.uniformResourceId)).groupBy(
+    device.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSession.ingestStartedAt,
+    urIngestSession.ingestFinishedAt,
+    urIngestSessionFsPathEntry.fileExtn,
+    urIngestSessionFsPath.rootPath
+  ).orderBy(device.deviceId, urIngestSession.ingestFinishedAt, urIngestSessionFsPathEntry.fileExtn);
+});
+var urIngestSessionFilesStatsLatest = sqliteView("ur_ingest_session_files_stats_latest").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSessionFilesStats.deviceId,
+    ingestSessionId: urIngestSessionFilesStats.ingestSessionId,
+    ingestSessionStartedAt: urIngestSessionFilesStats.ingestSessionStartedAt,
+    ingestSessionFinishedAt: urIngestSessionFilesStats.ingestSessionFinishedAt,
+    fileExtension: urIngestSessionFilesStats.fileExtension,
+    ingestSessionFsPathId: urIngestSessionFilesStats.ingestSessionFsPathId,
+    ingestSessionRootFsPath: urIngestSessionFilesStats.ingestSessionRootFsPath,
+    totalFileCount: urIngestSessionFilesStats.totalFileCount,
+    fileCountWithContent: urIngestSessionFilesStats.fileCountWithContent,
+    fileCountWithFrontmatter: urIngestSessionFilesStats.fileCountWithFrontmatter,
+    minFileSizeBytes: urIngestSessionFilesStats.minFileSizeBytes,
+    averageFileSizeBytes: urIngestSessionFilesStats.averageFileSizeBytes,
+    maxFileSizeBytes: urIngestSessionFilesStats.maxFileSizeBytes,
+    oldestFileLastModifiedDatetime: urIngestSessionFilesStats.oldestFileLastModifiedDatetime,
+    youngestFileLastModifiedDatetime: urIngestSessionFilesStats.youngestFileLastModifiedDatetime
+  }).from(urIngestSessionFilesStats).where(sql`${urIngestSessionFilesStats.ingestSessionId} IN (
+      SELECT ${urIngestSession.urIngestSessionId}
+      FROM ${urIngestSession}
+      ORDER BY ${urIngestSession.ingestFinishedAt} DESC
+      LIMIT 1
+    )`);
+});
+var urIngestSessionTasksStats = sqliteView("ur_ingest_session_tasks_stats").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    ingestSessionId: urIngestSession.urIngestSessionId,
+    ingestSessionStartedAt: urIngestSession.ingestStartedAt,
+    ingestSessionFinishedAt: urIngestSession.ingestFinishedAt,
+    urStatus: sql`COALESCE(${urIngestSessionTask.urStatus}, 'Ok')`.as("ur_status"),
+    nature: sql`COALESCE(${uniformResource.nature}, 'UNKNOWN')`.as("nature"),
+    totalFileCount: count(urIngestSessionTask.uniformResourceId).as("total_file_count"),
+    fileCountWithContent: sum(sql`CASE WHEN ${uniformResource.content} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_content"),
+    fileCountWithFrontmatter: sum(sql`CASE WHEN ${uniformResource.frontmatter} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_frontmatter"),
+    minFileSizeBytes: min(uniformResource.sizeBytes).as("min_file_size_bytes"),
+    averageFileSizeBytes: sql`CAST(ROUND(AVG(${uniformResource.sizeBytes})) AS INTEGER)`.as("average_file_size_bytes"),
+    maxFileSizeBytes: max(uniformResource.sizeBytes).as("max_file_size_bytes"),
+    oldestFileLastModifiedDatetime: min(uniformResource.lastModifiedAt).as("oldest_file_last_modified_datetime"),
+    youngestFileLastModifiedDatetime: max(uniformResource.lastModifiedAt).as("youngest_file_last_modified_datetime")
+  }).from(urIngestSession).innerJoin(device, eq(urIngestSession.deviceId, device.deviceId)).leftJoin(urIngestSessionTask, eq(urIngestSession.urIngestSessionId, urIngestSessionTask.ingestSessionId)).leftJoin(uniformResource, eq(urIngestSessionTask.uniformResourceId, uniformResource.uniformResourceId)).groupBy(
+    device.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSession.ingestStartedAt,
+    urIngestSession.ingestFinishedAt,
+    urIngestSessionTask.capturedExecutable
+  ).orderBy(device.deviceId, urIngestSession.ingestFinishedAt, urIngestSessionTask.urStatus);
+});
+var urIngestSessionTasksStatsLatest = sqliteView("ur_ingest_session_tasks_stats_latest").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSessionTasksStats.deviceId,
+    ingestSessionId: urIngestSessionTasksStats.ingestSessionId,
+    ingestSessionStartedAt: urIngestSessionTasksStats.ingestSessionStartedAt,
+    ingestSessionFinishedAt: urIngestSessionTasksStats.ingestSessionFinishedAt,
+    urStatus: urIngestSessionTasksStats.urStatus,
+    nature: urIngestSessionTasksStats.nature,
+    totalFileCount: urIngestSessionTasksStats.totalFileCount,
+    fileCountWithContent: urIngestSessionTasksStats.fileCountWithContent,
+    fileCountWithFrontmatter: urIngestSessionTasksStats.fileCountWithFrontmatter,
+    minFileSizeBytes: urIngestSessionTasksStats.minFileSizeBytes,
+    averageFileSizeBytes: urIngestSessionTasksStats.averageFileSizeBytes,
+    maxFileSizeBytes: urIngestSessionTasksStats.maxFileSizeBytes,
+    oldestFileLastModifiedDatetime: urIngestSessionTasksStats.oldestFileLastModifiedDatetime,
+    youngestFileLastModifiedDatetime: urIngestSessionTasksStats.youngestFileLastModifiedDatetime
+  }).from(urIngestSessionTasksStats).where(sql`${urIngestSessionTasksStats.ingestSessionId} IN (
+      SELECT ${urIngestSession.urIngestSessionId}
+      FROM ${urIngestSession}
+      ORDER BY ${urIngestSession.ingestFinishedAt} DESC
+      LIMIT 1
+    )`);
+});
+var urIngestSessionFileIssue = sqliteView("ur_ingest_session_file_issue").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSession.deviceId,
+    urIngestSessionId: urIngestSession.urIngestSessionId,
+    urIngestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    rootPath: urIngestSessionFsPath.rootPath,
+    urIngestSessionFsPathEntryId: urIngestSessionFsPathEntry.urIngestSessionFsPathEntryId,
+    filePathAbs: urIngestSessionFsPathEntry.filePathAbs,
+    urStatus: urIngestSessionFsPathEntry.urStatus,
+    urDiagnostics: urIngestSessionFsPathEntry.urDiagnostics
+  }).from(urIngestSessionFsPathEntry).innerJoin(urIngestSessionFsPath, eq(urIngestSessionFsPathEntry.ingestFsPathId, urIngestSessionFsPath.urIngestSessionFsPathId)).innerJoin(urIngestSession, eq(urIngestSessionFsPath.ingestSessionId, urIngestSession.urIngestSessionId)).where(sql`${urIngestSessionFsPathEntry.urStatus} IS NOT NULL`).groupBy(
+    urIngestSession.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSessionFsPath.urIngestSessionFsPathId,
+    urIngestSessionFsPath.rootPath,
+    urIngestSessionFsPathEntry.urIngestSessionFsPathEntryId,
+    urIngestSessionFsPathEntry.filePathAbs,
+    urIngestSessionFsPathEntry.urStatus,
+    urIngestSessionFsPathEntry.urDiagnostics
+  );
+});
+var orchestrationSessionByDevice = sqliteView("orchestration_session_by_device").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    deviceName: device.name,
+    sessionCount: count(orchestrationSession.orchestrationSessionId).as("session_count")
+  }).from(orchestrationSession).innerJoin(device, eq(orchestrationSession.deviceId, device.deviceId)).groupBy(device.deviceId, device.name);
+});
+var orchestrationSessionDuration = sqliteView("orchestration_session_duration").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    orchStartedAt: orchestrationSession.orchStartedAt,
+    orchFinishedAt: orchestrationSession.orchFinishedAt,
+    durationSeconds: sql`(JULIANDAY(${orchestrationSession.orchFinishedAt}) - JULIANDAY(${orchestrationSession.orchStartedAt})) * 24 * 60 * 60`.as("duration_seconds")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).where(sql`${orchestrationSession.orchFinishedAt} IS NOT NULL`);
+});
+var orchestrationSuccessRate = sqliteView("orchestration_success_rate").as((qb) => {
+  return qb.select({
+    orchestrationNature: orchestrationNature.nature,
+    totalSessions: count().as("total_sessions"),
+    successfulSessions: sum(sql`CASE WHEN ${orchestrationSessionState.toState} = 'surveilr_orch_completed' THEN 1 ELSE 0 END`).as("successful_sessions"),
+    successRate: sql`(CAST(SUM(CASE WHEN ${orchestrationSessionState.toState} = 'surveilr_orch_completed' THEN 1 ELSE 0 END) AS FLOAT) / COUNT(*)) * 100`.as("success_rate")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionState, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionState.sessionId)).where(sql`${orchestrationSessionState.toState} IN ('surveilr_orch_completed', 'surveilr_orch_failed')`).groupBy(orchestrationNature.nature);
+});
+var orchestrationSessionScript = sqliteView("orchestration_session_script").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    scriptCount: count(orchestrationSessionEntry.orchestrationSessionEntryId).as("script_count")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionEntry, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionEntry.sessionId)).groupBy(orchestrationSession.orchestrationSessionId, orchestrationNature.nature);
+});
+var orchestrationExecutionsByType = sqliteView("orchestration_executions_by_type").as((qb) => {
+  return qb.select({
+    execNature: orchestrationSessionExec.execNature,
+    executionCount: count(orchestrationSessionExec.orchestrationSessionExecId).as("execution_count")
+  }).from(orchestrationSessionExec).groupBy(orchestrationSessionExec.execNature);
+});
+var orchestrationExecutionSuccessRateByType = sqliteView("orchestration_execution_success_rate_by_type").as((qb) => {
+  return qb.select({
+    execNature: orchestrationSessionExec.execNature,
+    totalExecutions: count().as("total_executions"),
+    successfulExecutions: sum(sql`CASE WHEN ${orchestrationSessionExec.execStatus} = 0 THEN 1 ELSE 0 END`).as("successful_executions"),
+    successRate: sql`(CAST(SUM(CASE WHEN ${orchestrationSessionExec.execStatus} = 0 THEN 1 ELSE 0 END) AS FLOAT) / COUNT(*)) * 100`.as("success_rate")
+  }).from(orchestrationSessionExec).groupBy(orchestrationSessionExec.execNature);
+});
+var orchestrationSessionSummary = sqliteView("orchestration_session_summary").as((qb) => {
+  return qb.select({
+    issueType: orchestrationSessionIssue.issueType,
+    issueCount: count(orchestrationSessionIssue.orchestrationSessionIssueId).as("issue_count")
+  }).from(orchestrationSessionIssue).groupBy(orchestrationSessionIssue.issueType);
+});
+var orchestrationIssueRemediation = sqliteView("orchestration_issue_remediation").as((qb) => {
+  return qb.select({
+    orchestrationSessionIssueId: orchestrationSessionIssue.orchestrationSessionIssueId,
+    issueType: orchestrationSessionIssue.issueType,
+    issueMessage: orchestrationSessionIssue.issueMessage,
+    remediation: orchestrationSessionIssue.remediation
+  }).from(orchestrationSessionIssue).where(sql`${orchestrationSessionIssue.remediation} IS NOT NULL`);
+});
+var orchestrationLogsBySession = sqliteView("orchestration_logs_by_session").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    category: orchestrationSessionLog.category,
+    logCount: count(orchestrationSessionLog.orchestrationSessionLogId).as("log_count")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionExec, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionExec.sessionId)).innerJoin(orchestrationSessionLog, eq(orchestrationSessionExec.orchestrationSessionExecId, orchestrationSessionLog.parentExecId)).groupBy(orchestrationSession.orchestrationSessionId, orchestrationNature.nature, orchestrationSessionLog.category);
+});
+var emailMessagesWithTimezone = sqliteView("email_messages_with_timezone", {}).as(sql`
+SELECT
+    m.*,
+    -- Smart timezone conversion based on original timezone
+    CASE
+        -- If already IST (+0530), just extract the time
+        WHEN date LIKE '%+0530%' THEN substr(date, 18, 8)
+        -- If UTC (+0000), convert to IST
+        WHEN date LIKE '%+0000%' THEN time(substr(date, 18, 8), '+5 hours', '+30 minutes')
+        -- If EST (-0500), convert to IST
+        WHEN date LIKE '%-0500%' THEN time(substr(date, 18, 8), '+10 hours', '+30 minutes')
+        -- If PST (-0800), convert to IST
+        WHEN date LIKE '%-0800%' THEN time(substr(date, 18, 8), '+13 hours', '+30 minutes')
+        -- Default: assume UTC and convert
+        ELSE time(substr(date, 18, 8), '+5 hours', '+30 minutes')
+    END as ist_time,
+
+    -- Always show UTC time (convert from any timezone to UTC first)
+    CASE
+        WHEN date LIKE '%+0530%' THEN time(substr(date, 18, 8), '-5 hours', '-30 minutes')
+        WHEN date LIKE '%+0000%' THEN substr(date, 18, 8)
+        WHEN date LIKE '%-0500%' THEN time(substr(date, 18, 8), '+5 hours')
+        WHEN date LIKE '%-0800%' THEN time(substr(date, 18, 8), '+8 hours')
+        ELSE substr(date, 18, 8)
+    END as utc_time,
+
+    -- Detect original timezone more accurately
+    CASE
+        WHEN date LIKE '%+0530%' THEN 'IST'
+        WHEN date LIKE '%+0000%' THEN 'UTC'
+        WHEN date LIKE '%-0500%' THEN 'EST'
+        WHEN date LIKE '%-0800%' THEN 'PST'
+        ELSE 'Unknown'
+    END as detected_timezone
+FROM ur_ingest_session_imap_acct_folder_message m`);
+var deviceGraphOverview = sqliteView("device_graph_overview", {}).as(sql`
+SELECT
+    'snmp_device' as device_type,
+    sd.device_key as device_id,
+    sd.snmp_host as primary_identifier,
+    sd.device_type as device_category,
+    sd.device_description as description,
+    sd.status,
+    sd.created_at,
+    sd.updated_at,
+    json_object(
+        'snmp_port', sd.snmp_port,
+        'snmp_community', sd.snmp_community,
+        'snmp_version', sd.snmp_version,
+        'snmp_timeout', sd.snmp_timeout,
+        'snmp_retries', sd.snmp_retries
+    ) as device_metadata
+FROM surveilr_snmp_device sd
+WHERE sd.status = 'active'
+
+UNION ALL
+
+SELECT
+    'osquery_node' as device_type,
+    osq.node_key as device_id,
+    osq.host_identifier as primary_identifier,
+    'endpoint' as device_category,
+    osq.os_version as description,
+    osq.status,
+    osq.created_at,
+    osq.updated_at,
+    json_object(
+        'last_seen', osq.last_seen,
+        'platform', osq.platform,
+        'osquery_version', osq.osquery_version,
+        'device_id', osq.device_id
+    ) as device_metadata
+FROM surveilr_osquery_ms_node osq
+WHERE osq.status = 'active'`);
+var deviceGraphCorrelations = sqliteView("device_graph_correlations", {}).as(sql`
+SELECT DISTINCT
+    ure1.node_id as snmp_device_key,
+    ure1.uniform_resource_id as osquery_node_key,
+    CASE
+        WHEN ure1.nature LIKE '%ip_address_match%' THEN 'IP Address Match'
+        WHEN ure1.nature LIKE '%hostname_match%' THEN 'Hostname Match'
+        WHEN ure1.nature LIKE '%mac_address_match%' THEN 'MAC Address Match'
+        WHEN ure1.nature LIKE '%network_topology%' THEN 'Network Topology'
+        WHEN ure1.nature LIKE '%manual%' THEN 'Manual'
+        ELSE 'Unknown'
+    END as correlation_type,
+    CASE
+        WHEN ure1.nature LIKE '%ip_address_match%' THEN 0.95
+        WHEN ure1.nature LIKE '%hostname_match%' THEN 0.85
+        WHEN ure1.nature LIKE '%mac_address_match%' THEN 0.90
+        WHEN ure1.nature LIKE '%network_topology%' THEN 0.70
+        WHEN ure1.nature LIKE '%manual%' THEN 1.0
+        ELSE 0.5
+    END as confidence_score,
+    json_extract(ure1.elaboration, '$.snmp_host') as snmp_host,
+    json_extract(ure1.elaboration, '$.correlation_method') as correlation_method,
+    ure1.elaboration as evidence
+FROM uniform_resource_edge ure1
+WHERE ure1.graph_name = 'device_graph'
+AND ure1.nature LIKE 'snmp_to_osquery_%'
+ORDER BY ure1.node_id, ure1.uniform_resource_id`);
+var snmpDeviceInventory = sqliteView("snmp_device_inventory", {}).as(sql`
+SELECT
+    sd.device_key,
+    sd.snmp_host,
+    sd.snmp_port,
+    sd.device_type,
+    sd.device_description,
+    sd.status,
+    sd.created_at,
+    COUNT(sc.surveilr_snmp_collection_id) as total_collections,
+    MAX(sc.collected_at) as last_collection_time,
+    COUNT(DISTINCT sc.oid) as unique_oids_collected,
+    AVG(
+        CASE
+            WHEN sc.collected_at > datetime('now', '-1 hour') THEN 1
+            ELSE 0
+        END
+    ) as recent_activity_score
+FROM surveilr_snmp_device sd
+LEFT JOIN surveilr_snmp_collection sc ON sd.device_key = sc.device_key
+GROUP BY sd.device_key, sd.snmp_host, sd.snmp_port, sd.device_type,
+         sd.device_description, sd.status, sd.created_at
+ORDER BY sd.status, sd.snmp_host`);
+var snmpCollectionSummary = sqliteView("snmp_collection_summary", {}).as(sql`
+SELECT
+    sc.device_key,
+    sd.snmp_host,
+    sc.oid_type,
+    COUNT(*) as collection_count,
+    COUNT(DISTINCT sc.oid) as unique_oids,
+    MIN(sc.collected_at) as first_collection,
+    MAX(sc.collected_at) as latest_collection,
+    COUNT(DISTINCT DATE(sc.collected_at)) as collection_days
+FROM surveilr_snmp_collection sc
+JOIN surveilr_snmp_device sd ON sc.device_key = sd.device_key
+GROUP BY sc.device_key, sd.snmp_host, sc.oid_type
+ORDER BY sd.snmp_host, sc.oid_type`);
+var networkDeviceTopology = sqliteView("network_device_topology", {}).as(sql`
+SELECT
+    sd.device_key,
+    sd.snmp_host,
+    sd.device_type,
+    -- Extract network information from SNMP collections
+    COALESCE(
+        (SELECT sc.oid_value
+         FROM surveilr_snmp_collection sc
+         WHERE sc.device_key = sd.device_key
+         AND sc.oid LIKE '%.1.3.6.1.2.1.1.1.%'
+         LIMIT 1),
+        'Unknown'
+    ) as system_description,
+    COALESCE(
+        (SELECT sc.oid_value
+         FROM surveilr_snmp_collection sc
+         WHERE sc.device_key = sd.device_key
+         AND sc.oid LIKE '%.1.3.6.1.2.1.1.5.%'
+         LIMIT 1),
+        'Unknown'
+    ) as system_name,
+    -- Count correlated devices
+    (SELECT COUNT(*)
+     FROM device_graph_correlations dgc
+     WHERE dgc.snmp_device_key = sd.device_key
+    ) as correlated_devices_count,
+    sd.status,
+    sd.created_at
+FROM surveilr_snmp_device sd
+WHERE sd.status = 'active'
+ORDER BY sd.snmp_host`);
+var deviceGraphAnalytics = sqliteView("device_graph_analytics", {}).as(sql`
+SELECT
+    'summary' as metric_type,
+    'total_snmp_devices' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM surveilr_snmp_device
+WHERE status = 'active'
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'total_osquery_nodes' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM surveilr_osquery_ms_node
+WHERE status = 'active'
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'total_correlations' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM device_graph_correlations
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'correlation_types' as metric_name,
+    COUNT(DISTINCT correlation_type) as metric_value,
+    GROUP_CONCAT(DISTINCT correlation_type) as additional_info
+FROM device_graph_correlations
+
+UNION ALL
+
+SELECT
+    'correlation_by_type' as metric_type,
+    correlation_type as metric_name,
+    COUNT(*) as metric_value,
+    printf('avg_confidence: %.2f', AVG(confidence_score)) as additional_info
+FROM device_graph_correlations
+GROUP BY correlation_type
+
+UNION ALL
+
+SELECT
+    'collection_stats' as metric_type,
+    'total_snmp_collections' as metric_name,
+    COUNT(*) as metric_value,
+    printf('unique_devices: %d', COUNT(DISTINCT device_key)) as additional_info
+FROM surveilr_snmp_collection
+
+UNION ALL
+
+SELECT
+    'collection_stats' as metric_type,
+    'collection_activity_last_24h' as metric_name,
+    COUNT(*) as metric_value,
+    printf('devices_active: %d', COUNT(DISTINCT device_key)) as additional_info
+FROM surveilr_snmp_collection
+WHERE collected_at > datetime('now', '-24 hours')`);
+var snmpOidPerformance = sqliteView("snmp_oid_performance", {}).as(sql`
+SELECT
+    sc.oid,
+    sc.oid_type,
+    COUNT(*) as total_collections,
+    COUNT(DISTINCT sc.device_key) as devices_collecting,
+    COUNT(DISTINCT DATE(sc.collected_at)) as collection_days,
+    MIN(sc.collected_at) as first_seen,
+    MAX(sc.collected_at) as last_seen,
+    -- Calculate collection frequency (avoid nested aggregates)
+    CAST(
+        COUNT(*) * 1.0 /
+        NULLIF(MAX(julianday(sc.collected_at)) - MIN(julianday(sc.collected_at)), 0)
+    AS REAL) as avg_collections_per_day,
+    -- Sample values for diversity analysis
+    COUNT(DISTINCT sc.oid_value) as unique_values_count,
+    GROUP_CONCAT(DISTINCT sc.oid_value) as sample_values
+FROM surveilr_snmp_collection sc
+GROUP BY sc.oid, sc.oid_type
+HAVING COUNT(*) > 0
+ORDER BY total_collections DESC, devices_collecting DESC`);
+
+export {
+  codeNotebookCellVersions,
+  codeNotebookCellLatest,
+  codeNotebookSqlCellMigratableVersion,
+  codeNotebookSqlCellMigratable,
+  codeNotebookSqlCellMigratableState,
+  codeNotebookSqlCellMigratableNotExecuted,
+  codeNotebookMigrationSql,
+  imapGraph,
+  filesystemGraph,
+  consoleInformationSchemaTable,
+  consoleInformationSchemaView,
+  consoleContentTabular,
+  consoleInformationSchemaTableColFkey,
+  consoleInformationSchemaTableColIndex,
+  rssdStatisticsOverview,
+  rssdTableStatistic,
+  uniformResourceFile,
+  uniformResourceImap,
+  uniformResourceImapContent,
+  urIngestSessionFilesStats,
+  urIngestSessionFilesStatsLatest,
+  urIngestSessionTasksStats,
+  urIngestSessionTasksStatsLatest,
+  urIngestSessionFileIssue,
+  orchestrationSessionByDevice,
+  orchestrationSessionDuration,
+  orchestrationSuccessRate,
+  orchestrationSessionScript,
+  orchestrationExecutionsByType,
+  orchestrationExecutionSuccessRateByType,
+  orchestrationSessionSummary,
+  orchestrationIssueRemediation,
+  orchestrationLogsBySession,
+  emailMessagesWithTimezone,
+  deviceGraphOverview,
+  deviceGraphCorrelations,
+  snmpDeviceInventory,
+  snmpCollectionSummary,
+  networkDeviceTopology,
+  deviceGraphAnalytics,
+  snmpOidPerformance
+};