@squadbase/vite-server 0.1.12-dev.822582a → 0.1.12-dev.93b8799

package/dist/vite-plugin.js

@@ -118,6 +118,14 @@ var ConnectorPlugin = class _ConnectorPlugin {
   tools;
   query;
   checkConnection;
+  /**
+   * SQPD-1212: Logic-based, rule-driven connection setup. Connectors that
+   * implement this expose a step-by-step exploration flow (database/schema/
+   * table/etc. discovery) that the dashboard backend drives via the
+   * `/connections/:connectionId/setup` endpoint. Implement by delegating to
+   * `runSetupFlow` from `setup-flow.ts`.
+   */
+  setup;
   constructor(config) {
     this.slug = config.slug;
     this.authType = config.authType;
@@ -134,6 +142,7 @@ var ConnectorPlugin = class _ConnectorPlugin {
     this.tools = config.tools;
     this.query = config.query;
     this.checkConnection = config.checkConnection;
+    this.setup = config.setup;
   }
   get connectorKey() {
     return _ConnectorPlugin.deriveKey(this.slug, this.authType);
@@ -198,6 +207,50 @@ var ConnectorPlugin = class _ConnectorPlugin {
   }
 };
 
+// ../connectors/src/setup-flow.ts
+async function runSetupFlow(flow, params, ctx, config) {
+  const runtime = {
+    params,
+    language: ctx.language,
+    config
+  };
+  let state = flow.initialState();
+  let answerIdx = 0;
+  for (const step of flow.steps) {
+    const ans = ctx.answers[answerIdx];
+    if (ans && ans.questionSlug === step.slug) {
+      state = step.applyAnswer(state, ans.answer);
+      answerIdx += 1;
+      continue;
+    }
+    if (step.type === "text") {
+      return {
+        type: "nextQuestion",
+        questionSlug: step.slug,
+        question: step.question[ctx.language],
+        questionType: "text"
+      };
+    }
+    const options = step.fetchOptions ? await step.fetchOptions(state, runtime) : [];
+    if (options.length === 0) {
+      continue;
+    }
+    if (step.autoSelectIfSingle && options.length === 1) {
+      state = step.applyAnswer(state, [options[0].value]);
+      continue;
+    }
+    return {
+      type: "nextQuestion",
+      questionSlug: step.slug,
+      question: step.question[ctx.language],
+      questionType: "multiSelect",
+      options
+    };
+  }
+  const dataInvestigationResult = await flow.finalize(state, runtime);
+  return { type: "fulfilled", dataInvestigationResult };
+}
+
 // ../connectors/src/auth-types.ts
 var AUTH_TYPES = {
   OAUTH: "oauth",
@@ -359,6 +412,125 @@ var parameters = {
   })
 };
 
+// ../connectors/src/connectors/snowflake/setup-flow.ts
+var ALL_TABLES = "__ALL_TABLES__";
+var INTERNAL_SCHEMAS = /* @__PURE__ */ new Set([
+  "INFORMATION_SCHEMA",
+  "ACCOUNT_USAGE",
+  "READER_ACCOUNT_USAGE",
+  "DATA_SHARING_USAGE"
+]);
+function createSnowflakeSetupFlow(runQuery3) {
+  return {
+    initialState: () => ({}),
+    steps: [
+      {
+        slug: "database",
+        type: "multiSelect",
+        autoSelectIfSingle: true,
+        question: {
+          ja: "\u30BB\u30C3\u30C8\u30A2\u30C3\u30D7\u306B\u4F7F\u3046\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044\uFF081 \u4EF6\u306E\u307F\uFF09",
+          en: "Select the database to use for setup (pick one)"
+        },
+        async fetchOptions(_state, rt) {
+          const rows = await runQuery3(rt.params, "SHOW DATABASES");
+          return rows.map((r) => String(r["name"] ?? "")).filter((name) => name && !name.endsWith("_SHARE")).map((value) => ({ value }));
+        },
+        applyAnswer: (state, answer) => ({ ...state, database: answer[0] })
+      },
+      {
+        slug: "schema",
+        type: "multiSelect",
+        autoSelectIfSingle: true,
+        question: {
+          ja: "\u30BB\u30C3\u30C8\u30A2\u30C3\u30D7\u306B\u4F7F\u3046\u30B9\u30AD\u30FC\u30DE\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044\uFF081 \u4EF6\u306E\u307F\uFF09",
+          en: "Select the schema to use for setup (pick one)"
+        },
+        async fetchOptions(state, rt) {
+          if (!state.database) return [];
+          const rows = await runQuery3(
+            rt.params,
+            `SHOW SCHEMAS IN DATABASE "${state.database}"`
+          );
+          return rows.map((r) => String(r["name"] ?? "")).filter(
+            (name) => name && !INTERNAL_SCHEMAS.has(name.toUpperCase())
+          ).map((value) => ({ value }));
+        },
+        applyAnswer: (state, answer) => ({ ...state, schema: answer[0] })
+      },
+      {
+        slug: "tables",
+        type: "multiSelect",
+        question: {
+          ja: "\u5BFE\u8C61\u30C6\u30FC\u30D6\u30EB\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044\uFF08\u8907\u6570\u9078\u629E\u53EF\uFF09",
+          en: "Select target tables (multi-select allowed)"
+        },
+        async fetchOptions(state, rt) {
+          if (!state.database || !state.schema) return [];
+          const rows = await runQuery3(
+            rt.params,
+            `SHOW TABLES IN SCHEMA "${state.database}"."${state.schema}"`
+          );
+          const tableOptions = rows.map((r) => String(r["name"] ?? "")).filter((name) => name).map((value) => ({ value }));
+          return [
+            {
+              value: ALL_TABLES,
+              label: rt.language === "ja" ? "\u3059\u3079\u3066\u306E\u30C6\u30FC\u30D6\u30EB" : "All tables"
+            },
+            ...tableOptions
+          ];
+        },
+        applyAnswer: (state, answer) => ({ ...state, tables: answer })
+      }
+    ],
+    async finalize(state, rt) {
+      if (!state.database || !state.schema || !state.tables) {
+        throw new Error("Snowflake setup: incomplete state on finalize");
+      }
+      const db = state.database;
+      const schema = state.schema;
+      let targetTables;
+      if (state.tables.includes(ALL_TABLES)) {
+        const rows = await runQuery3(
+          rt.params,
+          `SHOW TABLES IN SCHEMA "${db}"."${schema}"`
+        );
+        targetTables = rows.map((r) => String(r["name"] ?? "")).filter((name) => name);
+      } else {
+        targetTables = state.tables.filter((t) => t !== ALL_TABLES);
+      }
+      const sections = [
+        "## Snowflake",
+        "",
+        `### Database: ${db}`,
+        "",
+        `#### Schema: ${schema}`,
+        ""
+      ];
+      for (const table of targetTables) {
+        const cols = await runQuery3(
+          rt.params,
+          `DESCRIBE TABLE "${db}"."${schema}"."${table}"`
+        );
+        sections.push(`##### Table: ${table}`, "");
+        sections.push("| Column | Type | Nullable | Default |");
+        sections.push("|--------|------|----------|---------|");
+        for (const c of cols) {
+          const name = String(c["name"] ?? "");
+          const type = String(c["type"] ?? "");
+          const nullable = String(c["null?"] ?? "");
+          const defaultValue = c["default"] == null ? "-" : String(c["default"]);
+          sections.push(
+            `| ${name} | ${type} | ${nullable} | ${defaultValue} |`
+          );
+        }
+        sections.push("");
+      }
+      return sections.join("\n");
+    }
+  };
+}
+
 // ../connectors/src/connectors/snowflake/tools/execute-query.ts
 import { z } from "zod";
 
@@ -403,6 +575,49 @@ function decryptPrivateKey(pem, passphrase) {
     passphrase
   }).export({ type: "pkcs8", format: "pem" });
 }
