veryfront 0.0.49 → 0.0.51

package/dist/integrations/snowflake/files/ai/tools/describe-table.ts

@@ -0,0 +1,57 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { describeTable, getTableRowCount } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "describe-table",
+  description:
+    "Get detailed schema information about a specific table in Snowflake. Returns column names, data types, constraints, and table statistics.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database containing the table",
+    ),
+    schema: z.string().default("PUBLIC").describe(
+      "The name of the schema containing the table. Defaults to PUBLIC.",
+    ),
+    table: z.string().describe(
+      "The name of the table to describe",
+    ),
+    includeRowCount: z.boolean().default(false).describe(
+      "Include the current row count for the table (may be slow for large tables)",
+    ),
+  }),
+  async execute({ database, schema, table, includeRowCount }) {
+    const description = await describeTable(database, schema, table);
+
+    let rowCount: number | null = null;
+    if (includeRowCount) {
+      try {
+        rowCount = await getTableRowCount(database, schema, table);
+      } catch (_error) {
+        // Silently fail if row count cannot be retrieved
+        rowCount = null;
+      }
+    }
+
+    return {
+      database,
+      schema,
+      table,
+      rowCount,
+      primaryKeys: description.primaryKeys,
+      columnCount: description.columns.length,
+      columns: description.columns.map((col) => ({
+        name: col.name,
+        type: col.type,
+        kind: col.kind,
+        nullable: col.null === "Y",
+        default: col.default || null,
+        primaryKey: col.primary_key === "Y",
+        uniqueKey: col.unique_key === "Y",
+        check: col.check || null,
+        expression: col.expression || null,
+        comment: col.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-databases.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listDatabases } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-databases",
+  description:
+    "List all databases in your Snowflake account. Returns database names, creation dates, owners, and comments.",
+  inputSchema: z.object({
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, owner, and comments",
+    ),
+  }),
+  async execute({ includeDetails }) {
+    const databases = await listDatabases();
+
+    if (!includeDetails) {
+      return {
+        count: databases.length,
+        databases: databases.map((db) => db.name),
+      };
+    }
+
+    return {
+      count: databases.length,
+      databases: databases.map((db) => ({
+        name: db.name,
+        createdOn: db.created_on,
+        owner: db.owner,
+        comment: db.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-schemas.ts

@@ -0,0 +1,40 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listSchemas } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-schemas",
+  description:
+    "List all schemas in a Snowflake database. Returns schema names, database names, creation dates, and owners.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database to list schemas from",
+    ),
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, owner, and comments",
+    ),
+  }),
+  async execute({ database, includeDetails }) {
+    const schemas = await listSchemas(database);
+
+    if (!includeDetails) {
+      return {
+        database,
+        count: schemas.length,
+        schemas: schemas.map((s) => s.name),
+      };
+    }
+
+    return {
+      database,
+      count: schemas.length,
+      schemas: schemas.map((s) => ({
+        name: s.name,
+        databaseName: s.database_name,
+        createdOn: s.created_on,
+        owner: s.owner,
+        comment: s.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-tables.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listTables } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-tables",
+  description:
+    "List all tables in a Snowflake database schema. Returns table names, types, creation dates, row counts, and sizes.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database containing the schema",
+    ),
+    schema: z.string().default("PUBLIC").describe(
+      "The name of the schema to list tables from. Defaults to PUBLIC.",
+    ),
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, row count, size, and owner",
+    ),
+  }),
+  async execute({ database, schema, includeDetails }) {
+    const tables = await listTables(database, schema);
+
+    if (!includeDetails) {
+      return {
+        database,
+        schema,
+        count: tables.length,
+        tables: tables.map((t) => t.name),
+      };
+    }
+
+    return {
+      database,
+      schema,
+      count: tables.length,
+      tables: tables.map((t) => ({
+        name: t.name,
+        databaseName: t.database_name,
+        schemaName: t.schema_name,
+        kind: t.kind,
+        createdOn: t.created_on,
+        rowCount: t.row_count || null,
+        bytes: t.bytes || null,
+        owner: t.owner,
+        comment: t.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/run-query.ts

@@ -0,0 +1,119 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getQueryStatus, runQuery } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "run-query",
+  description:
+    "Execute a SQL query against your Snowflake data warehouse. Supports SELECT, INSERT, UPDATE, DELETE, and other SQL operations.",
+  inputSchema: z.object({
+    sql: z.string().describe(
+      "The SQL query to execute. Can be SELECT, INSERT, UPDATE, DELETE, or DDL statements.",
+    ),
+    database: z.string().optional().describe(
+      "The database to use for this query. If not specified, uses the default database.",
+    ),
+    schema: z.string().optional().describe(
+      "The schema to use for this query. If not specified, uses the default schema.",
+    ),
+    timeout: z.number().min(1).max(300).default(60).describe(
+      "Query timeout in seconds (1-300). Default is 60 seconds.",
+    ),
+    async: z.boolean().default(false).describe(
+      "Execute query asynchronously. If true, returns immediately with a statement handle to check status later.",
+    ),
+  }),
+  async execute({ sql, database, schema, timeout, async: asyncExec }) {
+    const result = await runQuery(sql, database, schema, {
+      timeout,
+      async: asyncExec,
+    });
+
+    // Handle async execution
+    if (asyncExec && result.statementHandle) {
+      return {
+        status: "submitted",
+        statementHandle: result.statementHandle,
+        message:
+          "Query submitted for async execution. Use the statement handle to check status.",
+      };
+    }
+
+    // Handle synchronous result
+    return {
+      status: "completed",
+      sql,
+      database: database || "default",
+      schema: schema || "PUBLIC",
+      columns: result.columns,
+      rowCount: result.rowCount,
+      rows: result.rows,
+      statementHandle: result.statementHandle,
+    };
+  },
+});
+
+/**
+ * Additional tool for checking query status (for async queries)
+ */
+export const checkQueryStatus = tool({
+  id: "check-query-status",
+  description:
+    "Check the status and retrieve results of an asynchronously executed query.",
+  inputSchema: z.object({
+    statementHandle: z.string().describe(
+      "The statement handle returned from an async query execution.",
+    ),
+  }),
+  async execute({ statementHandle }) {
+    const status = await getQueryStatus(statementHandle);
+
+    // Check if query is complete
+    if (status.code === "090001") {
+      // Query is still running
+      return {
+        status: "running",
+        message: status.message,
+        statementHandle,
+      };
+    }
+
+    if (status.code === "000000" || !status.code) {
+      // Query completed successfully
+      const columns = status.resultSetMetaData?.rowType.map((col) => ({
+        name: col.name,
+        type: col.type,
+        nullable: col.nullable,
+      })) || [];
+
+      const rows: Record<string, unknown>[] = [];
+      if (status.data && status.resultSetMetaData) {
+        const columnNames = status.resultSetMetaData.rowType.map((col) => col.name);
+        for (const row of status.data) {
+          const obj: Record<string, unknown> = {};
+          columnNames.forEach((name, index) => {
+            obj[name] = row[index];
+          });
+          rows.push(obj);
+        }
+      }
+
+      return {
+        status: "completed",
+        columns,
+        rowCount: status.resultSetMetaData?.numRows || 0,
+        rows,
+        stats: status.stats,
+        statementHandle,
+      };
+    }
+
+    // Query failed
+    return {
+      status: "failed",
+      code: status.code,
+      message: status.message,
+      statementHandle,
+    };
+  },
+});

package/dist/integrations/snowflake/files/lib/snowflake-client.ts

@@ -0,0 +1,389 @@
+import {
+  getSnowflakeAccount,
+  getSnowflakeDatabase,
+  getSnowflakePassword,
+  getSnowflakeSchema,
+  getSnowflakeUsername,
+  getSnowflakeWarehouse,
+} from "./token-store.ts";
+
+/**
+ * Snowflake SQL REST API Response Types
+ * Based on: https://docs.snowflake.com/en/developer-guide/sql-api/reference
+ */
+
+interface SnowflakeStatementResponse {
+  statementHandle: string;
+  statementStatusUrl: string;
+  message?: string;
+  code?: string;
+}
+
+interface SnowflakeQueryResult {
+  resultSetMetaData: {
+    rowType: Array<{
+      name: string;
+      type: string;
+      nullable: boolean;
+      scale?: number;
+      precision?: number;
+      length?: number;
+    }>;
+    numRows: number;
+    format?: string;
+    partitionInfo?: Array<{
+      rowCount: number;
+      uncompressedSize: number;
+    }>;
+  };
+  data: unknown[][];
+  code?: string;
+  message?: string;
+  statementHandle?: string;
+  statementStatusUrl?: string;
+}
+
+interface SnowflakeQueryStatusResponse {
+  message: string;
+  code: string;
+  statementHandle: string;
+  statementStatusUrl: string;
+  sqlText?: string;
+  resultSetMetaData?: SnowflakeQueryResult["resultSetMetaData"];
+  data?: unknown[][];
+  stats?: {
+    numRowsInserted?: number;
+    numRowsUpdated?: number;
+    numRowsDeleted?: number;
+    numDuplicateRowsUpdated?: number;
+  };
+}
+
+interface DatabaseInfo {
+  name: string;
+  created_on: string;
+  owner: string;
+  comment?: string;
+}
+
+interface SchemaInfo {
+  name: string;
+  database_name: string;
+  created_on: string;
+  owner: string;
+  comment?: string;
+}
+
+interface TableInfo {
+  name: string;
+  database_name: string;
+  schema_name: string;
+  kind: string;
+  created_on: string;
+  row_count?: number;
+  bytes?: number;
+  owner: string;
+  comment?: string;
+}
+
+interface ColumnInfo {
+  name: string;
+  type: string;
+  kind: string;
+  null?: string;
+  default?: string;
+  primary_key?: string;
+  unique_key?: string;
+  check?: string;
+  expression?: string;
+  comment?: string;
+}
+
+interface SnowflakeError extends Error {
+  code?: string;
+  sqlState?: string;
+}
+
+/**
+ * Execute a Snowflake SQL API request
+ */
+async function snowflakeFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const account = getSnowflakeAccount();
+  const username = getSnowflakeUsername();
+  const password = getSnowflakePassword();
+
+  // Construct the base URL for Snowflake SQL REST API
+  const baseUrl = `https://${account}.snowflakecomputing.com/api/v2`;
+
+  // Create basic auth header
+  const authHeader = `Basic ${btoa(`${username}:${password}`)}`;
+
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": authHeader,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "X-Snowflake-Authorization-Token-Type": "KEYPAIR_JWT",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({})) as SnowflakeError;
+    const errorMessage = errorData.message ||
+      `Snowflake API error: ${response.status} ${response.statusText}`;
+    const err: SnowflakeError = new Error(errorMessage);
+    err.code = errorData.code;
+    err.sqlState = errorData.sqlState;
+    throw err;
+  }
+
+  return await response.json();
+}
+
+/**
+ * Submit a SQL statement for execution
+ */
+async function submitStatement(
+  sqlText: string,
+  database?: string,
+  schema?: string,
+  timeout?: number,
+  async_exec = false,
+): Promise<SnowflakeStatementResponse | SnowflakeQueryResult> {
+  const warehouse = getSnowflakeWarehouse();
+  const defaultDatabase = database || getSnowflakeDatabase();
+  const defaultSchema = schema || getSnowflakeSchema();
+
+  const requestBody = {
+    statement: sqlText,
+    warehouse,
+    database: defaultDatabase,
+    schema: defaultSchema,
+    timeout: timeout || 60,
+    resultSetMetaData: {
+      format: "json",
+    },
+    parameters: {},
+  };
+
+  // For async execution, use the /statements endpoint
+  // For sync execution, use /statements with async=false
+  const endpoint = async_exec
+    ? "/statements?async=true"
+    : "/statements";
+
+  return await snowflakeFetch<SnowflakeStatementResponse | SnowflakeQueryResult>(
+    endpoint,
+    {
+      method: "POST",
+      body: JSON.stringify(requestBody),
+    },
+  );
+}
+
+/**
+ * Get the status and results of a statement
+ */
+export async function getQueryStatus(
+  statementHandle: string,
+): Promise<SnowflakeQueryStatusResponse> {
+  return await snowflakeFetch<SnowflakeQueryStatusResponse>(
+    `/statements/${statementHandle}`,
+  );
+}
+
+/**
+ * Cancel a running statement
+ */
+export async function cancelQuery(statementHandle: string): Promise<void> {
+  await snowflakeFetch(`/statements/${statementHandle}/cancel`, {
+    method: "POST",
+  });
+}
+
+/**
+ * Transform Snowflake result format to more usable JSON objects
+ */
+function transformResults(result: SnowflakeQueryResult): Record<string, unknown>[] {
+  if (!result.data || result.data.length === 0) {
+    return [];
+  }
+
+  const columns = result.resultSetMetaData.rowType.map((col) => col.name);
+
+  return result.data.map((row) => {
+    const obj: Record<string, unknown> = {};
+    columns.forEach((col, index) => {
+      obj[col] = row[index];
+    });
+    return obj;
+  });
+}
+
+/**
+ * Run a SQL query and return results
+ */
+export async function runQuery(
+  sql: string,
+  database?: string,
+  schema?: string,
+  options: {
+    timeout?: number;
+    async?: boolean;
+  } = {},
+): Promise<{
+  columns: Array<{ name: string; type: string; nullable: boolean }>;
+  rows: Record<string, unknown>[];
+  rowCount: number;
+  statementHandle?: string;
+}> {
+  const result = await submitStatement(
+    sql,
+    database,
+    schema,
+    options.timeout,
+    options.async,
+  );
+
+  // Handle async execution
+  if ("statementHandle" in result && !("data" in result)) {
+    return {
+      columns: [],
+      rows: [],
+      rowCount: 0,
+      statementHandle: result.statementHandle,
+    };
+  }
+
+  // Handle synchronous result
+  const queryResult = result as SnowflakeQueryResult;
+
+  const columns = queryResult.resultSetMetaData.rowType.map((col) => ({
+    name: col.name,
+    type: col.type,
+    nullable: col.nullable,
+  }));
+
+  const rows = transformResults(queryResult);
+
+  return {
+    columns,
+    rows,
+    rowCount: queryResult.resultSetMetaData.numRows,
+    statementHandle: queryResult.statementHandle,
+  };
+}
+
+/**
+ * List all databases in the account
+ */
+export async function listDatabases(): Promise<DatabaseInfo[]> {
+  const result = await runQuery("SHOW DATABASES");
+  return result.rows as DatabaseInfo[];
+}
+
+/**
+ * List all schemas in a database
+ */
+export async function listSchemas(database: string): Promise<SchemaInfo[]> {
+  const result = await runQuery(`SHOW SCHEMAS IN DATABASE ${database}`);
+  return result.rows as SchemaInfo[];
+}
+
+/**
+ * List all tables in a database schema
+ */
+export async function listTables(
+  database: string,
+  schema: string,
+): Promise<TableInfo[]> {
+  const result = await runQuery(
+    `SHOW TABLES IN ${database}.${schema}`,
+  );
+  return result.rows as TableInfo[];
+}
+
+/**
+ * Get detailed information about a table's columns
+ */
+export async function describeTable(
+  database: string,
+  schema: string,
+  table: string,
+): Promise<{
+  columns: ColumnInfo[];
+  primaryKeys: string[];
+}> {
+  const result = await runQuery(
+    `DESCRIBE TABLE ${database}.${schema}.${table}`,
+  );
+
+  const columns = result.rows as ColumnInfo[];
+  const primaryKeys = columns
+    .filter((col) => col.primary_key === "Y")
+    .map((col) => col.name);
+
+  return {
+    columns,
+    primaryKeys,
+  };
+}
+
+/**
+ * Get table row count
+ */
+export async function getTableRowCount(
+  database: string,
+  schema: string,
+  table: string,
+): Promise<number> {
+  const result = await runQuery(
+    `SELECT COUNT(*) as count FROM ${database}.${schema}.${table}`,
+  );
+
+  if (result.rows.length > 0 && "count" in result.rows[0]) {
+    return Number(result.rows[0].count);
+  }
+
+  return 0;
+}
+
+/**
+ * Get current Snowflake version and session info
+ */
+export async function getSessionInfo(): Promise<{
+  version: string;
+  warehouse: string;
+  database?: string;
+  schema?: string;
+  user: string;
+  role?: string;
+}> {
+  const result = await runQuery(`
+    SELECT
+      CURRENT_VERSION() as version,
+      CURRENT_WAREHOUSE() as warehouse,
+      CURRENT_DATABASE() as database,
+      CURRENT_SCHEMA() as schema,
+      CURRENT_USER() as user,
+      CURRENT_ROLE() as role
+  `);
+
+  if (result.rows.length === 0) {
+    throw new Error("Failed to get session info");
+  }
+
+  return result.rows[0] as {
+    version: string;
+    warehouse: string;
+    database?: string;
+    schema?: string;
+    user: string;
+    role?: string;
+  };
+}