dbgate-api-premium 7.2.0 → 7.2.2

package/src/proc/databaseConnectionProcess.js

@@ -210,6 +210,15 @@ function waitStructure() {
   });
 }
 
+async function handleGetStructure({ msgid }) {
+  await waitStructure();
+  process.send({
+    msgtype: 'response',
+    msgid,
+    structure: serializeJsTypesForJsonStringify(analysedStructure),
+  });
+}
+
 function resolveAnalysedPromises() {
   for (const [resolve] of afterAnalyseCallbacks) {
     resolve();
@@ -623,13 +632,50 @@ async function handleEvalJsonScript({ script, runid }) {
   const directory = path.join(rundir(), runid);
   fs.mkdirSync(directory);
   const originalCwd = process.cwd();
+  let scriptError = null;
+  let finalizerError = null;
 
   try {
     process.chdir(directory);
 
-    const evalWriter = new ScriptWriterEval(dbgateApi, requirePlugin, dbhan, runid);
-    await playJsonScriptWriter(script, evalWriter);
-    process.send({ msgtype: 'runnerDone', runid });
+    try {
+      const evalWriter = new ScriptWriterEval(dbgateApi, requirePlugin, dbhan, runid);
+      await playJsonScriptWriter(script, evalWriter);
+    } catch (err) {
+      scriptError = err;
+    } finally {
+      try {
+        await dbgateApi.finalizer.run();
+      } catch (err) {
+        finalizerError = err;
+      }
+    }
+
+    const shouldReportScriptError = scriptError && !scriptError.dbgateCopyStreamErrorReported;
+
+    if (shouldReportScriptError || finalizerError) {
+      if (shouldReportScriptError) {
+        logger.error(extractErrorLogData(scriptError), 'DBGM-00000 Error running JSON script on database connection');
+      }
+      if (finalizerError) {
+        logger.error(extractErrorLogData(finalizerError), 'DBGM-00000 Error running JSON script finalizers');
+      }
+
+      process.send({
+        msgtype: 'copyStreamError',
+        copyStreamError: {
+          message: [
+            shouldReportScriptError && extractErrorMessage(scriptError),
+            finalizerError && `Finalizer failed: ${extractErrorMessage(finalizerError)}`,
+          ]
+            .filter(Boolean)
+            .join('\n'),
+          progressName: { name: 'script', runid },
+        },
+      });
+    } else {
+      process.send({ msgtype: 'runnerDone', runid });
+    }
   } finally {
     process.chdir(originalCwd);
   }
@@ -668,6 +714,7 @@ const messageHandlers = {
   sqlSelect: handleSqlSelect,
   exportKeys: handleExportKeys,
   schemaList: handleSchemaList,
+  getStructure: handleGetStructure,
   executeSessionQuery: handleExecuteSessionQuery,
   evalJsonScript: handleEvalJsonScript,
   multiCallMethod: handleMultiCallMethod,

package/src/proc/sessionProcess.js

@@ -290,14 +290,31 @@ async function handleExecuteReader({ jslid, sql, fileName }) {
 
   const reader = await driver.readQuery(dbhan, sql);
 
+  let isFinished = false;
+  const finishReader = () => {
+    if (isFinished) return;
+    isFinished = true;
+    writer.close().then(() => {
+      process.send({ msgtype: 'done' });
+    });
+  };
+
   reader.on('data', data => {
+    if (isFinished) return;
     writer.rowFromReader(data);
   });
-  reader.on('end', () => {
-    writer.close(() => {
-      process.send({ msgtype: 'done' });
+  reader.on('error', err => {
+    process.send({
+      msgtype: 'info',
+      info: {
+        message: extractErrorMessage(err),
+        severity: 'error',
+        time: new Date(),
+      },
     });
+    finishReader();
   });
+  reader.on('end', finishReader);
 }
 
 function handlePing() {

package/src/shell/copyStream.js

@@ -66,6 +66,7 @@ async function copyStream(input, output, options) {
     }
   } catch (err) {
     logger.error(extractErrorLogData(err, { progressName }), 'DBGM-00157 Import/export job failed');
+    err.dbgateCopyStreamErrorReported = true;
 
     process.send({
       msgtype: 'copyStreamError',
@@ -84,7 +85,7 @@ async function copyStream(input, output, options) {
         errorMessage: extractErrorMessage(err),
       });
     }
-    // throw err;
+    throw err;
   }
 }
 

package/src/storageModel.js

@@ -1047,6 +1047,10 @@ module.exports = {
         {
           "id": -3,
           "name": "superadmin"
+        },
+        {
+          "id": -4,
+          "name": "mcp"
         }
       ]
     },

package/src/utility/envtools.js

@@ -3,6 +3,10 @@ const _ = require('lodash');
 const { safeJsonParse, getDatabaseFileLabel } = require('dbgate-tools');
 const crypto = require('crypto');
 
+function isTrueValue(value) {
+  return [true, 1, '1', 'true'].includes(value);
+}
+
 function extractConnectionsFromEnv(env) {
   if (!env?.CONNECTIONS) {
     return null;
@@ -34,6 +38,7 @@ function extractConnectionsFromEnv(env) {
         : null),
     singleDatabase: !!env[`DATABASE_${id}`] || !!env[`FILE_${id}`] || !!env[`APISERVERURL1_${id}`],
     displayName: env[`LABEL_${id}`],
+    mcpEnabled: isTrueValue(env[`MCP_ENABLED_${id}`]),
     isReadOnly: env[`READONLY_${id}`],
     databases: env[`DBCONFIG_${id}`] ? safeJsonParse(env[`DBCONFIG_${id}`]) : null,
     allowedDatabases: env[`ALLOWED_DATABASES_${id}`]?.replace(/\|/g, '\n'),

package/src/utility/healthStatus.js

@@ -4,6 +4,7 @@ const databaseConnections = require('../controllers/databaseConnections');
 const serverConnections = require('../controllers/serverConnections');
 const sessions = require('../controllers/sessions');
 const runners = require('../controllers/runners');
+const { getLoggedUserCount } = require('./loginchecker');
 
 async function getHealthStatus() {
   const memory = process.memoryUsage();
@@ -13,7 +14,8 @@ async function getHealthStatus() {
     status: 'ok',
     databaseConnectionCount: databaseConnections.opened.length,
     serverConnectionCount: serverConnections.opened.length,
-    sessionCount: sessions.opened.length,
+    querySessionCount: sessions.opened.length,
+    loggedUserCount: getLoggedUserCount(),
     runProcessCount: runners.opened.length,
     memory,
     cpuUsage,

package/src/utility/loginchecker.js

@@ -60,10 +60,17 @@ function markLoginAsLoggedOut(licenseUid) {
   delete activeLoggedTokens[licenseUid];
 }
 
+function getLoggedUserCount() {
+  activeLoggedUsers = _.pickBy(activeLoggedUsers, value => value > Date.now());
+  activeLoggedTokens = _.pickBy(activeLoggedTokens, value => value > Date.now());
+  return _.uniq([...Object.keys(activeLoggedUsers), ...Object.keys(activeLoggedTokens)]).length;
+}
+
 module.exports = {
   markUserAsActive,
   markTokenAsLoggedIn,
   isLoginLicensed,
   LOGIN_LIMIT_ERROR,
   markLoginAsLoggedOut,
+  getLoggedUserCount,
 };

package/src/utility/mcpAuth.js

@@ -0,0 +1,137 @@
+const crypto = require('crypto');
+const getExpressPath = require('./getExpressPath');
+
+const MCP_ROLE_ID = -4;
+const MCP_AUTH_MODES = ['token', 'oauth', 'none'];
+
+function isLocalHostname(hostname) {
+  return ['localhost', '127.0.0.1', '::1'].includes(hostname.toLowerCase());
+}
+
+function hashMcpToken(token) {
+  return crypto.createHash('sha256').update(String(token)).digest('hex');
+}
+
+function isEnabledValue(value) {
+  return [true, 1, '1', 'true'].includes(value);
+}
+
+function sanitizeMcpConfig(config) {
+  const authMode = MCP_AUTH_MODES.includes(config?.authMode) ? config.authMode : 'none';
+  return {
+    enabled: isEnabledValue(config?.enabled),
+    authMode,
+    tokenHash: config?.tokenHash || null,
+    tokenEncrypted: config?.tokenEncrypted || null,
+    tokenSuffix: config?.tokenSuffix || null,
+    tokenGeneratedAt: config?.tokenGeneratedAt || null,
+    oauthClientId: config?.oauthClientId || null,
+    oauthClientSecretHash: config?.oauthClientSecretHash || null,
+    oauthClientSecretEncrypted: config?.oauthClientSecretEncrypted || null,
+    oauthClientSecretSuffix: config?.oauthClientSecretSuffix || null,
+    oauthClientGeneratedAt: config?.oauthClientGeneratedAt || null,
+  };
+}
+
+async function readMcpConfig() {
+  if (process.env.STORAGE_DATABASE) {
+    const storage = require('../controllers/storage');
+    return sanitizeMcpConfig((await storage.readConfig({ group: 'mcp' })) || {});
+  }
+
+  const token = process.env.MCP_TOKEN?.trim();
+  return {
+    enabled: !!token,
+    authMode: 'token',
+    tokenHash: token ? hashMcpToken(token) : null,
+    tokenEncrypted: null,
+    tokenSuffix: token ? token.slice(-6) : null,
+    tokenGeneratedAt: null,
+    oauthClientId: null,
+    oauthClientSecretHash: null,
+    oauthClientSecretEncrypted: null,
+    oauthClientSecretSuffix: null,
+    oauthClientGeneratedAt: null,
+  };
+}
+
+function getPublicBaseUrl(req) {
+  const configuredUrl = process.env.MCP_PUBLIC_URL?.trim();
+  if (configuredUrl) {
+    let parsed;
+    try {
+      parsed = new URL(configuredUrl);
+    } catch (error) {
+      throw new Error('DBGM-00000 MCP_PUBLIC_URL must be a valid HTTP(S) origin');
+    }
+    if (
+      !['http:', 'https:'].includes(parsed.protocol) ||
+      parsed.username ||
+      parsed.password ||
+      parsed.pathname !== '/' ||
+      parsed.search ||
+      parsed.hash
+    ) {
+      throw new Error(
+        'DBGM-00000 MCP_PUBLIC_URL must be an HTTP(S) origin without a path, credentials, query, or fragment'
+      );
+    }
+    if (parsed.protocol !== 'https:' && !isLocalHostname(parsed.hostname)) {
+      throw new Error('DBGM-00000 MCP_PUBLIC_URL must use HTTPS for a non-local origin');
+    }
+    return parsed.origin;
+  }
+
+  const protocol = req?.protocol || (req?.socket?.encrypted ? 'https' : 'http');
+  const host = req?.headers?.host || `localhost:${process.env.PORT || 3000}`;
+  if (!['http', 'https'].includes(protocol)) {
+    throw new Error('DBGM-00000 Could not determine a valid MCP public protocol');
+  }
+  let requestUrl;
+  try {
+    requestUrl = new URL(`${protocol}://${host}`);
+  } catch (error) {
+    throw new Error('DBGM-00000 Could not determine a valid MCP public URL');
+  }
+  if (requestUrl.username || requestUrl.password || requestUrl.pathname !== '/' || requestUrl.search || requestUrl.hash) {
+    throw new Error('DBGM-00000 Could not determine a valid MCP public URL');
+  }
+  if (requestUrl.protocol !== 'https:' && !isLocalHostname(requestUrl.hostname)) {
+    throw new Error('DBGM-00000 MCP OAuth requires HTTPS for a non-local public URL');
+  }
+  return requestUrl.origin;
+}
+
+function getMcpResourceUrl(req) {
+  return `${getPublicBaseUrl(req)}${getExpressPath('/mcp')}`;
+}
+
+function setMcpIdentity(req, details = {}) {
+  req.user = {
+    ...details,
+    amoid: 'mcp',
+    roleId: MCP_ROLE_ID,
+    licenseUid: details.licenseUid || 'mcp',
+    login: details.login || 'mcp',
+    tokenUse: 'mcp',
+  };
+}
+
+function safeTokenHashEquals(token, expectedHash) {
+  if (!token || !expectedHash) return false;
+  const actual = Buffer.from(hashMcpToken(token), 'hex');
+  const expected = Buffer.from(expectedHash, 'hex');
+  return actual.length === expected.length && crypto.timingSafeEqual(actual, expected);
+}
+
+module.exports = {
+  MCP_ROLE_ID,
+  MCP_AUTH_MODES,
+  hashMcpToken,
+  readMcpConfig,
+  sanitizeMcpConfig,
+  getPublicBaseUrl,
+  getMcpResourceUrl,
+  setMcpIdentity,
+  safeTokenHashEquals,
+};

package/src/utility/queryResultMetadata.js

@@ -20,6 +20,268 @@ function getColumnMetadata(columnMetadata, columnName) {
   return matchingKeys.length == 1 ? columnMetadata[matchingKeys[0]] : null;
 }
 
+function namesEqual(left, right) {
+  return left != null && right != null && left.toLowerCase() == right.toLowerCase();
+}
+
+function findTable(dbinfo, schemaName, pureName) {
+  if (!dbinfo?.tables?.length || !pureName) return null;
+  const schemaMatches = table => !schemaName || namesEqual(table.schemaName, schemaName);
+  const exactTables = dbinfo.tables.filter(table => schemaMatches(table) && table.pureName == pureName);
+  if (exactTables.length == 1) return exactTables[0];
+  const matchingTables = dbinfo.tables.filter(table => schemaMatches(table) && namesEqual(table.pureName, pureName));
+  if (matchingTables.length == 1) return matchingTables[0];
+  const uniqueNameTables = dbinfo.tables.filter(table => namesEqual(table.pureName, pureName));
+  return uniqueNameTables.length == 1 ? uniqueNameTables[0] : null;
+}
+
+function findView(dbinfo, schemaName, pureName) {
+  const views = [...(dbinfo?.views || []), ...(dbinfo?.matviews || [])];
+  if (!views.length || !pureName) return null;
+  if (schemaName) {
+    const exactView = views.find(view => view.schemaName == schemaName && view.pureName == pureName);
+    if (exactView) return exactView;
+    const schemaViews = views.filter(view => namesEqual(view.schemaName, schemaName) && namesEqual(view.pureName, pureName));
+    if (schemaViews.length == 1) return schemaViews[0];
+    const schemaLessViews = views.filter(view => !view.schemaName && namesEqual(view.pureName, pureName));
+    return schemaLessViews.length == 1 ? schemaLessViews[0] : null;
+  }
+  const matchingViews = views.filter(view => namesEqual(view.pureName, pureName));
+  return matchingViews.length == 1 ? matchingViews[0] : null;
+}
+
+function extractSelectFromCreateView(createSql) {
+  if (!createSql) return null;
+  const match = createSql.match(/\bas\s+(select\b[\s\S]*)/i);
+  return match ? match[1] : createSql;
+}
+
+function unquoteIdentifier(identifier) {
+  const trimmed = identifier?.trim();
+  if (!trimmed) return null;
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith('`') && trimmed.endsWith('`')) ||
+    (trimmed.startsWith('[') && trimmed.endsWith(']'))
+  ) {
+    return trimmed.slice(1, -1).replace(/""/g, '"').replace(/``/g, '`').replace(/]]/g, ']');
+  }
+  return trimmed;
+}
+
+function extractCreateViewColumnNames(createSql) {
+  if (!createSql) return null;
+  const asMatch = createSql.match(/\bas\b/i);
+  if (!asMatch) return null;
+  const prefix = createSql.substring(0, asMatch.index);
+  const match = prefix.match(/\(([^()]*)\)\s*$/);
+  if (!match) return null;
+  const columns = match[1]
+    .split(',')
+    .map(column => unquoteIdentifier(column))
+    .filter(Boolean);
+  return columns.length > 0 ? columns : null;
+}
+
+function getViewColumnNames(view) {
+  const analysedColumns = view?.columns?.map(column => column.columnName).filter(Boolean);
+  if (analysedColumns?.length) return analysedColumns;
+  return extractCreateViewColumnNames(view?.createSql);
+}
+
+function isSelectStarFromSingleTable(selectSql) {
+  return /^\s*select\s+\*\s+from\b/i.test(selectSql || '');
+}
+
+function getSelectListItemCount(selectSql) {
+  const selectMatch = selectSql?.match(/^\s*select\s+([\s\S]+?)\s+from\s/i);
+  return selectMatch ? splitTopLevelCommaList(selectMatch[1]).length : null;
+}
+
+const identifierPattern = '`(?:``|[^`])+`|"(?:""|[^"])+"|\\[[^\\]]+\\]|[A-Za-z_@$#][A-Za-z0-9_@$#]*';
+const qualifiedIdentifierPattern = `(?:${identifierPattern})(?:\\s*\\.\\s*(?:${identifierPattern}))*`;
+const qualifiedIdentifierOnlyRegex = new RegExp(`^\\s*${qualifiedIdentifierPattern}\\s*$`, 'i');
+const aliasStopWordPattern =
+  'on|where|join|inner|left|right|full|outer|cross|straight_join|group|order|having|limit|union';
+
+function splitTopLevelCommaList(text) {
+  const result = [];
+  let current = '';
+  let quote = null;
+  let depth = 0;
+
+  for (let index = 0; index < text.length; index++) {
+    const ch = text[index];
+    const next = text[index + 1];
+
+    if (quote) {
+      current += ch;
+      if (ch == quote) {
+        if ((quote == '"' || quote == '`') && next == quote) {
+          current += next;
+          index++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+
+    if (ch == '"' || ch == '`' || ch == '[') {
+      quote = ch == '[' ? ']' : ch;
+      current += ch;
+      continue;
+    }
+    if (ch == '(') depth++;
+    if (ch == ')' && depth > 0) depth--;
+    if (ch == ',' && depth == 0) {
+      result.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+
+function extractIdentifierParts(text) {
+  const identifierRegex = new RegExp(identifierPattern, 'g');
+  return (text.match(identifierRegex) || []).map(identifier => unquoteIdentifier(identifier));
+}
+
+function extractMySqlStyleViewColumnMetadata(selectSql, dbinfo) {
+  if (!selectSql) return null;
+  const selectMatch = selectSql.match(/^\s*select\s+([\s\S]+?)\s+from\s/i);
+  if (!selectMatch) return null;
+
+  const tableByAlias = {};
+  const tableRegex = new RegExp(
+    `\\b(?:from|join)\\s+\\(*\\s*(${qualifiedIdentifierPattern})(?:\\s+(?:as\\s+)?(?!\\b(?:${aliasStopWordPattern})\\b)(${identifierPattern}))?`,
+    'gi'
+  );
+  let tableMatch;
+  while ((tableMatch = tableRegex.exec(selectSql))) {
+    const tableParts = extractIdentifierParts(tableMatch[1]);
+    const alias = unquoteIdentifier(tableMatch[2]);
+    if (!tableParts.length) continue;
+    const metadata = {
+      schemaName: tableParts.length >= 2 ? tableParts[tableParts.length - 2] : undefined,
+      tableName: tableParts[tableParts.length - 1],
+    };
+    if (alias) tableByAlias[alias.toLowerCase()] = metadata;
+    tableByAlias[metadata.tableName.toLowerCase()] = metadata;
+  }
+  if (Object.keys(tableByAlias).length == 0) return null;
+
+  const result = {};
+  for (const item of splitTopLevelCommaList(selectMatch[1])) {
+    const [sourceText, aliasText] = item.split(/\s+\bas\b\s+/i);
+    if (!qualifiedIdentifierOnlyRegex.test(sourceText)) continue;
+    const sourceParts = extractIdentifierParts(sourceText);
+    if (sourceParts.length < 2) continue;
+    const sourceColumnName = sourceParts[sourceParts.length - 1];
+    const qualifier = sourceParts[sourceParts.length - 2];
+    const table = tableByAlias[qualifier.toLowerCase()];
+    if (!table) continue;
+    const aliasParts = aliasText ? extractIdentifierParts(aliasText) : [];
+    const resultColumnName = aliasParts[0] || sourceColumnName;
+    result[resultColumnName] = resolveMetadataTable(
+      {
+        ...table,
+        sourceColumnName,
+      },
+      dbinfo
+    );
+  }
+
+  return Object.keys(result).length == 0 ? null : result;
+}
+
+function resolveMetadataTable(metadata, dbinfo) {
+  if (!metadata?.tableName) return metadata;
+  const table = findTable(dbinfo, metadata.schemaName, metadata.tableName);
+  if (!table) return metadata;
+  return {
+    ...metadata,
+    tableName: table.pureName,
+    schemaName: table.schemaName,
+  };
+}
+
+function createViewColumnMetadata(view, dbinfo) {
+  const selectSql = extractSelectFromCreateView(view?.createSql);
+  if (!selectSql) return null;
+  const viewColumnNames = getViewColumnNames(view);
+  const columnMetadata = extractColumnMetadataFromSql(selectSql) || extractMySqlStyleViewColumnMetadata(selectSql, dbinfo);
+
+  if (columnMetadata && Object.keys(columnMetadata).length > 0) {
+    if (!viewColumnNames?.length) {
+      return Object.fromEntries(
+        Object.entries(columnMetadata).map(([columnName, metadata]) => [
+          columnName,
+          resolveMetadataTable(metadata, dbinfo),
+        ])
+      );
+    }
+
+    const metadataValues = Object.values(columnMetadata).map(metadata => resolveMetadataTable(metadata, dbinfo));
+    const allowPositionalFallback =
+      metadataValues.length == viewColumnNames.length && metadataValues.length == getSelectListItemCount(selectSql);
+    const result = {};
+    for (let index = 0; index < viewColumnNames.length; index++) {
+      const columnName = viewColumnNames[index];
+      const metadata = getColumnMetadata(columnMetadata, columnName);
+      const resolvedMetadata = metadata
+        ? resolveMetadataTable(metadata, dbinfo)
+        : allowPositionalFallback
+          ? metadataValues[index]
+          : null;
+      if (resolvedMetadata) result[columnName] = resolvedMetadata;
+    }
+    return result;
+  }
+
+  if (!viewColumnNames?.length || !isSelectStarFromSingleTable(selectSql)) return columnMetadata;
+  const sourceTable = extractSingleTableFromSql(selectSql);
+  const table = findTable(dbinfo, sourceTable?.schemaName, sourceTable?.tableName);
+  if (!table?.columns?.length) return columnMetadata;
+
+  const result = {};
+  for (let index = 0; index < viewColumnNames.length; index++) {
+    const sourceColumn = table.columns[index];
+    if (!sourceColumn?.columnName) continue;
+    result[viewColumnNames[index]] = {
+      tableName: table.pureName,
+      schemaName: table.schemaName,
+      sourceColumnName: sourceColumn.columnName,
+    };
+  }
+  return result;
+}
+
+function resolveViewResultColumns(columns, dbinfo) {
+  if (!columns?.length) return columns;
+  if (!dbinfo?.views?.length && !dbinfo?.matviews?.length) return columns;
+
+  return columns.map(column => {
+    const view = findView(dbinfo, column.tableSchema, column.tableName);
+    if (!view?.createSql) return column;
+
+    const columnMetadata = createViewColumnMetadata(view, dbinfo);
+    const metadata = getColumnMetadata(columnMetadata, column.columnName);
+    if (!metadata) return column;
+
+    return {
+      ...column,
+      tableName: metadata.tableName,
+      tableSchema: metadata.schemaName,
+      sourceColumnName: metadata.sourceColumnName,
+    };
+  });
+}
+
 async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, onNativeMetadataError, onFallbackMetadataError }) {
   if (!columns?.length || !driver?.databaseEngineTypes?.includes('sql') || !driver?.supportsEditableQueryResults) {
     return columns;
@@ -27,7 +289,7 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
 
   if (driver.enrichColumnMetadata) {
     try {
-      const enriched = await driver.enrichColumnMetadata(dbhan, sql, columns, dbinfo);
+      const enriched = resolveViewResultColumns(await driver.enrichColumnMetadata(dbhan, sql, columns, dbinfo), dbinfo);
       if (enriched?.every(column => column.tableName && column.sourceColumnName)) return enriched;
       if (enriched?.length == columns.length) columns = enriched;
     } catch (err) {
@@ -38,7 +300,7 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
   try {
     const columnMetadata = extractColumnMetadataFromSql(sql);
     if (columnMetadata) {
-      return columns.map(column => {
+      return resolveViewResultColumns(columns.map(column => {
         const metadata = getColumnMetadata(columnMetadata, column.columnName);
         return {
           ...column,
@@ -46,19 +308,19 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
           tableSchema: column.tableSchema || metadata?.schemaName,
           sourceColumnName: column.sourceColumnName || metadata?.sourceColumnName,
         };
-      });
+      }), dbinfo);
     }
 
     const table = extractSingleTableFromSql(sql);
     if (!table) return columns;
     const columnSources = extractColumnSourcesFromSql(sql);
 
-    return columns.map(column => ({
+    return resolveViewResultColumns(columns.map(column => ({
       ...column,
       tableName: column.tableName || table.tableName,
       tableSchema: column.tableSchema || table.schemaName,
       sourceColumnName: column.sourceColumnName || getColumnSourceName(columnSources, column.columnName) || column.columnName,
-    }));
+    })), dbinfo);
   } catch (err) {
     onFallbackMetadataError?.(err);
     return columns;
@@ -67,4 +329,5 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
 
 module.exports = {
   enrichQueryResultColumns,
+  resolveViewResultColumns,
 };

package/src/utility/storageReplicatorItems.js

@@ -31,6 +31,18 @@ module.exports = [
     updateExisting: true,
     matchColumns: ['conid'],
   },
+  {
+    name: 'team_folders',
+    findExisting: true,
+    createNew: true,
+    updateExisting: true,
+    matchColumns: ['folder_name'],
+  },
+  {
+    name: 'team_files',
+    createNew: true,
+    //matchColumns: ['file_name', 'team_folder_id'],
+  },
   {
     name: 'role_connections',
     findExisting: true,