+async function runQuery(params, sql) {
+  const snowflake = (await import("snowflake-sdk")).default;
+  snowflake.configure({ logLevel: "ERROR" });
+  const privateKeyPem = Buffer.from(
+    params[parameters.privateKeyBase64.slug],
+    "base64"
+  ).toString("utf-8");
+  const privateKeyPass = params[parameters.privateKeyPassphrase.slug] || void 0;
+  const privateKey = decryptPrivateKey(privateKeyPem, privateKeyPass);
+  const conn = snowflake.createConnection({
+    account: params[parameters.account.slug],
+    username: params[parameters.user.slug],
+    role: params[parameters.role.slug],
+    warehouse: params[parameters.warehouse.slug],
+    authenticator: "SNOWFLAKE_JWT",
+    privateKey
+  });
+  await new Promise((resolve, reject) => {
+    conn.connect((err) => {
+      if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
+      else resolve();
+    });
+  });
+  try {
+    return await new Promise((resolve, reject) => {
+      conn.execute({
+        sqlText: sql,
+        complete: (err, _stmt, rows) => {
+          if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
+          else resolve(rows ?? []);
+        }
+      });
+    });
+  } finally {
+    conn.destroy((err) => {
+      if (err) {
+        console.warn(
+          `[connector-query] Snowflake destroy error: ${err.message}`
+        );
+      }
+    });
+  }
+}
 async function executeWithSizeLimit(conn, sql, options) {
   const rows = [];
   let acc = 0;
@@ -557,6 +772,7 @@ Memory guidance:
 });
 
 // ../connectors/src/connectors/snowflake/index.ts
