@querypanel/node-sdk 1.0.25 → 1.0.26

package/dist/index.js

@@ -1,1443 +0,0 @@
-// src/index.ts
-import { createHash, randomUUID } from "crypto";
-import { importPKCS8, SignJWT } from "jose";
-
-// src/utils/clickhouse.ts
-var WRAPPER_REGEX = /^(Nullable|LowCardinality|SimpleAggregateFunction)\((.+)\)$/i;
-function isNullableType(type) {
-  return /Nullable\s*\(/i.test(type);
-}
-function unwrapTypeModifiers(type) {
-  let current = type.trim();
-  let match = WRAPPER_REGEX.exec(current);
-  while (match) {
-    const inner = match[2];
-    if (!inner) {
-      break;
-    }
-    current = inner.trim();
-    match = WRAPPER_REGEX.exec(current);
-  }
-  return current;
-}
-function extractPrecisionScale(type) {
-  const unwrapped = unwrapTypeModifiers(type);
-  const decimalMatch = unwrapped.match(/Decimal(?:\d+)?\((\d+)\s*,\s*(\d+)\)/i);
-  if (!decimalMatch) return {};
-  const precision = decimalMatch[1];
-  const scale = decimalMatch[2];
-  if (!precision || !scale) return {};
-  return {
-    precision: Number.parseInt(precision, 10),
-    scale: Number.parseInt(scale, 10)
-  };
-}
-function extractFixedStringLength(type) {
-  const unwrapped = unwrapTypeModifiers(type);
-  const match = unwrapped.match(/^(?:FixedString|StringFixed)\((\d+)\)$/i);
-  if (!match) return void 0;
-  const length = match[1];
-  if (!length) return void 0;
-  return Number.parseInt(length, 10);
-}
-function parseKeyExpression(expression) {
-  if (!expression) return [];
-  let value = expression.trim();
-  if (!value) return [];
-  if (/^tuple\s*\(/i.test(value) && value.endsWith(")")) {
-    value = value.replace(/^tuple\s*\(/i, "").replace(/\)$/, "");
-  }
-  const columns = [];
-  let depth = 0;
-  let token = "";
-  for (const ch of value) {
-    if (ch === "(") {
-      depth += 1;
-      token += ch;
-      continue;
-    }
-    if (ch === ")") {
-      depth = Math.max(0, depth - 1);
-      token += ch;
-      continue;
-    }
-    if (ch === "," && depth === 0) {
-      const col = token.trim();
-      if (col) columns.push(stripWrapper(col));
-      token = "";
-      continue;
-    }
-    token += ch;
-  }
-  const last = token.trim();
-  if (last) columns.push(stripWrapper(last));
-  return columns.filter(Boolean);
-}
-function stripWrapper(value) {
-  const noQuotes = stripQuotes(value);
-  const withoutTicks = noQuotes.replace(/`/g, "").trim();
-  const parts = withoutTicks.split(".");
-  return parts[parts.length - 1]?.trim() ?? "";
-}
-function stripQuotes(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-
-// src/adapters/clickhouse.ts
-var ClickHouseAdapter = class {
-  constructor(clientFn, options = {}) {
-    this.clientFn = clientFn;
-    this.databaseName = options.database ?? "default";
-    this.defaultFormat = options.defaultFormat ?? "JSONEachRow";
-    this.kind = options.kind ?? "clickhouse";
-    if (options.allowedTables) {
-      this.allowedTables = normalizeTableFilter(options.allowedTables);
-    }
-  }
-  databaseName;
-  defaultFormat;
-  kind;
-  allowedTables;
-  async execute(sql, params) {
-    if (this.allowedTables) {
-      this.validateQueryTables(sql);
-    }
-    const queryOptions = {
-      format: this.defaultFormat
-    };
-    if (params) {
-      queryOptions.params = params;
-    }
-    const rows = await this.query(sql, queryOptions);
-    const fields = rows.length > 0 ? Object.keys(rows[0] ?? {}) : [];
-    return { fields, rows };
-  }
-  async validate(sql, params) {
-    const queryOptions = {
-      format: this.defaultFormat
-    };
-    if (params) {
-      queryOptions.params = params;
-    }
-    await this.query(`EXPLAIN ${sql}`, queryOptions);
-  }
-  getDialect() {
-    return "clickhouse";
-  }
-  async introspect(options) {
-    const tablesToIntrospect = options?.tables ? normalizeTableFilter(options.tables) : this.allowedTables;
-    const allowTables = tablesToIntrospect ?? [];
-    const hasFilter = allowTables.length > 0;
-    const queryParams = {
-      db: this.databaseName
-    };
-    if (hasFilter) {
-      queryParams.tables = allowTables;
-    }
-    const filterClause = hasFilter ? " AND name IN {tables:Array(String)}" : "";
-    const tables = await this.query(
-      `SELECT name, engine, comment, total_rows, total_bytes, primary_key, sorting_key
-       FROM system.tables
-       WHERE database = {db:String}${filterClause}
-       ORDER BY name`,
-      { params: queryParams }
-    );
-    const columnFilterClause = hasFilter ? " AND table IN {tables:Array(String)}" : "";
-    const columns = await this.query(
-      `SELECT table, name, type, position, default_kind, default_expression, comment, is_in_primary_key
-       FROM system.columns
-       WHERE database = {db:String}${columnFilterClause}
-       ORDER BY table, position`,
-      { params: queryParams }
-    );
-    const columnsByTable = /* @__PURE__ */ new Map();
-    for (const rawColumn of columns) {
-      const list = columnsByTable.get(rawColumn.table) ?? [];
-      list.push(transformColumnRow(rawColumn));
-      columnsByTable.set(rawColumn.table, list);
-    }
-    const tableSchemas = tables.map((table) => {
-      const tableColumns = columnsByTable.get(table.name) ?? [];
-      const primaryKeyColumns = parseKeyExpression(table.primary_key);
-      const totalRows = toNumber(table.total_rows);
-      const totalBytes = toNumber(table.total_bytes);
-      for (const column of tableColumns) {
-        column.isPrimaryKey = column.isPrimaryKey || primaryKeyColumns.includes(column.name);
-      }
-      const indexes = primaryKeyColumns.length ? [
-        {
-          name: "primary_key",
-          columns: primaryKeyColumns,
-          unique: true,
-          type: "PRIMARY KEY",
-          ...table.primary_key ? { definition: table.primary_key } : {}
-        }
-      ] : [];
-      const constraints = primaryKeyColumns.length ? [
-        {
-          name: "primary_key",
-          type: "PRIMARY KEY",
-          columns: primaryKeyColumns
-        }
-      ] : [];
-      const base = {
-        name: table.name,
-        schema: this.databaseName,
-        type: asTableType(table.engine),
-        engine: table.engine,
-        columns: tableColumns,
-        indexes,
-        constraints
-      };
-      const comment = sanitize(table.comment);
-      if (comment !== void 0) {
-        base.comment = comment;
-      }
-      const statistics = buildTableStatistics(totalRows, totalBytes);
-      if (statistics) {
-        base.statistics = statistics;
-      }
-      return base;
-    });
-    return {
-      db: {
-        kind: this.kind,
-        name: this.databaseName
-      },
-      tables: tableSchemas,
-      introspectedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * Validate that the SQL query only references allowed tables.
-   * This is a basic validation that extracts table-like patterns from the query.
-   */
-  validateQueryTables(sql) {
-    if (!this.allowedTables || this.allowedTables.length === 0) {
-      return;
-    }
-    const allowedSet = new Set(this.allowedTables);
-    const tablePattern = /(?:FROM|JOIN)\s+(?:FINAL\s+)?(?:(?:[a-zA-Z_][a-zA-Z0-9_]*)\.)?(["'`]?[a-zA-Z_][a-zA-Z0-9_]*["'`]?)/gi;
-    const matches = sql.matchAll(tablePattern);
-    for (const match of matches) {
-      const table = match[1]?.replace(/["'`]/g, "");
-      if (table) {
-        if (!allowedSet.has(table)) {
-          throw new Error(
-            `Query references table "${table}" which is not in the allowed tables list`
-          );
-        }
-      }
-    }
-  }
-  async close() {
-  }
-  async query(sql, options) {
-    const params = {
-      query: sql
-    };
-    const format = options?.format ?? this.defaultFormat;
-    if (format !== void 0) {
-      params.format = format;
-    }
-    if (options?.params) {
-      params.query_params = options.params;
-    }
-    if (options?.settings) {
-      params.clickhouse_settings = options.settings;
-    }
-    const result = await this.clientFn(params);
-    return this.extractRows(result);
-  }
-  async extractRows(result) {
-    if (Array.isArray(result)) {
-      return result;
-    }
-    if (result && typeof result.json === "function") {
-      const payload = await result.json();
-      return normalizePayload(payload);
-    }
-    return [];
-  }
-};
-function normalizePayload(payload) {
-  if (Array.isArray(payload)) {
-    return payload;
-  }
-  if (payload && typeof payload === "object") {
-    const maybeData = payload.data;
-    if (Array.isArray(maybeData)) {
-      return maybeData;
-    }
-  }
-  return [];
-}
-function normalizeTableFilter(tables) {
-  if (!tables?.length) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const normalized = [];
-  for (const table of tables) {
-    if (!table) continue;
-    const trimmed = table.trim();
-    if (!trimmed) continue;
-    const parts = trimmed.split(".");
-    const tableName = parts[parts.length - 1];
-    if (!tableName || seen.has(tableName)) continue;
-    seen.add(tableName);
-    normalized.push(tableName);
-  }
-  return normalized;
-}
-function transformColumnRow(row) {
-  const nullable = isNullableType(row.type);
-  const unwrappedType = unwrapTypeModifiers(row.type);
-  const { precision, scale } = extractPrecisionScale(row.type);
-  const maxLength = extractFixedStringLength(row.type);
-  const column = {
-    name: row.name,
-    type: unwrappedType,
-    rawType: row.type,
-    nullable,
-    isPrimaryKey: Boolean(toNumber(row.is_in_primary_key)),
-    isForeignKey: false
-  };
-  const defaultKind = sanitize(row.default_kind);
-  if (defaultKind !== void 0) column.defaultKind = defaultKind;
-  const defaultExpression = sanitize(row.default_expression);
-  if (defaultExpression !== void 0) {
-    column.defaultExpression = defaultExpression;
-  }
-  const comment = sanitize(row.comment);
-  if (comment !== void 0) column.comment = comment;
-  if (maxLength !== void 0) column.maxLength = maxLength;
-  if (precision !== void 0) column.precision = precision;
-  if (scale !== void 0) column.scale = scale;
-  return column;
-}
-function asTableType(engine) {
-  if (typeof engine === "string") {
-    const normalized = engine.toLowerCase();
-    if (normalized.includes("view")) {
-      return "view";
-    }
-  }
-  return "table";
-}
-function buildTableStatistics(totalRows, totalBytes) {
-  if (totalRows === void 0 && totalBytes === void 0) return void 0;
-  const stats = {};
-  if (totalRows !== void 0) stats.totalRows = totalRows;
-  if (totalBytes !== void 0) stats.totalBytes = totalBytes;
-  return stats;
-}
-function sanitize(value) {
-  if (value === null || value === void 0) return void 0;
-  const trimmed = String(value).trim();
-  return trimmed.length ? trimmed : void 0;
-}
-function toNumber(value) {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(String(value));
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-
-// src/adapters/postgres.ts
-var PostgresAdapter = class {
-  constructor(clientFn, options = {}) {
-    this.clientFn = clientFn;
-    this.databaseName = options.database ?? "postgres";
-    this.defaultSchema = options.defaultSchema ?? "public";
-    this.kind = options.kind ?? "postgres";
-    if (options.allowedTables) {
-      this.allowedTables = normalizeTableFilter2(
-        options.allowedTables,
-        this.defaultSchema
-      );
-    }
-  }
-  databaseName;
-  defaultSchema;
-  kind;
-  allowedTables;
-  async execute(sql, params) {
-    if (this.allowedTables) {
-      this.validateQueryTables(sql);
-    }
-    let paramArray;
-    if (params) {
-      paramArray = this.convertNamedToPositionalParams(params);
-    }
-    const result = await this.clientFn(sql, paramArray);
-    const fields = result.fields.map((f) => f.name);
-    return { fields, rows: result.rows };
-  }
-  /**
-   * Validate that the SQL query only references allowed tables.
-   * This is a basic validation that extracts table-like patterns from the query.
-   */
-  validateQueryTables(sql) {
-    if (!this.allowedTables || this.allowedTables.length === 0) {
-      return;
-    }
-    const allowedSet = new Set(
-      this.allowedTables.map((t) => tableKey(t.schema, t.table))
-    );
-    const tablePattern = /(?:FROM|JOIN)\s+(?:ONLY\s+)?(?:([a-zA-Z_][a-zA-Z0-9_]*)\.)?(["']?[a-zA-Z_][a-zA-Z0-9_]*["']?)/gi;
-    const matches = sql.matchAll(tablePattern);
-    for (const match of matches) {
-      const schema = match[1] ?? this.defaultSchema;
-      const table = match[2]?.replace(/['"]/g, "");
-      if (table) {
-        const key = tableKey(schema, table);
-        if (!allowedSet.has(key)) {
-          throw new Error(
-            `Query references table "${schema}.${table}" which is not in the allowed tables list`
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Convert named params to positional array for PostgreSQL
-   * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3]
-   *
-   * Supports two formats:
-   * 1. Numeric keys: { '1': 'value1', '2': 'value2' } - maps directly to $1, $2
-   * 2. Named keys: { 'tenant_id': 'value' } - values extracted in alphabetical order
-   * 3. Mixed: { '1': 'value1', 'tenant_id': 'value' } - numeric keys first, then named keys
-   */
-  convertNamedToPositionalParams(params) {
-    const numericKeys = Object.keys(params).filter((k) => /^\d+$/.test(k)).map((k) => Number.parseInt(k, 10)).sort((a, b) => a - b);
-    const namedKeys = Object.keys(params).filter((k) => !/^\d+$/.test(k)).sort();
-    const positionalParams = [];
-    for (const key of numericKeys) {
-      let val = params[String(key)];
-      if (typeof val === "string") {
-        const match = val.match(/^<([a-zA-Z0-9_]+)>$/);
-        const namedKey = match?.[1];
-        if (namedKey && namedKey in params) {
-          val = params[namedKey];
-        }
-      }
-      positionalParams.push(val);
-    }
-    for (const key of namedKeys) {
-      const val = params[key];
-      positionalParams.push(val);
-    }
-    return positionalParams;
-  }
-  async validate(sql, params) {
-    let paramArray;
-    if (params) {
-      paramArray = this.convertNamedToPositionalParams(params);
-    }
-    await this.clientFn(`EXPLAIN ${sql}`, paramArray);
-  }
-  getDialect() {
-    return "postgres";
-  }
-  async introspect(options) {
-    const tablesToIntrospect = options?.tables ? normalizeTableFilter2(options.tables, this.defaultSchema) : this.allowedTables;
-    const normalizedTables = tablesToIntrospect ?? [];
-    const tablesResult = await this.clientFn(
-      buildTablesQuery(normalizedTables)
-    );
-    const tableRows = tablesResult.rows;
-    const columnsResult = await this.clientFn(
-      buildColumnsQuery(normalizedTables)
-    );
-    const columnRows = columnsResult.rows;
-    const constraintsResult = await this.clientFn(
-      buildConstraintsQuery(normalizedTables)
-    );
-    const constraintRows = constraintsResult.rows;
-    const indexesResult = await this.clientFn(
-      buildIndexesQuery(normalizedTables)
-    );
-    const indexRows = indexesResult.rows;
-    const tablesByKey = /* @__PURE__ */ new Map();
-    const columnsByKey = /* @__PURE__ */ new Map();
-    for (const row of tableRows) {
-      const key = tableKey(row.schema_name, row.table_name);
-      const statistics = buildTableStatistics2(
-        toNumber2(row.total_rows),
-        toNumber2(row.total_bytes)
-      );
-      const table = {
-        name: row.table_name,
-        schema: row.schema_name,
-        type: asTableType2(row.table_type),
-        columns: [],
-        indexes: [],
-        constraints: []
-      };
-      const comment = sanitize2(row.comment);
-      if (comment !== void 0) {
-        table.comment = comment;
-      }
-      if (statistics) {
-        table.statistics = statistics;
-      }
-      tablesByKey.set(key, table);
-      columnsByKey.set(key, /* @__PURE__ */ new Map());
-    }
-    for (const row of columnRows) {
-      const key = tableKey(row.table_schema, row.table_name);
-      const table = tablesByKey.get(key);
-      if (!table) continue;
-      const column = {
-        name: row.column_name,
-        type: row.data_type,
-        nullable: row.is_nullable.toUpperCase() === "YES",
-        isPrimaryKey: false,
-        isForeignKey: false
-      };
-      const rawType = row.udt_name ?? void 0;
-      if (rawType !== void 0) column.rawType = rawType;
-      const defaultExpression = sanitize2(row.column_default);
-      if (defaultExpression !== void 0)
-        column.defaultExpression = defaultExpression;
-      const comment = sanitize2(row.description);
-      if (comment !== void 0) column.comment = comment;
-      const maxLength = row.character_maximum_length ?? void 0;
-      if (maxLength !== void 0) column.maxLength = maxLength;
-      const precision = row.numeric_precision ?? void 0;
-      if (precision !== void 0) column.precision = precision;
-      const scale = row.numeric_scale ?? void 0;
-      if (scale !== void 0) column.scale = scale;
-      table.columns.push(column);
-      columnsByKey.get(key)?.set(row.column_name, column);
-    }
-    const constraintGroups = groupConstraints(constraintRows);
-    for (const group of constraintGroups) {
-      const key = tableKey(group.table_schema, group.table_name);
-      const table = tablesByKey.get(key);
-      if (!table) continue;
-      const constraint = {
-        name: group.constraint_name,
-        type: group.constraint_type,
-        columns: [...group.columns]
-      };
-      if (group.type === "FOREIGN KEY") {
-        if (group.foreign_table_name) {
-          const referencedTable = group.foreign_table_schema ? `${group.foreign_table_schema}.${group.foreign_table_name}` : group.foreign_table_name;
-          constraint.referencedTable = referencedTable;
-        }
-        if (group.foreign_columns.length) {
-          constraint.referencedColumns = [...group.foreign_columns];
-        }
-      }
-      table.constraints.push(constraint);
-      for (let index = 0; index < group.columns.length; index += 1) {
-        const columnName = group.columns[index];
-        if (!columnName) continue;
-        const column = columnsByKey.get(key)?.get(columnName);
-        if (!column) continue;
-        if (group.type === "PRIMARY KEY") {
-          column.isPrimaryKey = true;
-        }
-        if (group.type === "FOREIGN KEY") {
-          column.isForeignKey = true;
-          if (group.foreign_table_name) {
-            column.foreignKeyTable = group.foreign_table_schema ? `${group.foreign_table_schema}.${group.foreign_table_name}` : group.foreign_table_name;
-          }
-          const referencedColumn = group.foreign_columns[index];
-          if (referencedColumn) {
-            column.foreignKeyColumn = referencedColumn;
-          }
-        }
-      }
-    }
-    for (const row of indexRows) {
-      const key = tableKey(row.schema_name, row.table_name);
-      const table = tablesByKey.get(key);
-      if (!table) continue;
-      const columns = coerceStringArray(row.column_names).map((c) => c.trim()).filter(Boolean);
-      const index = {
-        name: row.index_name,
-        columns,
-        unique: Boolean(row.indisunique),
-        type: columns.length === 1 ? "INDEX" : "COMPOSITE INDEX"
-      };
-      const definition = sanitize2(row.definition);
-      if (definition !== void 0) index.definition = definition;
-      table.indexes.push(index);
-    }
-    const tables = Array.from(tablesByKey.values()).sort((a, b) => {
-      if (a.schema === b.schema) {
-        return a.name.localeCompare(b.name);
-      }
-      return a.schema.localeCompare(b.schema);
-    });
-    return {
-      db: {
-        kind: this.kind,
-        name: this.databaseName
-      },
-      tables,
-      introspectedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-};
-function groupConstraints(rows) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = `${row.table_schema}.${row.table_name}.${row.constraint_name}`;
-    let group = groups.get(key);
-    if (!group) {
-      group = {
-        table_schema: row.table_schema,
-        table_name: row.table_name,
-        constraint_name: row.constraint_name,
-        constraint_type: row.constraint_type,
-        columns: [],
-        foreign_columns: [],
-        type: row.constraint_type
-      };
-      groups.set(key, group);
-    }
-    if (row.column_name) {
-      group.columns.push(row.column_name);
-    }
-    if (row.constraint_type === "FOREIGN KEY") {
-      group.foreign_table_schema = row.foreign_table_schema;
-      group.foreign_table_name = row.foreign_table_name;
-      if (row.foreign_column_name) {
-        group.foreign_columns.push(row.foreign_column_name);
-      }
-    }
-  }
-  return Array.from(groups.values());
-}
-function normalizeTableFilter2(tables, defaultSchema) {
-  if (!tables?.length) return [];
-  const normalized = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const raw of tables) {
-    if (!raw) continue;
-    const trimmed = raw.trim();
-    if (!trimmed) continue;
-    const parts = trimmed.split(".");
-    const table = parts.pop() ?? "";
-    const schema = parts.pop() ?? defaultSchema;
-    if (!isSafeIdentifier(schema) || !isSafeIdentifier(table)) {
-      continue;
-    }
-    const key = tableKey(schema, table);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    normalized.push({ schema, table });
-  }
-  return normalized;
-}
-function buildTablesQuery(tables) {
-  const filter = buildFilterClause(tables, "n.nspname", "c.relname");
-  return `SELECT
-    c.relname AS table_name,
-    n.nspname AS schema_name,
-    CASE c.relkind
-      WHEN 'r' THEN 'table'
-      WHEN 'v' THEN 'view'
-      WHEN 'm' THEN 'materialized_view'
-      ELSE c.relkind::text
-    END AS table_type,
-    obj_description(c.oid) AS comment,
-    c.reltuples AS total_rows,
-    pg_total_relation_size(c.oid) AS total_bytes
-  FROM pg_class c
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-    AND c.relkind IN ('r', 'v', 'm')
-    ${filter}
-  ORDER BY n.nspname, c.relname;`;
-}
-function buildColumnsQuery(tables) {
-  const filter = buildFilterClause(
-    tables,
-    "cols.table_schema",
-    "cols.table_name"
-  );
-  return `SELECT
-    cols.table_name,
-    cols.table_schema,
-    cols.column_name,
-    cols.data_type,
-    cols.udt_name,
-    cols.is_nullable,
-    cols.column_default,
-    cols.character_maximum_length,
-    cols.numeric_precision,
-    cols.numeric_scale,
-    cols.ordinal_position,
-    pgd.description
-  FROM information_schema.columns cols
-  LEFT JOIN pg_catalog.pg_class c
-    ON c.relname = cols.table_name
-   AND c.relkind IN ('r', 'v', 'm')
-  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_catalog.pg_attribute attr
-    ON attr.attrelid = c.oid
-   AND attr.attname = cols.column_name
-  LEFT JOIN pg_catalog.pg_description pgd
-    ON pgd.objoid = attr.attrelid AND pgd.objsubid = attr.attnum
-  WHERE cols.table_schema NOT IN ('pg_catalog', 'information_schema')
-    ${filter}
-  ORDER BY cols.table_schema, cols.table_name, cols.ordinal_position;`;
-}
-function buildConstraintsQuery(tables) {
-  const filter = buildFilterClause(tables, "tc.table_schema", "tc.table_name");
-  return `SELECT
-    tc.table_schema,
-    tc.table_name,
-    tc.constraint_name,
-    tc.constraint_type,
-    kcu.column_name,
-    ccu.table_schema AS foreign_table_schema,
-    ccu.table_name AS foreign_table_name,
-    ccu.column_name AS foreign_column_name
-  FROM information_schema.table_constraints tc
-  LEFT JOIN information_schema.key_column_usage kcu
-    ON tc.constraint_name = kcu.constraint_name
-   AND tc.table_schema = kcu.table_schema
-  LEFT JOIN information_schema.constraint_column_usage ccu
-    ON ccu.constraint_name = tc.constraint_name
-   AND ccu.table_schema = tc.table_schema
-  WHERE tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE', 'FOREIGN KEY')
-    AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
-    ${filter}
-  ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position;`;
-}
-function buildIndexesQuery(tables) {
-  const filter = buildFilterClause(tables, "n.nspname", "c.relname");
-  return `SELECT
-    n.nspname AS schema_name,
-    c.relname AS table_name,
-    ci.relname AS index_name,
-    idx.indisunique,
-    array_remove(
-      array_agg(pg_get_indexdef(idx.indexrelid, g.k, true) ORDER BY g.k),
-      NULL
-    ) AS column_names,
-    pg_get_indexdef(idx.indexrelid) AS definition
-  FROM pg_class c
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  JOIN pg_index idx ON idx.indrelid = c.oid
-  JOIN pg_class ci ON ci.oid = idx.indexrelid
-  JOIN LATERAL generate_subscripts(idx.indkey, 1) AS g(k) ON true
-  WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-    ${filter}
-  GROUP BY n.nspname, c.relname, ci.relname, idx.indisunique, idx.indexrelid;`;
-}
-function buildFilterClause(tables, schemaExpr, tableExpr) {
-  if (!tables.length) return "";
-  const clauses = tables.map(({ schema, table }) => {
-    return `(${schemaExpr} = '${schema}' AND ${tableExpr} = '${table}')`;
-  });
-  return `AND (${clauses.join(" OR ")})`;
-}
-function tableKey(schema, table) {
-  return `${schema}.${table}`;
-}
-function isSafeIdentifier(value) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
-}
-function asTableType2(value) {
-  const normalized = value.toLowerCase();
-  if (normalized.includes("view")) {
-    return normalized.includes("materialized") ? "materialized_view" : "view";
-  }
-  return "table";
-}
-function buildTableStatistics2(totalRows, totalBytes) {
-  if (totalRows === void 0 && totalBytes === void 0) return void 0;
-  const stats = {};
-  if (totalRows !== void 0) stats.totalRows = totalRows;
-  if (totalBytes !== void 0) stats.totalBytes = totalBytes;
-  return stats;
-}
-function sanitize2(value) {
-  if (value === null || value === void 0) return void 0;
-  const trimmed = String(value).trim();
-  return trimmed.length ? trimmed : void 0;
-}
-function toNumber2(value) {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(String(value));
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function coerceStringArray(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) {
-    return value.map((entry) => String(entry));
-  }
-  const text = String(value).trim();
-  if (!text) return [];
-  const withoutBraces = text.startsWith("{") && text.endsWith("}") ? text.slice(1, -1) : text;
-  if (!withoutBraces) return [];
-  return withoutBraces.split(",").map((part) => part.trim().replace(/^"(.+)"$/, "$1")).filter(Boolean);
-}
-
-// src/index.ts
-var QueryPanelSdkAPI = class {
-  baseUrl;
-  privateKey;
-  organizationId;
-  defaultTenantId;
-  additionalHeaders;
-  fetchImpl;
-  cachedPrivateKey;
-  databases = /* @__PURE__ */ new Map();
-  databaseMetadata = /* @__PURE__ */ new Map();
-  defaultDatabase;
-  lastSyncHashes = /* @__PURE__ */ new Map();
-  syncedDatabases = /* @__PURE__ */ new Set();
-  constructor(baseUrl, privateKey, organizationId, options) {
-    if (!baseUrl) {
-      throw new Error("Base URL is required");
-    }
-    if (!privateKey) {
-      throw new Error("Private key is required");
-    }
-    if (!organizationId) {
-      throw new Error("Organization ID is required");
-    }
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.privateKey = privateKey;
-    this.organizationId = organizationId;
-    this.defaultTenantId = options?.defaultTenantId;
-    this.additionalHeaders = options?.additionalHeaders;
-    this.fetchImpl = options?.fetch ?? globalThis.fetch;
-    if (!this.fetchImpl) {
-      throw new Error(
-        "Fetch implementation not found. Provide options.fetch or use Node 18+."
-      );
-    }
-  }
-  attachClickhouse(name, clientFn, options) {
-    const adapter = new ClickHouseAdapter(clientFn, options);
-    this.attachDatabase(name, adapter);
-    const metadata = {
-      name,
-      dialect: "clickhouse",
-      description: options?.description,
-      tags: options?.tags,
-      tenantFieldName: options?.tenantFieldName,
-      tenantFieldType: options?.tenantFieldType ?? "String",
-      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
-    };
-    this.databaseMetadata.set(name, metadata);
-  }
-  attachPostgres(name, clientFn, options) {
-    const adapter = new PostgresAdapter(clientFn, options);
-    this.attachDatabase(name, adapter);
-    const metadata = {
-      name,
-      dialect: "postgres",
-      description: options?.description,
-      tags: options?.tags,
-      tenantFieldName: options?.tenantFieldName,
-      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
-    };
-    this.databaseMetadata.set(name, metadata);
-  }
-  attachDatabase(name, adapter) {
-    this.databases.set(name, adapter);
-    if (!this.defaultDatabase) {
-      this.defaultDatabase = name;
-    }
-  }
-  async syncSchema(databaseName, options, signal) {
-    const tenantId = this.resolveTenantId(options.tenantId);
-    const adapter = this.getDatabase(databaseName);
-    const introspection = await adapter.introspect(
-      options.tables ? { tables: options.tables } : void 0
-    );
-    const payload = this.buildSchemaRequest(
-      databaseName,
-      adapter,
-      introspection
-    );
-    const hash = this.hashSchemaRequest(payload);
-    const previousHash = this.lastSyncHashes.get(databaseName);
-    if (!options.force && previousHash === hash) {
-      return {
-        success: true,
-        message: "Schema unchanged; skipping ingestion",
-        chunks: 0,
-        chunks_with_annotations: 0,
-        schema_hash: hash,
-        skipped: true
-      };
-    }
-    const sessionId = randomUUID();
-    const response = await this.post(
-      "/ingest",
-      payload,
-      tenantId,
-      options.userId,
-      options.scopes,
-      signal,
-      sessionId
-    );
-    this.lastSyncHashes.set(databaseName, hash);
-    this.syncedDatabases.add(databaseName);
-    return response;
-  }
-  async ingestKnowledgeBaseChunks(payload, options, signal) {
-    const tenantId = this.resolveTenantId(
-      payload.tenantId ?? options?.tenantId
-    );
-    return await this.post(
-      "/knowledge-base/chunks",
-      {
-        organization_id: this.organizationId,
-        tenant_id: tenantId,
-        database: payload.database,
-        dialect: payload.dialect,
-        tables: payload.tables
-      },
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async introspect(databaseName, tables) {
-    const adapter = this.getDatabase(databaseName);
-    return await adapter.introspect(tables ? { tables } : void 0);
-  }
-  async ask(question, options, signal) {
-    const tenantId = this.resolveTenantId(options.tenantId);
-    await this.ensureSchemasSynced(
-      tenantId,
-      options.userId,
-      options.scopes,
-      options.disableAutoSync
-    );
-    const sessionId = randomUUID();
-    const queryResponse = await this.post(
-      "/query",
-      {
-        question,
-        ...options.lastError ? { last_error: options.lastError } : {},
-        ...options.previousSql ? { previous_sql: options.previousSql } : {},
-        ...options.maxRetry ? { max_retry: options.maxRetry } : {}
-      },
-      tenantId,
-      options.userId,
-      options.scopes,
-      signal,
-      sessionId
-    );
-    const databaseName = options.database ?? this.defaultDatabase;
-    if (!databaseName) {
-      throw new Error(
-        "No database attached. Call attachPostgres/attachClickhouse first."
-      );
-    }
-    const adapter = this.getDatabase(databaseName);
-    const paramMetadata = Array.isArray(queryResponse.params) ? queryResponse.params : [];
-    const paramValues = this.mapGeneratedParams(paramMetadata);
-    const metadata = this.databaseMetadata.get(databaseName);
-    if (metadata) {
-      queryResponse.sql = this.ensureTenantIsolation(
-        queryResponse.sql,
-        paramValues,
-        metadata,
-        tenantId
-      );
-    }
-    await adapter.validate(queryResponse.sql, paramValues);
-    const execution = await adapter.execute(queryResponse.sql, paramValues);
-    const rows = execution.rows ?? [];
-    let chart = {
-      vegaLiteSpec: null,
-      notes: rows.length === 0 ? "Query returned no rows." : null
-    };
-    if (rows.length > 0) {
-      const chartResponse = await this.post(
-        "/chart",
-        {
-          question,
-          sql: queryResponse.sql,
-          rationale: queryResponse.rationale,
-          fields: execution.fields,
-          rows: anonymizeResults(rows),
-          max_retries: options.chartMaxRetries ?? 3,
-          query_id: queryResponse.queryId
-        },
-        tenantId,
-        options.userId,
-        options.scopes,
-        signal,
-        sessionId
-      );
-      chart = {
-        vegaLiteSpec: chartResponse.chart ? {
-          ...chartResponse.chart,
-          data: { values: rows }
-        } : null,
-        notes: chartResponse.notes
-      };
-    }
-    return {
-      sql: queryResponse.sql,
-      params: paramValues,
-      paramMetadata,
-      rationale: queryResponse.rationale,
-      dialect: queryResponse.dialect,
-      queryId: queryResponse.queryId,
-      rows,
-      fields: execution.fields,
-      chart,
-      context: queryResponse.context
-    };
-  }
-  async upsertAnnotation(input, options, signal) {
-    const tenantId = this.resolveTenantId(input.tenantId ?? options?.tenantId);
-    const response = await this.post(
-      "/knowledge-base/annotations",
-      {
-        organization_id: this.organizationId,
-        tenant_id: tenantId,
-        target_identifier: input.targetIdentifier,
-        content: input.content,
-        user_id: input.userId
-      },
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return response.annotation;
-  }
-  async listAnnotations(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const response = await this.get(
-      "/knowledge-base/annotations",
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return response.annotations;
-  }
-  async getAnnotation(targetIdentifier, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const response = await this.get(
-      `/knowledge-base/annotations/${encodeURIComponent(targetIdentifier)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    ).catch((error) => {
-      if (error?.status === 404) {
-        return { success: false, annotation: null };
-      }
-      throw error;
-    });
-    return response.annotation ?? null;
-  }
-  async deleteAnnotation(targetIdentifier, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/knowledge-base/annotations/${encodeURIComponent(targetIdentifier)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async createChart(body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.post(
-      "/charts",
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async listCharts(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const params = new URLSearchParams();
-    if (options?.pagination?.page)
-      params.set("page", `${options.pagination.page}`);
-    if (options?.pagination?.limit)
-      params.set("limit", `${options.pagination.limit}`);
-    if (options?.sortBy) params.set("sort_by", options.sortBy);
-    if (options?.sortDir) params.set("sort_dir", options.sortDir);
-    if (options?.title) params.set("title", options.title);
-    if (options?.userFilter) params.set("user_id", options.userFilter);
-    if (options?.createdFrom) params.set("created_from", options.createdFrom);
-    if (options?.createdTo) params.set("created_to", options.createdTo);
-    if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
-    if (options?.updatedTo) params.set("updated_to", options.updatedTo);
-    const response = await this.get(
-      `/charts${params.toString() ? `?${params.toString()}` : ""}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.includeData) {
-      response.data = await Promise.all(
-        response.data.map(async (chart) => ({
-          ...chart,
-          vega_lite_spec: {
-            ...chart.vega_lite_spec,
-            data: {
-              values: await this.runSafeQueryOnClient(
-                chart.sql,
-                chart.database ?? void 0,
-                chart.sql_params ?? void 0
-              )
-            }
-          }
-        }))
-      );
-    }
-    return response;
-  }
-  async getChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const chart = await this.get(
-      `/charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    return {
-      ...chart,
-      vega_lite_spec: {
-        ...chart.vega_lite_spec,
-        data: {
-          values: await this.runSafeQueryOnClient(
-            chart.sql,
-            chart.database ?? void 0,
-            chart.sql_params ?? void 0
-          )
-        }
-      }
-    };
-  }
-  async updateChart(id, body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.put(
-      `/charts/${encodeURIComponent(id)}`,
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async deleteChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async createActiveChart(body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.post(
-      "/active-charts",
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async listActiveCharts(options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const params = new URLSearchParams();
-    if (options?.pagination?.page)
-      params.set("page", `${options.pagination.page}`);
-    if (options?.pagination?.limit)
-      params.set("limit", `${options.pagination.limit}`);
-    if (options?.sortBy) params.set("sort_by", options.sortBy);
-    if (options?.sortDir) params.set("sort_dir", options.sortDir);
-    if (options?.title) params.set("name", options.title);
-    if (options?.userFilter) params.set("user_id", options.userFilter);
-    if (options?.createdFrom) params.set("created_from", options.createdFrom);
-    if (options?.createdTo) params.set("created_to", options.createdTo);
-    if (options?.updatedFrom) params.set("updated_from", options.updatedFrom);
-    if (options?.updatedTo) params.set("updated_to", options.updatedTo);
-    const response = await this.get(
-      `/active-charts${params.toString() ? `?${params.toString()}` : ""}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.withData) {
-      response.data = await Promise.all(
-        response.data.map(async (active) => ({
-          ...active,
-          chart: active.chart ? await this.getChart(active.chart_id, options, signal) : null
-        }))
-      );
-    }
-    return response;
-  }
-  async getActiveChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    const active = await this.get(
-      `/active-charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-    if (options?.withData && active.chart_id) {
-      return {
-        ...active,
-        chart: await this.getChart(active.chart_id, options, signal)
-      };
-    }
-    return active;
-  }
-  async updateActiveChart(id, body, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    return await this.put(
-      `/active-charts/${encodeURIComponent(id)}`,
-      body,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  async deleteActiveChart(id, options, signal) {
-    const tenantId = this.resolveTenantId(options?.tenantId);
-    await this.delete(
-      `/active-charts/${encodeURIComponent(id)}`,
-      tenantId,
-      options?.userId,
-      options?.scopes,
-      signal
-    );
-  }
-  getDatabase(name) {
-    const dbName = name ?? this.defaultDatabase;
-    if (!dbName) {
-      throw new Error("No database attached.");
-    }
-    const adapter = this.databases.get(dbName);
-    if (!adapter) {
-      throw new Error(
-        `Database '${dbName}' not found. Attached: ${Array.from(
-          this.databases.keys()
-        ).join(", ")}`
-      );
-    }
-    return adapter;
-  }
-  async ensureSchemasSynced(tenantId, userId, scopes, disableAutoSync) {
-    if (disableAutoSync) return;
-    const unsynced = Array.from(this.databases.keys()).filter(
-      (name) => !this.syncedDatabases.has(name)
-    );
-    await Promise.all(
-      unsynced.map(
-        (name) => this.syncSchema(name, { tenantId, userId, scopes }).catch((error) => {
-          console.warn(`Failed to sync schema for ${name}:`, error);
-        })
-      )
-    );
-  }
-  resolveTenantId(tenantId) {
-    const resolved = tenantId ?? this.defaultTenantId;
-    if (!resolved) {
-      throw new Error(
-        "tenantId is required. Provide it per request or via defaultTenantId option."
-      );
-    }
-    return resolved;
-  }
-  async headers(tenantId, userId, scopes, includeJson = true, sessionId) {
-    const token = await this.generateJWT(tenantId, userId, scopes);
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json"
-    };
-    if (includeJson) {
-      headers["Content-Type"] = "application/json";
-    }
-    if (sessionId) {
-      headers["x-session-id"] = sessionId;
-    }
-    if (this.additionalHeaders) {
-      Object.assign(headers, this.additionalHeaders);
-    }
-    return headers;
-  }
-  async request(path, init) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, init);
-    const text = await response.text();
-    let json;
-    try {
-      json = text ? JSON.parse(text) : void 0;
-    } catch {
-      json = void 0;
-    }
-    if (!response.ok) {
-      const error = new Error(
-        json?.error || response.statusText || "Request failed"
-      );
-      error.status = response.status;
-      if (json?.details) error.details = json.details;
-      throw error;
-    }
-    return json;
-  }
-  async get(path, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "GET",
-      headers: await this.headers(tenantId, userId, scopes, false, sessionId),
-      signal
-    });
-  }
-  async post(path, body, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "POST",
-      headers: await this.headers(tenantId, userId, scopes, true, sessionId),
-      body: JSON.stringify(body ?? {}),
-      signal
-    });
-  }
-  async put(path, body, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "PUT",
-      headers: await this.headers(tenantId, userId, scopes, true, sessionId),
-      body: JSON.stringify(body ?? {}),
-      signal
-    });
-  }
-  async delete(path, tenantId, userId, scopes, signal, sessionId) {
-    return await this.request(path, {
-      method: "DELETE",
-      headers: await this.headers(tenantId, userId, scopes, false, sessionId),
-      signal
-    });
-  }
-  async generateJWT(tenantId, userId, scopes) {
-    if (!this.cachedPrivateKey) {
-      this.cachedPrivateKey = await importPKCS8(this.privateKey, "RS256");
-    }
-    const payload = {
-      organizationId: this.organizationId,
-      tenantId
-    };
-    if (userId) payload.userId = userId;
-    if (scopes?.length) payload.scopes = scopes;
-    return await new SignJWT(payload).setProtectedHeader({ alg: "RS256" }).setIssuedAt().setExpirationTime("1h").sign(this.cachedPrivateKey);
-  }
-  buildSchemaRequest(databaseName, adapter, introspection) {
-    const dialect = adapter.getDialect();
-    const tables = introspection.tables.map((table) => ({
-      table_name: table.name,
-      description: table.comment ?? `Table ${table.name}`,
-      columns: table.columns.map((column) => ({
-        name: column.name,
-        data_type: column.rawType ?? column.type,
-        is_primary_key: Boolean(column.isPrimaryKey),
-        description: column.comment ?? ""
-      }))
-    }));
-    return {
-      database: databaseName,
-      dialect,
-      tables
-    };
-  }
-  hashSchemaRequest(payload) {
-    const normalized = payload.tables.map((table) => ({
-      name: table.table_name,
-      columns: table.columns.map((column) => ({
-        name: column.name,
-        type: column.data_type,
-        primary: column.is_primary_key
-      }))
-    }));
-    return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
-  }
-  mapGeneratedParams(params) {
-    const record = {};
-    params.forEach((param, index) => {
-      const value = param.value;
-      if (value === void 0) {
-        return;
-      }
-      const nameCandidate = typeof param.name === "string" && param.name.trim() || typeof param.placeholder === "string" && param.placeholder.trim() || typeof param.position === "number" && String(param.position) || String(index + 1);
-      const key = nameCandidate.replace(/[{}:$]/g, "").trim();
-      record[key] = value;
-    });
-    return record;
-  }
-  ensureTenantIsolation(sql, params, metadata, tenantId) {
-    if (!metadata.tenantFieldName || metadata.enforceTenantIsolation === false) {
-      return sql;
-    }
-    const tenantField = metadata.tenantFieldName;
-    const paramKey = tenantField;
-    params[paramKey] = tenantId;
-    const normalizedSql = sql.toLowerCase();
-    if (normalizedSql.includes(tenantField.toLowerCase())) {
-      return sql;
-    }
-    const tenantPredicate = metadata.dialect === "clickhouse" ? `${tenantField} = {${tenantField}:${metadata.tenantFieldType ?? "String"}}` : `${tenantField} = '${tenantId}'`;
-    if (/\bwhere\b/i.test(sql)) {
-      return sql.replace(
-        /\bwhere\b/i,
-        (match) => `${match} ${tenantPredicate} AND `
-      );
-    }
-    return `${sql} WHERE ${tenantPredicate}`;
-  }
-  async runSafeQueryOnClient(sql, database, params) {
-    try {
-      const adapter = this.getDatabase(database);
-      const result = await adapter.execute(sql, params);
-      return result.rows;
-    } catch (error) {
-      console.warn(
-        `Failed to execute SQL locally for database '${database}':`,
-        error
-      );
-      return [];
-    }
-  }
-};
-function anonymizeResults(rows) {
-  if (!rows?.length) return [];
-  return rows.map((row) => {
-    const masked = {};
-    Object.entries(row).forEach(([key, value]) => {
-      if (value === null) masked[key] = "null";
-      else if (Array.isArray(value)) masked[key] = "array";
-      else masked[key] = typeof value;
-    });
-    return masked;
-  });
-}
-export {
-  ClickHouseAdapter,
-  PostgresAdapter,
-  QueryPanelSdkAPI,
-  anonymizeResults
-};
-//# sourceMappingURL=index.js.map