@squadbase/vite-server 0.0.1-build-10 → 0.0.1-build-12

package/dist/vite-plugin.js

@@ -70,6 +70,152 @@ function createBigQueryClient(entry, connectionId) {
   };
 }
 
+// src/connection.ts
+import { getContext } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+var APP_SESSION_COOKIE_NAME = "__Host-squadbase-session";
+var PREVIEW_SESSION_COOKIE_NAME = "squadbase-preview-session";
+var APP_BASE_DOMAIN = "squadbase.app";
+var PREVIEW_BASE_DOMAIN = "preview.app.squadbase.dev";
+var SANDBOX_ID_ENV_NAME = "INTERNAL_SQUADBASE_SANDBOX_ID";
+var MACHINE_CREDENTIAL_ENV_NAME = "INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL";
+function resolveProxyUrl(connectionId) {
+  const connectionPath = `/_sqcore/connections/${connectionId}/request`;
+  const sandboxId = process.env[SANDBOX_ID_ENV_NAME];
+  if (sandboxId) {
+    const baseDomain2 = process.env["SQUADBASE_PREVIEW_BASE_DOMAIN"] ?? PREVIEW_BASE_DOMAIN;
+    return `https://${sandboxId}.${baseDomain2}${connectionPath}`;
+  }
+  const projectId = process.env["SQUADBASE_PROJECT_ID"];
+  if (!projectId) {
+    throw new Error(
+      "Project ID is required. Please set SQUADBASE_PROJECT_ID environment variable."
+    );
+  }
+  const baseDomain = process.env["SQUADBASE_APP_BASE_DOMAIN"] ?? APP_BASE_DOMAIN;
+  return `https://${projectId}.${baseDomain}${connectionPath}`;
+}
+function resolveAuthHeaders() {
+  const machineCredential = process.env[MACHINE_CREDENTIAL_ENV_NAME];
+  if (machineCredential) {
+    return { Authorization: `Bearer ${machineCredential}` };
+  }
+  const c = getContext();
+  const cookies = getCookie(c);
+  const previewSession = cookies[PREVIEW_SESSION_COOKIE_NAME];
+  if (previewSession) {
+    return {
+      Cookie: `${PREVIEW_SESSION_COOKIE_NAME}=${previewSession}`
+    };
+  }
+  const appSession = cookies[APP_SESSION_COOKIE_NAME];
+  if (appSession) {
+    return { Authorization: `Bearer ${appSession}` };
+  }
+  throw new Error(
+    "No authentication method available for connection proxy. Expected one of: INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL env var, preview session cookie, or app session cookie."
+  );
+}
+function connection(connectionId) {
+  return {
+    async fetch(url, options) {
+      const proxyUrl = resolveProxyUrl(connectionId);
+      const authHeaders = resolveAuthHeaders();
+      return await fetch(proxyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders
+        },
+        body: JSON.stringify({
+          url,
+          method: options?.method,
+          headers: options?.headers,
+          body: options?.body,
+          timeoutMs: options?.timeoutMs
+        })
+      });
+    }
+  };
+}
+
+// src/connector-client/bigquery-oauth.ts
+var MAX_RESULTS = 1e4;
+var POLL_INTERVAL_MS = 1e3;
+var POLL_TIMEOUT_MS = 12e4;
+function flattenRows(fields, rows) {
+  return rows.map((row) => {
+    const obj = {};
+    for (let i = 0; i < fields.length; i++) {
+      obj[fields[i].name] = row.f[i].v;
+    }
+    return obj;
+  });
+}
+function createBigQueryOAuthClient(entry, connectionId) {
+  const projectId = resolveEnvVar(entry, "project-id", connectionId);
+  const baseUrl = `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}`;
+  return {
+    async query(sql) {
+      const conn = connection(connectionId);
+      const res = await conn.fetch(`${baseUrl}/queries`, {
+        method: "POST",
+        body: {
+          query: sql,
+          useLegacySql: false,
+          maxResults: MAX_RESULTS
+        }
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => res.statusText);
+        throw new Error(`BigQuery query failed: HTTP ${res.status} ${text}`);
+      }
+      let data = await res.json();
+      if (data.errors?.length) {
+        throw new Error(
+          `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
+        );
+      }
+      if (!data.jobComplete) {
+        const jobId = data.jobReference.jobId;
+        const location = data.jobReference.location;
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        while (!data.jobComplete) {
+          if (Date.now() > deadline) {
+            throw new Error(
+              `BigQuery query timed out after ${POLL_TIMEOUT_MS / 1e3}s (jobId: ${jobId})`
+            );
+          }
+          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+          const params = new URLSearchParams({
+            maxResults: String(MAX_RESULTS)
+          });
+          if (location) params.set("location", location);
+          const pollRes = await conn.fetch(
+            `${baseUrl}/queries/${jobId}?${params}`,
+            { method: "GET" }
+          );
+          if (!pollRes.ok) {
+            const text = await pollRes.text().catch(() => pollRes.statusText);
+            throw new Error(
+              `BigQuery poll failed: HTTP ${pollRes.status} ${text}`
+            );
+          }
+          data = await pollRes.json();
+          if (data.errors?.length) {
+            throw new Error(
+              `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
+            );
+          }
+        }
+      }
+      const fields = data.schema?.fields ?? [];
+      const rawRows = data.rows ?? [];
+      return { rows: flattenRows(fields, rawRows) };
+    }
+  };
+}
+
 // src/connector-client/snowflake.ts
 function createSnowflakeClient(entry, connectionId) {
   const accountIdentifier = resolveEnvVar(entry, "account", connectionId);
@@ -82,7 +228,7 @@ function createSnowflakeClient(entry, connectionId) {
     async query(sql) {
       const snowflake = (await import("snowflake-sdk")).default;
       snowflake.configure({ logLevel: "ERROR" });
-      const connection = snowflake.createConnection({
+      const connection2 = snowflake.createConnection({
         account: accountIdentifier,
         username: user,
         role,
@@ -91,13 +237,13 @@ function createSnowflakeClient(entry, connectionId) {
         privateKey
       });
       await new Promise((resolve, reject) => {
-        connection.connect((err) => {
+        connection2.connect((err) => {
           if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
           else resolve();
         });
       });
       const rows = await new Promise((resolve, reject) => {
-        connection.execute({
+        connection2.execute({
           sqlText: sql,
           complete: (err, _stmt, rows2) => {
             if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
@@ -105,7 +251,7 @@ function createSnowflakeClient(entry, connectionId) {
           }
         });
       });
-      connection.destroy((err) => {
+      connection2.destroy((err) => {
         if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
       });
       return { rows };
@@ -311,6 +457,9 @@ function createConnectorRegistry() {
       return { client: createSnowflakeClient(entry, connectionId), connectorSlug };
     }
     if (connectorSlug === "bigquery") {
+      if (entry.connector.authType === "oauth") {
+        return { client: createBigQueryOAuthClient(entry, connectionId), connectorSlug };
+      }
       return { client: createBigQueryClient(entry, connectionId), connectorSlug };
     }
     if (connectorSlug === "athena") {
@@ -380,6 +529,68 @@ function createConnectorRegistry() {
 // src/connector-client/index.ts
 var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
+// src/types/data-source.ts
+import { z } from "zod";
+var parameterMetaSchema = z.object({
+  name: z.string(),
+  type: z.enum(["string", "number", "boolean"]),
+  description: z.string(),
+  required: z.boolean().optional(),
+  default: z.union([z.string(), z.number(), z.boolean()]).optional()
+});
+var dataSourceCacheConfigSchema = z.object({
+  ttl: z.number(),
+  staleWhileRevalidate: z.boolean().optional()
+});
+var dataSourceSchemaObjectSchema = z.lazy(
+  () => z.object({
+    type: z.enum(["string", "number", "integer", "boolean", "object", "array", "null"]).optional(),
+    format: z.string().optional(),
+    description: z.string().optional(),
+    nullable: z.boolean().optional(),
+    enum: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional(),
+    items: dataSourceSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), dataSourceSchemaObjectSchema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional()
+  })
+);
+var dataSourceMediaTypeSchema = z.object({
+  schema: dataSourceSchemaObjectSchema.optional(),
+  example: z.unknown().optional()
+});
+var dataSourceResponseSchema = z.object({
+  description: z.string().optional(),
+  defaultContentType: z.string().optional(),
+  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+});
+var jsonBaseFields = {
+  description: z.string(),
+  parameters: z.array(parameterMetaSchema).optional(),
+  response: dataSourceResponseSchema.optional(),
+  cache: dataSourceCacheConfigSchema.optional()
+};
+var jsonSqlDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("sql").optional(),
+  query: z.string(),
+  connectionId: z.string()
+});
+var jsonTypeScriptDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("typescript"),
+  handlerPath: z.string()
+});
+var anyJsonDataSourceSchema = z.union([
+  jsonTypeScriptDataSourceSchema,
+  jsonSqlDataSourceSchema
+]);
+
 // src/registry.ts
 var viteServer = null;
 function setViteServer(server) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.1-build-10",
+  "version": "0.0.1-build-12",
   "type": "module",
   "exports": {
     ".": {
@@ -47,7 +47,8 @@
     "hono": "^4.11.9",
     "mysql2": "^3.11.0",
     "pg": "^8.18.0",
-    "snowflake-sdk": "^1.15.0"
+    "snowflake-sdk": "^1.15.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@clack/prompts": "^0.9.1",