+var snowflakeSetupFlow = createSnowflakeSetupFlow(runQuery);
 var tools = { executeQuery: executeQueryTool };
 var snowflakeConnector = new ConnectorPlugin({
   slug: "snowflake",
@@ -603,6 +819,7 @@ The business logic type for this connector is "sql".
 - INFORMATION_SCHEMA \u3082\u5229\u7528\u53EF\u80FD: \`SELECT * FROM db_name.INFORMATION_SCHEMA.TABLES\``
   },
   tools,
+  setup: (params, ctx, config) => runSetupFlow(snowflakeSetupFlow, params, ctx, config),
   async checkConnection(params, _config) {
     try {
       const snowflake = (await import("snowflake-sdk")).default;
@@ -735,6 +952,47 @@ var parameters2 = {
   })
 };
 
+// ../connectors/src/connectors/snowflake-pat/utils.ts
+async function runQuery2(params, sql) {
+  const snowflake = (await import("snowflake-sdk")).default;
+  snowflake.configure({ logLevel: "ERROR" });
+  const conn = snowflake.createConnection({
+    account: params[parameters2.account.slug],
+    username: params[parameters2.user.slug],
+    role: params[parameters2.role.slug],
+    warehouse: params[parameters2.warehouse.slug],
+    password: params[parameters2.pat.slug]
+  });
+  await new Promise((resolve, reject) => {
+    conn.connect((err) => {
+      if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
+      else resolve();
+    });
+  });
+  try {
+    return await new Promise((resolve, reject) => {
+      conn.execute({
+        sqlText: sql,
+        complete: (err, _stmt, rows) => {
+          if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
+          else resolve(rows ?? []);
+        }
+      });
+    });
+  } finally {
+    conn.destroy((err) => {
+      if (err) {
+        console.warn(
+          `[connector-query] Snowflake destroy error: ${err.message}`
+        );
+      }
+    });
+  }
+}
+
+// ../connectors/src/connectors/snowflake-pat/setup-flow.ts
+var snowflakePatSetupFlow = createSnowflakeSetupFlow(runQuery2);
+
 // ../connectors/src/connectors/snowflake-pat/tools/execute-query.ts
 import { z as z2 } from "zod";
 var MAX_ROWS = 500;
@@ -887,6 +1145,7 @@ The business logic type for this connector is "sql".
 - INFORMATION_SCHEMA \u3082\u5229\u7528\u53EF\u80FD: \`SELECT * FROM db_name.INFORMATION_SCHEMA.TABLES\``
   },
   tools: tools2,
+  setup: (params, ctx, config) => runSetupFlow(snowflakePatSetupFlow, params, ctx, config),
   async checkConnection(params, _config) {
     try {
       const snowflake = (await import("snowflake-sdk")).default;
@@ -27962,6 +28221,10 @@ import { z as z98 } from "zod";
 var DEFAULT_API_VERSION = "3.28";
 var REQUEST_TIMEOUT_MS75 = 6e4;
 var sessionCache = /* @__PURE__ */ new Map();
+var inFlightSignIns = /* @__PURE__ */ new Map();
+function sessionCacheKey(serverUrl, siteContentUrl, patName) {
+  return `${serverUrl}|${siteContentUrl}|${patName}`;
+}
 function buildBaseUrl4(serverUrl, apiVersion) {
   return `${serverUrl.replace(/\/$/, "")}/api/${apiVersion}`;
 }
@@ -27996,21 +28259,39 @@ async function signIn(serverUrl, apiVersion, siteContentUrl, patName, patSecret)
     expiresAt: Date.now() + 30 * 60 * 1e3
   };
 }
-async function getSession(serverUrl, apiVersion, siteContentUrl, patName, patSecret) {
-  const cacheKey = `${serverUrl}|${siteContentUrl}|${patName}`;
-  const cached = sessionCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now() + 6e4) {
-    return cached;
+async function getSession(serverUrl, apiVersion, siteContentUrl, patName, patSecret, { forceRefresh = false } = {}) {
+  const cacheKey = sessionCacheKey(serverUrl, siteContentUrl, patName);
+  if (forceRefresh) {
+    sessionCache.delete(cacheKey);
+  } else {
+    const cached = sessionCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now() + 6e4) {
+      return cached;
+    }
   }
-  const session = await signIn(
+  const existing = inFlightSignIns.get(cacheKey);
+  if (existing) return existing;
+  const promise = signIn(
     serverUrl,
     apiVersion,
     siteContentUrl,
     patName,
     patSecret
-  );
-  sessionCache.set(cacheKey, session);
-  return session;
+  ).then((session) => {
+    sessionCache.set(cacheKey, session);
+    return session;
+  }).finally(() => {
+    inFlightSignIns.delete(cacheKey);
+  });
+  inFlightSignIns.set(cacheKey, promise);
+  return promise;
+}
+function invalidateSession(serverUrl, siteContentUrl, patName, staleAuthToken) {
+  const cacheKey = sessionCacheKey(serverUrl, siteContentUrl, patName);
+  const current = sessionCache.get(cacheKey);
+  if (current && current.authToken === staleAuthToken) {
+    sessionCache.delete(cacheKey);
+  }
 }
 var inputSchema98 = z98.object({
   toolUseIntent: z98.string().optional().describe(
@@ -28066,48 +28347,64 @@ Accept and Content-Type headers default to application/json so list responses co
       const patName = parameters81.patName.getValue(connection);
       const patSecret = parameters81.patSecret.getValue(connection);
       const apiVersion = parameters81.apiVersion.tryGetValue(connection) || DEFAULT_API_VERSION;
-      const session = await getSession(
-        serverUrl,
-        apiVersion,
-        siteContentUrl,
-        patName,
-        patSecret
-      );
-      const resolvedPath = path4.trim().replace(/\{siteId\}/g, session.siteId).replace(/^([^/])/, "/$1");
-      let url = `${buildBaseUrl4(serverUrl, apiVersion)}${resolvedPath}`;
-      if (queryParams) {
-        const searchParams = new URLSearchParams(queryParams);
-        url += `?${searchParams.toString()}`;
-      }
+      const trimmedPath = path4.trim().replace(/^([^/])/, "/$1");
+      const queryString = queryParams ? `?${new URLSearchParams(queryParams).toString()}` : "";
+      const baseUrl = buildBaseUrl4(serverUrl, apiVersion);
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS75);
       try {
-        const init = {
-          method,
-          headers: {
-            "X-Tableau-Auth": session.authToken,
-            Accept: "application/json",
-            "Content-Type": "application/json"
-          },
-          signal: controller.signal
-        };
-        if (body !== void 0) {
-          init.body = JSON.stringify(body);
-        }
-        const response = await fetch(url, init);
-        const text = await response.text();
-        const data = text ? (() => {
-          try {
-            return JSON.parse(text);
-          } catch {
-            return text;
+        let attempt = 0;
+        while (true) {
+          const session = await getSession(
+            serverUrl,
+            apiVersion,
+            siteContentUrl,
+            patName,
+            patSecret,
+            { forceRefresh: attempt > 0 }
+          );
+          const resolvedPath = trimmedPath.replace(
+            /\{siteId\}/g,
+            session.siteId
+          );
+          const url = `${baseUrl}${resolvedPath}${queryString}`;
+          const init = {
+            method,
+            headers: {
+              "X-Tableau-Auth": session.authToken,
+              Accept: "application/json",
+              "Content-Type": "application/json"
+            },
+            signal: controller.signal
+          };
+          if (body !== void 0) {
+            init.body = JSON.stringify(body);
           }
-        })() : null;
-        if (!response.ok) {
-          const errorMessage = data && typeof data === "object" && "error" in data ? JSON.stringify(data.error) : typeof data === "string" && data ? data : `HTTP ${response.status} ${response.statusText}`;
-          return { success: false, error: errorMessage };
+          const response = await fetch(url, init);
+          const text = await response.text();
+          const data = text ? (() => {
+            try {
+              return JSON.parse(text);
+            } catch {
+              return text;
+            }
+          })() : null;
+          if (response.status === 401 && attempt === 0) {
+            invalidateSession(
+              serverUrl,
+              siteContentUrl,
+              patName,
+              session.authToken
+            );
+            attempt++;
+            continue;
+          }
+          if (!response.ok) {
+            const errorMessage = data && typeof data === "object" && "error" in data ? JSON.stringify(data.error) : typeof data === "string" && data ? data : `HTTP ${response.status} ${response.statusText}`;
+            return { success: false, error: errorMessage };
+          }
+          return { success: true, status: response.status, data };
         }
-        return { success: true, status: response.status, data };
       } finally {
         clearTimeout(timeout);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.1.12-dev.822582a",
+  "version": "0.1.12-dev.93b8799",
   "type": "module",
   "exports": {
     ".": {