@querypanel/node-sdk 1.0.27 → 1.0.29

package/dist/index.cjs

@@ -26,9 +26,14 @@ __export(index_exports, {
   anonymizeResults: () => anonymizeResults
 });
 module.exports = __toCommonJS(index_exports);
+var import_node_crypto = require("crypto");
+var import_jose = require("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);
@@ -42,6 +47,26 @@ function unwrapTypeModifiers(type) {
   }
   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();
@@ -129,10 +154,6 @@ var ClickHouseAdapter = class {
   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 ?? [];
@@ -145,7 +166,7 @@ var ClickHouseAdapter = class {
     }
     const filterClause = hasFilter ? " AND name IN {tables:Array(String)}" : "";
     const tables = await this.query(
-      `SELECT name, engine, comment, primary_key
+      `SELECT name, engine, comment, total_rows, total_bytes, primary_key, sorting_key
        FROM system.tables
        WHERE database = {db:String}${filterClause}
        ORDER BY name`,
@@ -153,7 +174,7 @@ var ClickHouseAdapter = class {
     );
     const columnFilterClause = hasFilter ? " AND table IN {tables:Array(String)}" : "";
     const columns = await this.query(
-      `SELECT table, name, type, position, comment, is_in_primary_key
+      `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`,
@@ -168,19 +189,44 @@ var ClickHouseAdapter = class {
     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),
-        columns: tableColumns
+        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 {
@@ -192,6 +238,10 @@ var ClickHouseAdapter = class {
       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;
@@ -269,15 +319,29 @@ function normalizeTableFilter(tables) {
   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,
-    isPrimaryKey: Boolean(toNumber(row.is_in_primary_key))
+    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) {
@@ -289,6 +353,13 @@ function asTableType(engine) {
   }
   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();
@@ -331,6 +402,10 @@ var PostgresAdapter = class {
     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;
@@ -356,6 +431,11 @@ var PostgresAdapter = class {
   /**
    * 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);
@@ -388,10 +468,6 @@ var PostgresAdapter = class {
   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 ?? [];
@@ -403,20 +479,39 @@ var PostgresAdapter = class {
       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: []
+        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);
@@ -425,13 +520,80 @@ var PostgresAdapter = class {
       const column = {
         name: row.column_name,
         type: row.data_type,
-        isPrimaryKey: row.is_primary_key
+        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) {
@@ -449,6 +611,36 @@ var PostgresAdapter = class {
     };
   }
 };
+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 = [];
@@ -481,7 +673,9 @@ function buildTablesQuery(tables) {
       WHEN 'm' THEN 'materialized_view'
       ELSE c.relkind::text
     END AS table_type,
-    obj_description(c.oid) AS comment
+    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')
@@ -501,18 +695,13 @@ function buildColumnsQuery(tables) {
     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
+    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
@@ -527,6 +716,50 @@ function buildColumnsQuery(tables) {
     ${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 }) => {
@@ -547,15 +780,38 @@ function asTableType2(value) {
   }
   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/core/client.ts
-var import_jose = require("jose");
-var ApiClient = class {
+// src/index.ts
+var QueryPanelSdkAPI = class {
   baseUrl;
   privateKey;
   organizationId;
@@ -563,6 +819,11 @@ var ApiClient = class {
   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");
@@ -585,703 +846,621 @@ var ApiClient = class {
       );
     }
   }
-  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"
+  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
     };
-    if (includeJson) {
-      headers["Content-Type"] = "application/json";
-    }
-    if (sessionId) {
-      headers["x-session-id"] = sessionId;
-    }
-    if (this.additionalHeaders) {
-      Object.assign(headers, this.additionalHeaders);
-    }
-    return headers;
+    this.databaseMetadata.set(name, metadata);
   }
-  async generateJWT(tenantId, userId, scopes) {
-    if (!this.cachedPrivateKey) {
-      this.cachedPrivateKey = await (0, import_jose.importPKCS8)(this.privateKey, "RS256");
-    }
-    const payload = {
-      organizationId: this.organizationId,
-      tenantId
+  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
     };
-    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);
+    this.databaseMetadata.set(name, metadata);
   }
-};
-
-// src/core/query-engine.ts
-var QueryEngine = class {
-  databases = /* @__PURE__ */ new Map();
-  databaseMetadata = /* @__PURE__ */ new Map();
-  defaultDatabase;
-  attachDatabase(name, adapter, metadata) {
+  attachDatabase(name, adapter) {
     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(", ")}`
-      );
+  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
+      };
     }
-    return adapter;
+    const sessionId = (0, import_node_crypto.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;
   }
-  getDatabaseMetadata(name) {
-    const dbName = name ?? this.defaultDatabase;
-    if (!dbName) return void 0;
-    return this.databaseMetadata.get(dbName);
+  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
+    );
   }
-  getDefaultDatabase() {
-    return this.defaultDatabase;
+  async introspect(databaseName, tables) {
+    const adapter = this.getDatabase(databaseName);
+    return await adapter.introspect(tables ? { tables } : void 0);
   }
-  async validateAndExecute(sql, params, databaseName, tenantId) {
+  async ask(question, options, signal) {
+    const tenantId = this.resolveTenantId(options.tenantId);
+    await this.ensureSchemasSynced(
+      tenantId,
+      options.userId,
+      options.scopes,
+      options.disableAutoSync
+    );
+    const sessionId = (0, import_node_crypto.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 metadata = this.getDatabaseMetadata(databaseName);
-    let finalSql = sql;
+    const paramMetadata = Array.isArray(queryResponse.params) ? queryResponse.params : [];
+    const paramValues = this.mapGeneratedParams(paramMetadata);
+    const metadata = this.databaseMetadata.get(databaseName);
     if (metadata) {
-      finalSql = this.ensureTenantIsolation(sql, params, metadata, tenantId);
+      queryResponse.sql = this.ensureTenantIsolation(
+        queryResponse.sql,
+        paramValues,
+        metadata,
+        tenantId
+      );
     }
-    await adapter.validate(finalSql, params);
-    const result = await adapter.execute(finalSql, params);
-    return {
-      rows: result.rows,
-      fields: result.fields
+    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
     };
-  }
-  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
+    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
       );
-      return [];
+      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
+    };
   }
-  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",
+  async upsertAnnotation(input, options, signal) {
+    const tenantId = this.resolveTenantId(input.tenantId ?? options?.tenantId);
+    const response = await this.post(
+      "/knowledge-base/annotations",
       {
-        question,
-        ...lastError ? { last_error: lastError } : {},
-        ...previousSql ? { previous_sql: previousSql } : {},
-        ...options.maxRetry ? { max_retry: options.maxRetry } : {}
+        organization_id: this.organizationId,
+        tenant_id: tenantId,
+        target_identifier: input.targetIdentifier,
+        content: input.content,
+        user_id: input.userId
       },
       tenantId,
-      options.userId,
-      options.scopes,
-      signal,
-      sessionId
+      options?.userId,
+      options?.scopes,
+      signal
     );
-    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...`
-      );
-    }
+    return response.annotation;
   }
-  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."
+  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;
   }
-  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;
+  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 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();
+    return response.annotation ?? null;
   }
-  // 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,
+  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
     );
   }
-  // Natural language query
-  async ask(question, options, signal) {
-    return await ask(
-      this.client,
-      this.queryEngine,
-      question,
-      options,
+  async createChart(body, options, signal) {
+    const tenantId = this.resolveTenantId(options?.tenantId);
+    return await this.post(
+      "/charts",
+      body,
+      tenantId,
+      options?.userId,
+      options?.scopes,
       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,
+    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) {
-    return await getChart(
-      this.client,
-      this.queryEngine,
-      id,
-      options,
+    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) {
-    return await updateChart(
-      this.client,
-      id,
+    const tenantId = this.resolveTenantId(options?.tenantId);
+    return await this.put(
+      `/charts/${encodeURIComponent(id)}`,
       body,
-      options,
+      tenantId,
+      options?.userId,
+      options?.scopes,
       signal
     );
   }
   async deleteChart(id, options, signal) {
-    await deleteChart(this.client, id, options, signal);
+    const tenantId = this.resolveTenantId(options?.tenantId);
+    await this.delete(
+      `/charts/${encodeURIComponent(id)}`,
+      tenantId,
+      options?.userId,
+      options?.scopes,
+      signal
+    );
   }
-  // Active Chart CRUD operations
   async createActiveChart(body, options, signal) {
-    return await createActiveChart(
-      this.client,
+    const tenantId = this.resolveTenantId(options?.tenantId);
+    return await this.post(
+      "/active-charts",
       body,
-      options,
+      tenantId,
+      options?.userId,
+      options?.scopes,
       signal
     );
   }
   async listActiveCharts(options, signal) {
-    return await listActiveCharts(
-      this.client,
-      this.queryEngine,
-      options,
+    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) {
-    return await getActiveChart(
-      this.client,
-      this.queryEngine,
-      id,
-      options,
+    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) {
-    return await updateActiveChart(
-      this.client,
-      id,
+    const tenantId = this.resolveTenantId(options?.tenantId);
+    return await this.put(
+      `/active-charts/${encodeURIComponent(id)}`,
       body,
-      options,
+      tenantId,
+      options?.userId,
+      options?.scopes,
       signal
     );
   }
   async deleteActiveChart(id, options, signal) {
-    await deleteActiveChart(this.client, 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 (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);
+  }
+  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 (0, import_node_crypto.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;
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClickHouseAdapter,