@bubblelab/bubble-core 0.1.250 → 0.1.251

package/dist/bubbles/service-bubble/snowflake/index.d.ts

@@ -0,0 +1,4 @@
+export { SnowflakeBubble } from './snowflake.js';
+export { SnowflakeParamsSchema, SnowflakeResultSchema, SnowflakeColumnSchema, type SnowflakeParams, type SnowflakeResult, type SnowflakeParamsInput, } from './snowflake.schema.js';
+export { parseSnowflakeCredential, generateSnowflakeJWT, getSnowflakeBaseUrl, type SnowflakeCredentials, } from './snowflake.utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/bubbles/service-bubble/snowflake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/snowflake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/bubbles/service-bubble/snowflake/index.js

@@ -0,0 +1,4 @@
+export { SnowflakeBubble } from './snowflake.js';
+export { SnowflakeParamsSchema, SnowflakeResultSchema, SnowflakeColumnSchema, } from './snowflake.schema.js';
+export { parseSnowflakeCredential, generateSnowflakeJWT, getSnowflakeBaseUrl, } from './snowflake.utils.js';
+//# sourceMappingURL=index.js.map

package/dist/bubbles/service-bubble/snowflake/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/snowflake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,GAItB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,mBAAmB,GAEpB,MAAM,sBAAsB,CAAC"}

package/dist/bubbles/service-bubble/snowflake/snowflake.d.ts

@@ -0,0 +1,354 @@
+import { ServiceBubble } from '../../../types/service-bubble-class.js';
+import type { BubbleContext } from '../../../types/bubble.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { type SnowflakeParamsInput, type SnowflakeResult } from './snowflake.schema.js';
+/**
+ * Snowflake Service Bubble
+ *
+ * Snowflake data warehouse integration using the SQL REST API with key-pair authentication.
+ *
+ * Features:
+ * - Execute arbitrary SQL statements
+ * - List databases, schemas, and tables
+ * - Describe table column definitions
+ * - Key-pair (RSA) JWT authentication — no token expiry
+ *
+ * Credential fields (multi-field):
+ * - account (required): Account identifier (ORGNAME-ACCOUNTNAME from URL)
+ * - username (required): Snowflake login username
+ * - privateKey (required): RSA private key in PEM format
+ * - privateKeyPassword (optional): Passphrase if key is encrypted
+ * - warehouse (optional): Default warehouse
+ * - database (optional): Default database
+ * - schema (optional): Default schema
+ * - role (optional): Default role
+ */
+export declare class SnowflakeBubble<T extends SnowflakeParamsInput = SnowflakeParamsInput> extends ServiceBubble<T, Extract<SnowflakeResult, {
+    operation: T['operation'];
+}>> {
+    static readonly type: "service";
+    static readonly service = "snowflake";
+    static readonly authType: "apikey";
+    static readonly bubbleName = "snowflake";
+    static readonly schema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"execute_sql">;
+        statement: import("zod").ZodString;
+        database: import("zod").ZodOptional<import("zod").ZodString>;
+        schema: import("zod").ZodOptional<import("zod").ZodString>;
+        warehouse: import("zod").ZodOptional<import("zod").ZodString>;
+        role: import("zod").ZodOptional<import("zod").ZodString>;
+        timeout: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        timeout: number;
+        operation: "execute_sql";
+        statement: string;
+        schema?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        role?: string | undefined;
+        database?: string | undefined;
+        warehouse?: string | undefined;
+    }, {
+        operation: "execute_sql";
+        statement: string;
+        schema?: string | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        timeout?: number | undefined;
+        role?: string | undefined;
+        database?: string | undefined;
+        warehouse?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_databases">;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "list_databases";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "list_databases";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_schemas">;
+        database: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "list_schemas";
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "list_schemas";
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_tables">;
+        database: import("zod").ZodString;
+        schema: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        schema: string;
+        operation: "list_tables";
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        schema: string;
+        operation: "list_tables";
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"describe_table">;
+        database: import("zod").ZodString;
+        schema: import("zod").ZodString;
+        table: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        schema: string;
+        operation: "describe_table";
+        table: string;
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        schema: string;
+        operation: "describe_table";
+        table: string;
+        database: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>]>;
+    static readonly resultSchema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"execute_sql">;
+        success: import("zod").ZodBoolean;
+        columns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            nullable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: string;
+            name: string;
+            nullable?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            nullable?: boolean | undefined;
+        }>, "many">>;
+        rows: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>, "many">, "many">>;
+        num_rows: import("zod").ZodOptional<import("zod").ZodNumber>;
+        statement_handle: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "execute_sql";
+        rows?: (string | null)[][] | undefined;
+        columns?: {
+            type: string;
+            name: string;
+            nullable?: boolean | undefined;
+        }[] | undefined;
+        num_rows?: number | undefined;
+        statement_handle?: string | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "execute_sql";
+        rows?: (string | null)[][] | undefined;
+        columns?: {
+            type: string;
+            name: string;
+            nullable?: boolean | undefined;
+        }[] | undefined;
+        num_rows?: number | undefined;
+        statement_handle?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_databases">;
+        success: import("zod").ZodBoolean;
+        databases: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            owner: import("zod").ZodOptional<import("zod").ZodString>;
+            created_on: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+        }, {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+        }>, "many">>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "list_databases";
+        databases?: {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+        }[] | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "list_databases";
+        databases?: {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_schemas">;
+        success: import("zod").ZodBoolean;
+        schemas: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            database_name: import("zod").ZodOptional<import("zod").ZodString>;
+            owner: import("zod").ZodOptional<import("zod").ZodString>;
+            created_on: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+        }, {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+        }>, "many">>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "list_schemas";
+        schemas?: {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+        }[] | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "list_schemas";
+        schemas?: {
+            name: string;
+            owner?: string | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list_tables">;
+        success: import("zod").ZodBoolean;
+        tables: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            database_name: import("zod").ZodOptional<import("zod").ZodString>;
+            schema_name: import("zod").ZodOptional<import("zod").ZodString>;
+            kind: import("zod").ZodOptional<import("zod").ZodString>;
+            rows: import("zod").ZodOptional<import("zod").ZodNumber>;
+            created_on: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            rows?: number | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+            schema_name?: string | undefined;
+            kind?: string | undefined;
+        }, {
+            name: string;
+            rows?: number | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+            schema_name?: string | undefined;
+            kind?: string | undefined;
+        }>, "many">>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "list_tables";
+        tables?: {
+            name: string;
+            rows?: number | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+            schema_name?: string | undefined;
+            kind?: string | undefined;
+        }[] | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "list_tables";
+        tables?: {
+            name: string;
+            rows?: number | undefined;
+            created_on?: string | undefined;
+            database_name?: string | undefined;
+            schema_name?: string | undefined;
+            kind?: string | undefined;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"describe_table">;
+        success: import("zod").ZodBoolean;
+        columns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            nullable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            primary_key: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            comment: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: string;
+            name: string;
+            default?: string | null | undefined;
+            nullable?: boolean | undefined;
+            comment?: string | null | undefined;
+            primary_key?: boolean | undefined;
+        }, {
+            type: string;
+            name: string;
+            default?: string | null | undefined;
+            nullable?: boolean | undefined;
+            comment?: string | null | undefined;
+            primary_key?: boolean | undefined;
+        }>, "many">>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "describe_table";
+        columns?: {
+            type: string;
+            name: string;
+            default?: string | null | undefined;
+            nullable?: boolean | undefined;
+            comment?: string | null | undefined;
+            primary_key?: boolean | undefined;
+        }[] | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "describe_table";
+        columns?: {
+            type: string;
+            name: string;
+            default?: string | null | undefined;
+            nullable?: boolean | undefined;
+            comment?: string | null | undefined;
+            primary_key?: boolean | undefined;
+        }[] | undefined;
+    }>]>;
+    static readonly shortDescription = "Snowflake data warehouse integration for SQL queries and metadata";
+    static readonly longDescription = "\n    Snowflake data warehouse integration using the SQL REST API with key-pair authentication.\n\n    Features:\n    - Execute arbitrary SQL statements against Snowflake\n    - List databases, schemas, and tables\n    - Describe table column definitions\n    - Key-pair (RSA) JWT authentication \u2014 no token expiry, no refresh needed\n\n    Use cases:\n    - Run SQL queries to fetch data from Snowflake warehouses\n    - Explore database metadata (databases, schemas, tables, columns)\n    - Automate data pipeline operations\n    - Build reports from Snowflake data\n  ";
+    static readonly alias = "snowflake";
+    constructor(params?: T, context?: BubbleContext, instanceId?: string);
+    testCredential(): Promise<boolean>;
+    protected chooseCredential(): string | undefined;
+    /**
+     * Execute a SQL statement via the Snowflake SQL API.
+     */
+    private executeStatement;
+    protected performAction(context?: BubbleContext): Promise<Extract<SnowflakeResult, {
+        operation: T['operation'];
+    }>>;
+    private executeSql;
+    private listDatabases;
+    private listSchemas;
+    private listTables;
+    private describeTable;
+}
+//# sourceMappingURL=snowflake.d.ts.map

package/dist/bubbles/service-bubble/snowflake/snowflake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snowflake.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/snowflake/snowflake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAS/B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe,CAC1B,CAAC,SAAS,oBAAoB,GAAG,oBAAoB,CACrD,SAAQ,aAAa,CACrB,CAAC,EACD,OAAO,CAAC,eAAe,EAAE;IAAE,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAA;CAAE,CAAC,CACxD;IACC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAU;IAC1C,MAAM,CAAC,QAAQ,CAAC,OAAO,eAAe;IACtC,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAG,QAAQ,CAAU;IAC7C,MAAM,CAAC,QAAQ,CAAC,UAAU,eAAe;IACzC,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAyB;IAC/C,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAyB;IACrD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,uEACsC;IACtE,MAAM,CAAC,QAAQ,CAAC,eAAe,qkBAc7B;IACF,MAAM,CAAC,QAAQ,CAAC,KAAK,eAAe;gBAGlC,MAAM,GAAE,CAEF,EACN,OAAO,CAAC,EAAE,aAAa,EACvB,UAAU,CAAC,EAAE,MAAM;IAKR,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAoC/C,SAAS,CAAC,gBAAgB,IAAI,MAAM,GAAG,SAAS;IAYhD;;OAEG;YACW,gBAAgB;cAkFd,aAAa,CAC3B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE;QAAE,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAA;KAAE,CAAC,CAAC;YAiErD,UAAU;YA2BV,aAAa;YAoBb,WAAW;YAyBX,UAAU;YA8BV,aAAa;CA8B5B"}

package/dist/bubbles/service-bubble/snowflake/snowflake.js

@@ -0,0 +1,285 @@
+import { ServiceBubble } from '../../../types/service-bubble-class.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { SnowflakeParamsSchema, SnowflakeResultSchema, } from './snowflake.schema.js';
+import { parseSnowflakeCredential, generateSnowflakeJWT, getSnowflakeBaseUrl, getCellByName, } from './snowflake.utils.js';
+/**
+ * Snowflake Service Bubble
+ *
+ * Snowflake data warehouse integration using the SQL REST API with key-pair authentication.
+ *
+ * Features:
+ * - Execute arbitrary SQL statements
+ * - List databases, schemas, and tables
+ * - Describe table column definitions
+ * - Key-pair (RSA) JWT authentication — no token expiry
+ *
+ * Credential fields (multi-field):
+ * - account (required): Account identifier (ORGNAME-ACCOUNTNAME from URL)
+ * - username (required): Snowflake login username
+ * - privateKey (required): RSA private key in PEM format
+ * - privateKeyPassword (optional): Passphrase if key is encrypted
+ * - warehouse (optional): Default warehouse
+ * - database (optional): Default database
+ * - schema (optional): Default schema
+ * - role (optional): Default role
+ */
+export class SnowflakeBubble extends ServiceBubble {
+    static type = 'service';
+    static service = 'snowflake';
+    static authType = 'apikey';
+    static bubbleName = 'snowflake';
+    static schema = SnowflakeParamsSchema;
+    static resultSchema = SnowflakeResultSchema;
+    static shortDescription = 'Snowflake data warehouse integration for SQL queries and metadata';
+    static longDescription = `
+    Snowflake data warehouse integration using the SQL REST API with key-pair authentication.
+
+    Features:
+    - Execute arbitrary SQL statements against Snowflake
+    - List databases, schemas, and tables
+    - Describe table column definitions
+    - Key-pair (RSA) JWT authentication — no token expiry, no refresh needed
+
+    Use cases:
+    - Run SQL queries to fetch data from Snowflake warehouses
+    - Explore database metadata (databases, schemas, tables, columns)
+    - Automate data pipeline operations
+    - Build reports from Snowflake data
+  `;
+    static alias = 'snowflake';
+    constructor(params = {
+        operation: 'list_databases',
+    }, context, instanceId) {
+        super(params, context, instanceId);
+    }
+    async testCredential() {
+        const credential = this.chooseCredential();
+        if (!credential) {
+            throw new Error('Snowflake credentials are required');
+        }
+        const creds = parseSnowflakeCredential(credential);
+        const jwt = generateSnowflakeJWT(creds);
+        const baseUrl = getSnowflakeBaseUrl(creds.account);
+        // Test by running SELECT CURRENT_USER()
+        const response = await fetch(`${baseUrl}/api/v2/statements`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${jwt}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'X-Snowflake-Authorization-Token-Type': 'KEYPAIR_JWT',
+            },
+            body: JSON.stringify({
+                statement: 'SELECT CURRENT_USER()',
+                timeout: 30,
+                ...(creds.warehouse && { warehouse: creds.warehouse }),
+                ...(creds.role && { role: creds.role }),
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Snowflake credential validation failed (${response.status}): ${text}`);
+        }
+        return true;
+    }
+    chooseCredential() {
+        const { credentials } = this.params;
+        if (!credentials || typeof credentials !== 'object') {
+            return undefined;
+        }
+        return credentials[CredentialType.SNOWFLAKE_CRED];
+    }
+    /**
+     * Execute a SQL statement via the Snowflake SQL API.
+     */
+    async executeStatement(creds, statement, options) {
+        const jwt = generateSnowflakeJWT(creds);
+        const baseUrl = getSnowflakeBaseUrl(creds.account);
+        const body = {
+            statement,
+            timeout: options?.timeout ?? 60,
+        };
+        // Apply context: explicit params > credential defaults
+        const database = options?.database ?? creds.database;
+        const schema = options?.schema ?? creds.schema;
+        const warehouse = options?.warehouse ?? creds.warehouse;
+        const role = options?.role ?? creds.role;
+        if (database)
+            body.database = database;
+        if (schema)
+            body.schema = schema;
+        if (warehouse)
+            body.warehouse = warehouse;
+        if (role)
+            body.role = role;
+        const response = await fetch(`${baseUrl}/api/v2/statements`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${jwt}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'X-Snowflake-Authorization-Token-Type': 'KEYPAIR_JWT',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage;
+            try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage =
+                    errorJson.message || errorJson.error || `HTTP ${response.status}`;
+            }
+            catch {
+                errorMessage = errorText || `HTTP ${response.status}`;
+            }
+            throw new Error(`Snowflake API error (${response.status}): ${errorMessage}`);
+        }
+        const result = await response.json();
+        // Handle async execution (202 status)
+        if (response.status === 202) {
+            throw new Error('Query is still executing asynchronously. Increase the timeout or use a simpler query.');
+        }
+        return {
+            resultSetMetaData: result.resultSetMetaData || {
+                numRows: 0,
+                rowType: [],
+            },
+            data: result.data || [],
+            statementHandle: result.statementHandle || '',
+        };
+    }
+    async performAction(context) {
+        void context;
+        const { operation } = this.params;
+        try {
+            const credential = this.chooseCredential();
+            if (!credential) {
+                throw new Error('Snowflake credentials are required');
+            }
+            const creds = parseSnowflakeCredential(credential);
+            const result = await (async () => {
+                const parsedParams = this.params;
+                switch (operation) {
+                    case 'execute_sql':
+                        return await this.executeSql(creds, parsedParams);
+                    case 'list_databases':
+                        return await this.listDatabases(creds);
+                    case 'list_schemas':
+                        return await this.listSchemas(creds, parsedParams);
+                    case 'list_tables':
+                        return await this.listTables(creds, parsedParams);
+                    case 'describe_table':
+                        return await this.describeTable(creds, parsedParams);
+                    default:
+                        throw new Error(`Unsupported operation: ${operation}`);
+                }
+            })();
+            return result;
+        }
+        catch (error) {
+            return {
+                operation,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    async executeSql(creds, params) {
+        const result = await this.executeStatement(creds, params.statement, {
+            database: params.database,
+            schema: params.schema,
+            warehouse: params.warehouse,
+            role: params.role,
+            timeout: params.timeout,
+        });
+        return {
+            operation: 'execute_sql',
+            success: true,
+            columns: result.resultSetMetaData.rowType.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: col.nullable,
+            })),
+            rows: result.data,
+            num_rows: result.resultSetMetaData.numRows,
+            statement_handle: result.statementHandle,
+            error: '',
+        };
+    }
+    async listDatabases(creds) {
+        const result = await this.executeStatement(creds, 'SHOW DATABASES');
+        const rowType = result.resultSetMetaData.rowType;
+        const databases = result.data.map((row) => ({
+            name: getCellByName(row, rowType, 'name') ?? '',
+            owner: getCellByName(row, rowType, 'owner'),
+            created_on: getCellByName(row, rowType, 'created_on'),
+        }));
+        return {
+            operation: 'list_databases',
+            success: true,
+            databases,
+            error: '',
+        };
+    }
+    async listSchemas(creds, params) {
+        const result = await this.executeStatement(creds, `SHOW SCHEMAS IN DATABASE "${params.database}"`);
+        const rowType = result.resultSetMetaData.rowType;
+        const schemas = result.data.map((row) => ({
+            name: getCellByName(row, rowType, 'name') ?? '',
+            database_name: getCellByName(row, rowType, 'database_name'),
+            owner: getCellByName(row, rowType, 'owner'),
+            created_on: getCellByName(row, rowType, 'created_on'),
+        }));
+        return {
+            operation: 'list_schemas',
+            success: true,
+            schemas,
+            error: '',
+        };
+    }
+    async listTables(creds, params) {
+        const result = await this.executeStatement(creds, `SHOW TABLES IN SCHEMA "${params.database}"."${params.schema}"`);
+        const rowType = result.resultSetMetaData.rowType;
+        const tables = result.data.map((row) => {
+            const rowsStr = getCellByName(row, rowType, 'rows');
+            return {
+                name: getCellByName(row, rowType, 'name') ?? '',
+                database_name: getCellByName(row, rowType, 'database_name'),
+                schema_name: getCellByName(row, rowType, 'schema_name'),
+                kind: getCellByName(row, rowType, 'kind'),
+                rows: rowsStr ? parseInt(rowsStr, 10) : undefined,
+                created_on: getCellByName(row, rowType, 'created_on'),
+            };
+        });
+        return {
+            operation: 'list_tables',
+            success: true,
+            tables,
+            error: '',
+        };
+    }
+    async describeTable(creds, params) {
+        const result = await this.executeStatement(creds, `DESCRIBE TABLE "${params.database}"."${params.schema}"."${params.table}"`);
+        const rowType = result.resultSetMetaData.rowType;
+        const columns = result.data.map((row) => {
+            const nullableStr = getCellByName(row, rowType, 'null?');
+            const pkStr = getCellByName(row, rowType, 'primary key');
+            return {
+                name: getCellByName(row, rowType, 'name') ?? '',
+                type: getCellByName(row, rowType, 'type') ?? '',
+                nullable: nullableStr ? nullableStr.toUpperCase() === 'Y' : undefined,
+                default: getCellByName(row, rowType, 'default') ?? null,
+                primary_key: pkStr ? pkStr.toUpperCase() === 'Y' : undefined,
+                comment: getCellByName(row, rowType, 'comment') ?? null,
+            };
+        });
+        return {
+            operation: 'describe_table',
+            success: true,
+            columns,
+            error: '',
+        };
+    }
+}
+//# sourceMappingURL=snowflake.js.map