@querypanel/node-sdk 1.0.26 → 1.0.27

package/dist/index.cjs

@@ -0,0 +1,1292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClickHouseAdapter: () => ClickHouseAdapter,
+  PostgresAdapter: () => PostgresAdapter,
+  QueryPanelSdkAPI: () => QueryPanelSdkAPI,
+  anonymizeResults: () => anonymizeResults
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/clickhouse.ts
+var WRAPPER_REGEX = /^(Nullable|LowCardinality|SimpleAggregateFunction)\((.+)\)$/i;
+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 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";
+  }
+  /**
+   * Simplified introspection: only collect table/column metadata for IngestRequest
+   * No indexes, constraints, or statistics
+   */
+  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, primary_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, 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);
+      for (const column of tableColumns) {
+        column.isPrimaryKey = column.isPrimaryKey || primaryKeyColumns.includes(column.name);
+      }
+      const base = {
+        name: table.name,
+        schema: this.databaseName,
+        type: asTableType(table.engine),
+        columns: tableColumns
+      };
+      const comment = sanitize(table.comment);
+      if (comment !== void 0) {
+        base.comment = comment;
+      }
+      return base;
+    });
+    return {
+      db: {
+        kind: this.kind,
+        name: this.databaseName
+      },
+      tables: tableSchemas,
+      introspectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  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 unwrappedType = unwrapTypeModifiers(row.type);
+  const column = {
+    name: row.name,
+    type: unwrappedType,
+    rawType: row.type,
+    isPrimaryKey: Boolean(toNumber(row.is_in_primary_key))
+  };
+  const comment = sanitize(row.comment);
+  if (comment !== void 0) column.comment = comment;
+  return column;
+}
+function asTableType(engine) {
+  if (typeof engine === "string") {
+    const normalized = engine.toLowerCase();
+    if (normalized.includes("view")) {
+      return "view";
+    }
+  }
+  return "table";
+}
+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 };
+  }
+  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]
+   */
+  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";
+  }
+  /**
+   * Simplified introspection: only collect table/column metadata for IngestRequest
+   * No indexes, constraints, or statistics
+   */
+  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 tablesByKey = /* @__PURE__ */ new Map();
+    for (const row of tableRows) {
+      const key = tableKey(row.schema_name, row.table_name);
+      const table = {
+        name: row.table_name,
+        schema: row.schema_name,
+        type: asTableType2(row.table_type),
+        columns: []
+      };
+      const comment = sanitize2(row.comment);
+      if (comment !== void 0) {
+        table.comment = comment;
+      }
+      tablesByKey.set(key, table);
+    }
+    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,
+        isPrimaryKey: row.is_primary_key
+      };
+      const rawType = row.udt_name ?? void 0;
+      if (rawType !== void 0) column.rawType = rawType;
+      const comment = sanitize2(row.description);
+      if (comment !== void 0) column.comment = comment;
+      table.columns.push(column);
+    }
+    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 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
+  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,
+    pgd.description,
+    EXISTS(
+      SELECT 1
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_schema = cols.table_schema
+        AND tc.table_name = cols.table_name
+        AND kcu.column_name = cols.column_name
+    ) AS is_primary_key
+  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 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 sanitize2(value) {
+  if (value === null || value === void 0) return void 0;
+  const trimmed = String(value).trim();
+  return trimmed.length ? trimmed : void 0;
+}
+
+// src/core/client.ts
+var import_jose = require("jose");
+var ApiClient = class {
+  baseUrl;
+  privateKey;
+  organizationId;
+  defaultTenantId;
+  additionalHeaders;
+  fetchImpl;
+  cachedPrivateKey;
+  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+."
+      );
+    }
+  }
+  getDefaultTenantId() {
+    return this.defaultTenantId;
+  }
+  async get(path, tenantId, userId, scopes, signal, sessionId) {
+    return await this.request(path, {
+      method: "GET",
+      headers: await this.buildHeaders(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.buildHeaders(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.buildHeaders(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.buildHeaders(tenantId, userId, scopes, false, sessionId),
+      signal
+    });
+  }
+  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 buildHeaders(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 generateJWT(tenantId, userId, scopes) {
+    if (!this.cachedPrivateKey) {
+      this.cachedPrivateKey = await (0, import_jose.importPKCS8)(this.privateKey, "RS256");
+    }
+    const payload = {
+      organizationId: this.organizationId,
+      tenantId
+    };
+    if (userId) payload.userId = userId;
+    if (scopes?.length) payload.scopes = scopes;
+    return await new import_jose.SignJWT(payload).setProtectedHeader({ alg: "RS256" }).setIssuedAt().setExpirationTime("1h").sign(this.cachedPrivateKey);
+  }
+};
+
+// src/core/query-engine.ts
+var QueryEngine = class {
+  databases = /* @__PURE__ */ new Map();
+  databaseMetadata = /* @__PURE__ */ new Map();
+  defaultDatabase;
+  attachDatabase(name, adapter, metadata) {
+    this.databases.set(name, adapter);
+    this.databaseMetadata.set(name, metadata);
+    if (!this.defaultDatabase) {
+      this.defaultDatabase = name;
+    }
+  }
+  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;
+  }
+  getDatabaseMetadata(name) {
+    const dbName = name ?? this.defaultDatabase;
+    if (!dbName) return void 0;
+    return this.databaseMetadata.get(dbName);
+  }
+  getDefaultDatabase() {
+    return this.defaultDatabase;
+  }
+  async validateAndExecute(sql, params, databaseName, tenantId) {
+    const adapter = this.getDatabase(databaseName);
+    const metadata = this.getDatabaseMetadata(databaseName);
+    let finalSql = sql;
+    if (metadata) {
+      finalSql = this.ensureTenantIsolation(sql, params, metadata, tenantId);
+    }
+    await adapter.validate(finalSql, params);
+    const result = await adapter.execute(finalSql, params);
+    return {
+      rows: result.rows,
+      fields: result.fields
+    };
+  }
+  async execute(sql, params, databaseName) {
+    try {
+      const adapter = this.getDatabase(databaseName);
+      const result = await adapter.execute(sql, params);
+      return result.rows;
+    } catch (error) {
+      console.warn(
+        `Failed to execute SQL locally for database '${databaseName}':`,
+        error
+      );
+      return [];
+    }
+  }
+  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}`;
+  }
+};
+
+// src/routes/charts.ts
+async function createChart(client, body, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  return await client.post(
+    "/charts",
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listCharts(client, queryEngine, options, signal) {
+  const tenantId = resolveTenantId(client, 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 client.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 queryEngine.execute(
+              chart.sql,
+              chart.sql_params ?? void 0,
+              chart.target_db ?? void 0
+            )
+          }
+        }
+      }))
+    );
+  }
+  return response;
+}
+async function getChart(client, queryEngine, id, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  const chart = await client.get(
+    `/charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  return {
+    ...chart,
+    vega_lite_spec: {
+      ...chart.vega_lite_spec,
+      data: {
+        values: await queryEngine.execute(
+          chart.sql,
+          chart.sql_params ?? void 0,
+          chart.target_db ?? void 0
+        )
+      }
+    }
+  };
+}
+async function updateChart(client, id, body, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  return await client.put(
+    `/charts/${encodeURIComponent(id)}`,
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteChart(client, id, options, signal) {
+  const tenantId = resolveTenantId(client, options?.tenantId);
+  await client.delete(
+    `/charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+function resolveTenantId(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+
+// src/routes/active-charts.ts
+async function createActiveChart(client, body, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  return await client.post(
+    "/active-charts",
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listActiveCharts(client, queryEngine, options, signal) {
+  const tenantId = resolveTenantId2(client, 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 client.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 getChart(
+          client,
+          queryEngine,
+          active.chart_id,
+          options,
+          signal
+        ) : null
+      }))
+    );
+  }
+  return response;
+}
+async function getActiveChart(client, queryEngine, id, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  const active = await client.get(
+    `/active-charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+  if (options?.withData && active.chart_id) {
+    return {
+      ...active,
+      chart: await getChart(
+        client,
+        queryEngine,
+        active.chart_id,
+        options,
+        signal
+      )
+    };
+  }
+  return active;
+}
+async function updateActiveChart(client, id, body, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  return await client.put(
+    `/active-charts/${encodeURIComponent(id)}`,
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteActiveChart(client, id, options, signal) {
+  const tenantId = resolveTenantId2(client, options?.tenantId);
+  await client.delete(
+    `/active-charts/${encodeURIComponent(id)}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+function resolveTenantId2(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+
+// src/routes/ingest.ts
+var import_node_crypto = require("crypto");
+async function syncSchema(client, queryEngine, databaseName, options, signal) {
+  const tenantId = resolveTenantId3(client, options.tenantId);
+  const adapter = queryEngine.getDatabase(databaseName);
+  const introspection = await adapter.introspect(
+    options.tables ? { tables: options.tables } : void 0
+  );
+  const payload = buildSchemaRequest(databaseName, adapter, introspection);
+  const sessionId = (0, import_node_crypto.randomUUID)();
+  const response = await client.post(
+    "/ingest",
+    payload,
+    tenantId,
+    options.userId,
+    options.scopes,
+    signal,
+    sessionId
+  );
+  return response;
+}
+function resolveTenantId3(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+function 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
+  };
+}
+
+// src/routes/query.ts
+var import_node_crypto2 = require("crypto");
+async function ask(client, queryEngine, question, options, signal) {
+  const tenantId = resolveTenantId4(client, options.tenantId);
+  const sessionId = (0, import_node_crypto2.randomUUID)();
+  const maxRetry = options.maxRetry ?? 0;
+  let attempt = 0;
+  let lastError = options.lastError;
+  let previousSql = options.previousSql;
+  while (attempt <= maxRetry) {
+    console.log({ lastError, previousSql });
+    const queryResponse = await client.post(
+      "/query",
+      {
+        question,
+        ...lastError ? { last_error: lastError } : {},
+        ...previousSql ? { previous_sql: previousSql } : {},
+        ...options.maxRetry ? { max_retry: options.maxRetry } : {}
+      },
+      tenantId,
+      options.userId,
+      options.scopes,
+      signal,
+      sessionId
+    );
+    const databaseName = queryResponse.database ?? options.database ?? queryEngine.getDefaultDatabase();
+    if (!databaseName) {
+      throw new Error(
+        "No database attached. Call attachPostgres/attachClickhouse first."
+      );
+    }
+    const paramMetadata = Array.isArray(queryResponse.params) ? queryResponse.params : [];
+    const paramValues = queryEngine.mapGeneratedParams(paramMetadata);
+    try {
+      const execution = await queryEngine.validateAndExecute(
+        queryResponse.sql,
+        paramValues,
+        databaseName,
+        tenantId
+      );
+      const rows = execution.rows ?? [];
+      let chart = {
+        vegaLiteSpec: null,
+        notes: rows.length === 0 ? "Query returned no rows." : null
+      };
+      if (rows.length > 0) {
+        const chartResponse = await client.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,
+        attempts: attempt + 1
+      };
+    } catch (error) {
+      attempt++;
+      if (attempt > maxRetry) {
+        throw error;
+      }
+      lastError = error instanceof Error ? error.message : String(error);
+      previousSql = queryResponse.sql;
+      console.warn(
+        `SQL execution failed (attempt ${attempt}/${maxRetry + 1}): ${lastError}. Retrying...`
+      );
+    }
+  }
+  throw new Error("Unexpected error in ask retry loop");
+}
+function resolveTenantId4(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (!resolved) {
+    throw new Error(
+      "tenantId is required. Provide it per request or via defaultTenantId option."
+    );
+  }
+  return resolved;
+}
+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;
+  });
+}
+
+// src/index.ts
+var QueryPanelSdkAPI = class {
+  client;
+  queryEngine;
+  constructor(baseUrl, privateKey, organizationId, options) {
+    this.client = new ApiClient(baseUrl, privateKey, organizationId, options);
+    this.queryEngine = new QueryEngine();
+  }
+  // Database attachment methods
+  attachClickhouse(name, clientFn, options) {
+    const adapter = new ClickHouseAdapter(clientFn, options);
+    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.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  attachPostgres(name, clientFn, options) {
+    const adapter = new PostgresAdapter(clientFn, options);
+    const metadata = {
+      name,
+      dialect: "postgres",
+      description: options?.description,
+      tags: options?.tags,
+      tenantFieldName: options?.tenantFieldName,
+      enforceTenantIsolation: options?.tenantFieldName ? options?.enforceTenantIsolation ?? true : void 0
+    };
+    this.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  attachDatabase(name, adapter) {
+    const metadata = {
+      name,
+      dialect: adapter.getDialect()
+    };
+    this.queryEngine.attachDatabase(name, adapter, metadata);
+  }
+  // Schema introspection and sync
+  async introspect(databaseName, tables) {
+    const adapter = this.queryEngine.getDatabase(databaseName);
+    return await adapter.introspect(tables ? { tables } : void 0);
+  }
+  async syncSchema(databaseName, options, signal) {
+    return await syncSchema(
+      this.client,
+      this.queryEngine,
+      databaseName,
+      options,
+      signal
+    );
+  }
+  // Natural language query
+  async ask(question, options, signal) {
+    return await ask(
+      this.client,
+      this.queryEngine,
+      question,
+      options,
+      signal
+    );
+  }
+  // Chart CRUD operations
+  async createChart(body, options, signal) {
+    return await createChart(this.client, body, options, signal);
+  }
+  async listCharts(options, signal) {
+    return await listCharts(
+      this.client,
+      this.queryEngine,
+      options,
+      signal
+    );
+  }
+  async getChart(id, options, signal) {
+    return await getChart(
+      this.client,
+      this.queryEngine,
+      id,
+      options,
+      signal
+    );
+  }
+  async updateChart(id, body, options, signal) {
+    return await updateChart(
+      this.client,
+      id,
+      body,
+      options,
+      signal
+    );
+  }
+  async deleteChart(id, options, signal) {
+    await deleteChart(this.client, id, options, signal);
+  }
+  // Active Chart CRUD operations
+  async createActiveChart(body, options, signal) {
+    return await createActiveChart(
+      this.client,
+      body,
+      options,
+      signal
+    );
+  }
+  async listActiveCharts(options, signal) {
+    return await listActiveCharts(
+      this.client,
+      this.queryEngine,
+      options,
+      signal
+    );
+  }
+  async getActiveChart(id, options, signal) {
+    return await getActiveChart(
+      this.client,
+      this.queryEngine,
+      id,
+      options,
+      signal
+    );
+  }
+  async updateActiveChart(id, body, options, signal) {
+    return await updateActiveChart(
+      this.client,
+      id,
+      body,
+      options,
+      signal
+    );
+  }
+  async deleteActiveChart(id, options, signal) {
+    await deleteActiveChart(this.client, id, options, signal);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClickHouseAdapter,
+  PostgresAdapter,
+  QueryPanelSdkAPI,
+  anonymizeResults
+});
+//# sourceMappingURL=index.cjs.map