@keystrokehq/snowflake 0.0.1

package/dist/catalog.mjs

@@ -0,0 +1,158 @@
+import { executeSql } from "./sql.mjs";
+import { i as quoteIdentifier, n as inClause, r as likeClause, t as buildFqn } from "./sql-safety-CywdR3EP.mjs";
+
+//#region src/catalog.ts
+function limitClause(limit) {
+	return limit && limit > 0 ? ` LIMIT ${Math.floor(limit)}` : "";
+}
+function toScope(options) {
+	if (options.inAccount) return " IN ACCOUNT";
+	if (options.inSchema) return inClause("SCHEMA", buildFqn(options.inSchema.database, options.inSchema.schema));
+	if (options.inDatabase) return inClause("DATABASE", quoteIdentifier(options.inDatabase));
+	return "";
+}
+async function runShow(client, sql, ctx) {
+	const result = await executeSql(client, {
+		statement: sql,
+		warehouse: ctx.warehouse,
+		role: ctx.role,
+		database: ctx.database,
+		schema: ctx.schema
+	});
+	return {
+		rows: result.rows,
+		columns: result.columns.map((c) => ({
+			name: c.name,
+			type: c.type
+		}))
+	};
+}
+async function showDatabases(client, options = {}) {
+	return runShow(client, `SHOW DATABASES${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showSchemas(client, options = {}) {
+	return runShow(client, `SHOW${options.history ? " HISTORY" : ""} SCHEMAS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showTables(client, options = {}) {
+	return runShow(client, `SHOW${options.terse ? " TERSE" : ""}${options.history ? " HISTORY" : ""} TABLES${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showViews(client, options = {}) {
+	return runShow(client, `SHOW${options.terse ? " TERSE" : ""} VIEWS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showMaterializedViews(client, options = {}) {
+	return runShow(client, `SHOW MATERIALIZED VIEWS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showColumns(client, options = {}) {
+	let scope = "";
+	if (options.inTable) scope = ` IN TABLE ${buildFqn(options.inTable.database, options.inTable.schema, options.inTable.table)}`;
+	else if (options.inView) scope = ` IN VIEW ${buildFqn(options.inView.database, options.inView.schema, options.inView.view)}`;
+	else if (options.inSchema) scope = ` IN SCHEMA ${buildFqn(options.inSchema.database, options.inSchema.schema)}`;
+	else if (options.inDatabase) scope = ` IN DATABASE ${quoteIdentifier(options.inDatabase)}`;
+	return runShow(client, `SHOW COLUMNS${scope}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showWarehouses(client, options = {}) {
+	return runShow(client, `SHOW WAREHOUSES${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showRoles(client, options = {}) {
+	return runShow(client, `SHOW ROLES${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showUsers(client, options = {}) {
+	return runShow(client, `SHOW USERS${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showStages(client, options = {}) {
+	return runShow(client, `SHOW STAGES${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showPipes(client, options = {}) {
+	return runShow(client, `SHOW PIPES${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showTasks(client, options = {}) {
+	return runShow(client, `SHOW${options.terse ? " TERSE" : ""} TASKS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showStreams(client, options = {}) {
+	return runShow(client, `SHOW STREAMS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showShares(client, options = {}) {
+	return runShow(client, `SHOW SHARES${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showFunctions(client, options = {}) {
+	return runShow(client, `SHOW FUNCTIONS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showProcedures(client, options = {}) {
+	return runShow(client, `SHOW PROCEDURES${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showFileFormats(client, options = {}) {
+	return runShow(client, `SHOW FILE FORMATS${toScope(options)}${likeClause(options.like)}${limitClause(options.limit)}`, options);
+}
+async function showGrants(client, options = {}) {
+	let tail = "";
+	if (options.on) {
+		const fqn = buildFqn(options.on.database, options.on.schema, options.on.name);
+		tail = ` ON ${options.on.objectType.toUpperCase()} ${fqn}`;
+	} else if (options.toRole) tail = ` TO ROLE ${quoteIdentifier(options.toRole)}`;
+	else if (options.toUser) tail = ` TO USER ${quoteIdentifier(options.toUser)}`;
+	else if (options.toShare) tail = ` TO SHARE ${quoteIdentifier(options.toShare)}`;
+	else if (options.ofRole) tail = ` OF ROLE ${quoteIdentifier(options.ofRole)}`;
+	else if (options.ofShare) tail = ` OF SHARE ${quoteIdentifier(options.ofShare)}`;
+	return runShow(client, `SHOW GRANTS${tail}${likeClause(options.like)}`, options);
+}
+async function describeTable(client, options) {
+	return runShow(client, `DESCRIBE TABLE ${buildFqn(options.database, options.schema, options.table)}${options.type ? ` TYPE = ${options.type}` : ""}`, options);
+}
+/**
+* Composio `SNOWFLAKE_BASIC_EXPLORE_COLUMNS` parity — pull a small distinct
+* sample from each requested column to help LLMs disambiguate column
+* semantics.
+*/
+async function exploreColumns(client, options) {
+	const fqn = buildFqn(options.database, options.schema, options.table);
+	const columns = options.columns && options.columns.length > 0 ? options.columns : (await describeTable(client, options)).rows.map((row) => row.name ?? row.NAME).filter((name) => Boolean(name));
+	const limit = options.limit ?? 100;
+	const samples = [];
+	for (const column of columns) {
+		const distinctValues = (await executeSql(client, {
+			statement: `SELECT DISTINCT ${quoteIdentifier(column)} AS v FROM ${fqn} LIMIT ${Math.max(1, Math.floor(limit))}`,
+			warehouse: options.warehouse,
+			role: options.role
+		})).rows.map((row) => row.V ?? row.v);
+		samples.push({
+			column,
+			distinctValues
+		});
+	}
+	return {
+		table: fqn,
+		samples
+	};
+}
+function applyNameFilter(rows, substring) {
+	if (!substring) return [...rows];
+	const needle = substring.toLowerCase();
+	return rows.filter((row) => {
+		const name = row.name ?? row.NAME;
+		return typeof name === "string" && name.toLowerCase().includes(needle);
+	});
+}
+async function findDatabases(client, options = {}) {
+	const result = await showDatabases(client, options);
+	return {
+		columns: result.columns,
+		rows: applyNameFilter(result.rows, options.nameContains)
+	};
+}
+async function findSchemas(client, options = {}) {
+	const result = await showSchemas(client, options);
+	return {
+		columns: result.columns,
+		rows: applyNameFilter(result.rows, options.nameContains)
+	};
+}
+async function findTables(client, options = {}) {
+	const result = await showTables(client, options);
+	return {
+		columns: result.columns,
+		rows: applyNameFilter(result.rows, options.nameContains)
+	};
+}
+
+//#endregion
+export { describeTable, exploreColumns, findDatabases, findSchemas, findTables, showColumns, showDatabases, showFileFormats, showFunctions, showGrants, showMaterializedViews, showPipes, showProcedures, showRoles, showSchemas, showShares, showStages, showStreams, showTables, showTasks, showUsers, showViews, showWarehouses };

package/dist/client.d.mts

@@ -0,0 +1,44 @@
+import { n as SnowflakeCredentials } from "./integration-CCWMSTlO.mjs";
+import { t as RetryPolicy } from "./retry-w7cTp1QL.mjs";
+
+//#region src/client.d.ts
+type SnowflakeAuthTokenType = 'KEYPAIR_JWT' | 'OAUTH' | 'PROGRAMMATIC_ACCESS_TOKEN' | 'BASIC';
+type SnowflakeHttpMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+type QueryPrimitive = string | number | boolean;
+type SnowflakeQueryValue = QueryPrimitive | readonly QueryPrimitive[] | null | undefined;
+interface SnowflakeQuery {
+  readonly [key: string]: SnowflakeQueryValue;
+}
+interface SnowflakeRequestInit {
+  readonly method?: SnowflakeHttpMethod;
+  readonly body?: unknown;
+  readonly query?: SnowflakeQuery;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly timeoutMs?: number;
+  readonly requestId?: string;
+  /** Raw body; when true the response object is returned verbatim. */
+  readonly raw?: boolean;
+  /** Disable retries for this call (statement cancel, etc.). */
+  readonly retry?: boolean | RetryPolicy;
+}
+interface SnowflakeClientOptions {
+  readonly fetchImpl?: typeof fetch;
+  readonly timeoutMs?: number;
+  readonly retry?: RetryPolicy;
+  readonly sleep?: (ms: number) => Promise<void>;
+  readonly now?: () => number;
+  readonly userAgent?: string;
+  readonly randomUUID?: () => string;
+}
+interface SnowflakeClient {
+  readonly host: string;
+  readonly account: string;
+  readonly credentials: SnowflakeCredentials;
+  request<T = unknown>(path: string, init?: SnowflakeRequestInit): Promise<T>;
+  requestRaw(path: string, init?: SnowflakeRequestInit): Promise<Response>;
+  buildUrl(path: string, query?: SnowflakeQuery): string;
+}
+declare function createSnowflakeClient(rawCredentials: SnowflakeCredentials | unknown, options?: SnowflakeClientOptions): SnowflakeClient;
+declare function resolveHost(credentials: SnowflakeCredentials): string;
+//#endregion
+export { SnowflakeAuthTokenType, SnowflakeClient, SnowflakeClientOptions, SnowflakeHttpMethod, SnowflakeQuery, SnowflakeQueryValue, SnowflakeRequestInit, createSnowflakeClient, resolveHost };

package/dist/client.mjs

@@ -0,0 +1,273 @@
+import { t as parseSnowflakeCredentials } from "./integration-Dptv8L0L.mjs";
+import { a as extractSnowflakeMessage, c as parseRetryAfterHeader, i as extractSnowflakeCode, n as SnowflakeSqlError, o as extractSnowflakeSqlState, r as classifySnowflakeHttpStatus, s as extractSnowflakeStatementHandle, t as SnowflakeApiError } from "./errors-DKnc9o_a.mjs";
+import { a as createSnowflakeJwt, i as shouldRetry, n as computeBackoffMs, r as defaultSleep, t as DEFAULT_RETRY_POLICY } from "./retry-0hMfb8cC.mjs";
+
+//#region src/client.ts
+/**
+* Core HTTP client for the Snowflake integration.
+*
+* Shape — kept intentionally generic so the same client backs every domain
+* module (SQL API v2, Snowpipe REST, org-admin REST). Higher-level helpers
+* (`sql.ts`, `pipes.ts`, ...) consume `SnowflakeClient.request` and layer
+* their own schemas on top.
+*
+* Responsibilities:
+*  - resolve credentials -> `Authorization` header + auth-token-type header
+*  - sign JWTs for `mode=keypair` and cache them until expiry
+*  - apply default retry policy with exponential backoff + `Retry-After`
+*  - classify non-2xx responses into structured errors (see `errors.ts`)
+*  - attach a deterministic `requestId` for idempotent statement submission
+*/
+const DEFAULT_TIMEOUT_MS = 3e4;
+const JWT_REFRESH_SKEW_SECONDS = 60;
+const USER_AGENT = "keystroke-integration-snowflake/0.0.0";
+function createSnowflakeClient(rawCredentials, options = {}) {
+	const credentials = isSnowflakeCredentials(rawCredentials) ? rawCredentials : parseSnowflakeCredentials(rawCredentials);
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const sleep = options.sleep ?? defaultSleep;
+	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const retryPolicy = options.retry ?? DEFAULT_RETRY_POLICY;
+	const now = options.now ?? (() => Date.now());
+	const userAgent = options.userAgent ?? USER_AGENT;
+	const randomUUID = options.randomUUID ?? (() => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : pseudoRandomUuid());
+	const host = resolveHost(credentials);
+	const account = credentials.SNOWFLAKE_ACCOUNT.trim();
+	let cachedJwt;
+	async function authorization() {
+		if (credentials.mode === "keypair") {
+			const nowMs = now();
+			if (!cachedJwt || cachedJwt.expiresAtMs - JWT_REFRESH_SKEW_SECONDS * 1e3 <= nowMs) {
+				if (!credentials.SNOWFLAKE_USER || !credentials.SNOWFLAKE_PRIVATE_KEY) throw new SnowflakeApiError({
+					kind: "auth",
+					status: 0,
+					message: "SNOWFLAKE_USER and SNOWFLAKE_PRIVATE_KEY are required for keypair mode"
+				});
+				const jwt = await createSnowflakeJwt({
+					account,
+					user: credentials.SNOWFLAKE_USER,
+					privateKeyPem: credentials.SNOWFLAKE_PRIVATE_KEY,
+					publicKeyFingerprint: credentials.SNOWFLAKE_PUBLIC_KEY_FP,
+					now: () => nowMs
+				});
+				cachedJwt = {
+					token: jwt.token,
+					expiresAtMs: jwt.expiresAt * 1e3
+				};
+			}
+			return {
+				header: `Bearer ${cachedJwt.token}`,
+				tokenType: "KEYPAIR_JWT"
+			};
+		}
+		if (credentials.mode === "oauth") {
+			if (!credentials.SNOWFLAKE_OAUTH_ACCESS_TOKEN) throw new SnowflakeApiError({
+				kind: "auth",
+				status: 0,
+				message: "SNOWFLAKE_OAUTH_ACCESS_TOKEN is required for oauth mode"
+			});
+			return {
+				header: `Bearer ${credentials.SNOWFLAKE_OAUTH_ACCESS_TOKEN}`,
+				tokenType: "OAUTH"
+			};
+		}
+		if (credentials.mode === "pat") {
+			if (!credentials.SNOWFLAKE_PAT) throw new SnowflakeApiError({
+				kind: "auth",
+				status: 0,
+				message: "SNOWFLAKE_PAT is required for pat mode"
+			});
+			return {
+				header: `Bearer ${credentials.SNOWFLAKE_PAT}`,
+				tokenType: "PROGRAMMATIC_ACCESS_TOKEN"
+			};
+		}
+		if (!credentials.SNOWFLAKE_USER || !credentials.SNOWFLAKE_PASSWORD) throw new SnowflakeApiError({
+			kind: "auth",
+			status: 0,
+			message: "SNOWFLAKE_USER and SNOWFLAKE_PASSWORD are required for basic mode"
+		});
+		return {
+			header: `Basic ${base64EncodeString(`${credentials.SNOWFLAKE_USER}:${credentials.SNOWFLAKE_PASSWORD}`)}`,
+			tokenType: "BASIC"
+		};
+	}
+	function buildUrl(path, query) {
+		return `${path.startsWith("http://") || path.startsWith("https://") ? path : `https://${host}${path.startsWith("/") ? path : `/${path}`}`}${toQueryString(query)}`;
+	}
+	async function requestRaw(path, init = {}) {
+		const method = init.method ?? "GET";
+		const policy = resolveRetryPolicy(init.retry, retryPolicy);
+		const attemptTimeoutMs = init.timeoutMs ?? timeoutMs;
+		const requestId = init.requestId ?? randomUUID();
+		const url = buildUrl(path, {
+			...init.query ?? {},
+			...method === "POST" && path.includes("/api/v2/statements") ? { requestId } : {}
+		});
+		let body;
+		const headers = {
+			Accept: "application/json",
+			"User-Agent": userAgent,
+			...init.headers
+		};
+		if (init.body !== void 0) {
+			headers["Content-Type"] = "application/json";
+			body = JSON.stringify(init.body);
+		}
+		let attempt = 0;
+		for (;;) {
+			const auth = await authorization();
+			headers.Authorization = auth.header;
+			headers["X-Snowflake-Authorization-Token-Type"] = auth.tokenType;
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), attemptTimeoutMs);
+			let response;
+			try {
+				response = await fetchImpl(url, {
+					method,
+					headers,
+					...body !== void 0 ? { body } : {},
+					signal: controller.signal
+				});
+			} catch (error) {
+				clearTimeout(timer);
+				const isAbort = error instanceof Error && (error.name === "AbortError" || /aborted|abort/iu.test(error.message));
+				const kind = isAbort ? "timeout" : "network";
+				if (policy && shouldRetry(kind, attempt, policy)) {
+					attempt += 1;
+					await sleep(computeBackoffMs({
+						attempt,
+						policy
+					}));
+					continue;
+				}
+				throw new SnowflakeApiError({
+					kind,
+					status: 0,
+					message: isAbort ? `Request to \`${path}\` timed out after ${attemptTimeoutMs}ms` : `Request to \`${path}\` failed: ${error?.message ?? String(error)}`,
+					requestId,
+					cause: error
+				});
+			}
+			clearTimeout(timer);
+			if (response.ok || response.status === 202) return response;
+			const parsed = await readResponseBody(response);
+			const retryAfterMs = parseRetryAfterHeader(response.headers.get("retry-after"));
+			const kind = classifySnowflakeHttpStatus(response.status);
+			if (policy && shouldRetry(kind, attempt, policy)) {
+				attempt += 1;
+				await sleep(computeBackoffMs({
+					attempt,
+					retryAfterMs,
+					policy
+				}));
+				continue;
+			}
+			throw toStructuredError({
+				response,
+				body: parsed,
+				requestId,
+				retryAfterMs
+			});
+		}
+	}
+	async function request(path, init = {}) {
+		const response = await requestRaw(path, init);
+		if (init.raw) return response;
+		if (response.status === 204) return void 0;
+		return await readResponseBody(response);
+	}
+	return {
+		host,
+		account,
+		credentials,
+		request,
+		requestRaw,
+		buildUrl
+	};
+}
+function resolveRetryPolicy(override, fallback) {
+	if (override === false) return void 0;
+	if (override === true || override === void 0) return fallback;
+	return override;
+}
+async function readResponseBody(response) {
+	if ((response.headers.get("content-type") ?? "").includes("application/json")) return response.json().catch(() => void 0);
+	return response.text().catch(() => void 0);
+}
+function toStructuredError(args) {
+	const { response, body, requestId, retryAfterMs } = args;
+	const kind = classifySnowflakeHttpStatus(response.status);
+	const message = extractSnowflakeMessage(body) ?? `Snowflake HTTP ${response.status} (${response.statusText})`;
+	const providerCode = extractSnowflakeCode(body);
+	const snowflakeRequestId = response.headers.get("x-snowflake-request-id") ?? void 0;
+	if (response.status === 422) return new SnowflakeSqlError({
+		kind: "sql",
+		status: response.status,
+		message,
+		body,
+		providerCode,
+		requestId: snowflakeRequestId ?? requestId,
+		retryAfterMs,
+		sqlState: extractSnowflakeSqlState(body),
+		code: providerCode,
+		statementHandle: extractSnowflakeStatementHandle(body)
+	});
+	return new SnowflakeApiError({
+		kind,
+		status: response.status,
+		message,
+		body,
+		providerCode,
+		requestId: snowflakeRequestId ?? requestId,
+		retryAfterMs
+	});
+}
+function resolveHost(credentials) {
+	if (credentials.SNOWFLAKE_HOST) return stripProtocol(credentials.SNOWFLAKE_HOST).replace(/\/+$/u, "");
+	const account = credentials.SNOWFLAKE_ACCOUNT.trim();
+	const region = credentials.SNOWFLAKE_REGION?.trim();
+	if (region && !account.includes(".") && !account.includes("-")) return `${account}.${region}.snowflakecomputing.com`;
+	if (/snowflakecomputing\.com$/u.test(account)) return account;
+	return `${account}.snowflakecomputing.com`;
+}
+function stripProtocol(host) {
+	return host.replace(/^https?:\/\//u, "");
+}
+function toQueryString(query) {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) params.append(key, String(item));
+			continue;
+		}
+		params.set(key, String(value));
+	}
+	const qs = params.toString();
+	return qs.length > 0 ? `?${qs}` : "";
+}
+function isSnowflakeCredentials(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const mode = value.mode;
+	return mode === "keypair" || mode === "oauth" || mode === "pat" || mode === "basic";
+}
+function base64EncodeString(input) {
+	if (typeof btoa === "function") return btoa(unescape(encodeURIComponent(input)));
+	/* c8 ignore next */
+	return Buffer.from(input, "utf8").toString("base64");
+}
+function pseudoRandomUuid() {
+	/* c8 ignore start */
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+	bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+	bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+	const hex = [];
+	for (const b of bytes) hex.push(b.toString(16).padStart(2, "0"));
+	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+	/* c8 ignore end */
+}
+
+//#endregion
+export { createSnowflakeClient, resolveHost };

package/dist/common-BnKTPQXc.mjs

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+//#region src/schemas/common.ts
+/**
+* Cross-domain Zod primitives for the Snowflake integration.
+*
+* These schemas are the single source of truth for identifier shapes,
+* fully-qualified names, statement context, and row / column metadata.
+* Downstream domain files (sql.ts, results.ts, rows.ts, tables.ts, ...)
+* compose them to avoid drift.
+*/
+/**
+* Snowflake identifiers are 1-255 chars. Unquoted identifiers are normalized
+* to upper-case; quoted identifiers preserve case. We keep raw validation
+* permissive and let the server reject bad names — a strict regex would
+* forbid unicode-quoted identifiers legitimately used in the wild.
+*/
+const snowflakeIdentifier = z.string().min(1, "Snowflake identifier must not be empty").max(255, "Snowflake identifier must be 255 chars or less");
+/**
+* Fully-qualified name: `DATABASE.SCHEMA.NAME` (or subsets). Stored as a
+* single string; we do *not* split/rejoin so callers can pass quoted
+* segments through verbatim.
+*/
+const snowflakeFqn = z.string().min(1);
+/**
+* Optional context overrides applied per-statement.
+* Every field is optional — absent values fall back to the connection's
+* session defaults and then to account-level defaults.
+*/
+const statementContextSchema = z.object({
+	database: snowflakeIdentifier.optional(),
+	schema: snowflakeIdentifier.optional(),
+	warehouse: snowflakeIdentifier.optional(),
+	role: snowflakeIdentifier.optional(),
+	timeout: z.number().int().nonnegative().optional(),
+	parameters: z.record(z.string(), z.unknown()).optional()
+}).strict();
+/**
+* SQL API v2 supports typed bindings: each binding is an object with a
+* `type` and a `value`. We allow the simple positional shape and the
+* keyed-map shape Snowflake accepts.
+*/
+const sqlBindingValueSchema = z.object({
+	type: z.string(),
+	value: z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	])
+});
+const sqlBindingsSchema = z.record(z.string(), sqlBindingValueSchema).or(z.array(sqlBindingValueSchema));
+/**
+* Loosely-typed record shape for objects returned by `SHOW ...` commands.
+* Snowflake returns positional arrays with a `rowType[]` describing each
+* column — callers either consume the tuple form directly or `hydrateRow`
+* into a `Record<string, unknown>`.
+*/
+const snowflakeObjectRowSchema = z.record(z.string(), z.unknown());
+/**
+* Column metadata entry as returned under `resultSetMetaData.rowType`.
+*/
+const columnMetaSchema = z.object({
+	name: z.string(),
+	type: z.string(),
+	nullable: z.boolean().optional(),
+	length: z.number().optional(),
+	precision: z.number().optional(),
+	scale: z.number().optional(),
+	byteLength: z.number().optional(),
+	collation: z.string().nullable().optional(),
+	database: z.string().optional(),
+	schema: z.string().optional(),
+	table: z.string().optional()
+}).catchall(z.unknown());
+/**
+* Partition entry describing a shard of the total result set.
+*/
+const partitionInfoSchema = z.object({
+	rowCount: z.number(),
+	uncompressedSize: z.number().optional(),
+	compressedSize: z.number().optional()
+}).catchall(z.unknown());
+const resultSetMetaDataSchema = z.object({
+	numRows: z.number().optional(),
+	format: z.string().optional(),
+	partitionInfo: z.array(partitionInfoSchema).optional(),
+	rowType: z.array(columnMetaSchema).optional()
+}).catchall(z.unknown());
+
+//#endregion
+export { snowflakeIdentifier as a, sqlBindingsSchema as c, snowflakeFqn as i, statementContextSchema as l, partitionInfoSchema as n, snowflakeObjectRowSchema as o, resultSetMetaDataSchema as r, sqlBindingValueSchema as s, columnMetaSchema as t };

package/dist/connection.d.mts

@@ -0,0 +1,2 @@
+import { a as snowflakeAuthModeSchema, c as snowflakeOfficialIntegration, i as snowflake, n as SnowflakeCredentials, o as snowflakeAuthSchema, r as parseSnowflakeCredentials, s as snowflakeBundle, t as SnowflakeAuthMode } from "./integration-CCWMSTlO.mjs";
+export { type SnowflakeAuthMode, type SnowflakeCredentials, parseSnowflakeCredentials, snowflake, snowflakeAuthModeSchema, snowflakeAuthSchema, snowflakeBundle, snowflakeOfficialIntegration };

package/dist/connection.mjs

@@ -0,0 +1,3 @@
+import { a as snowflakeBundle, i as snowflakeAuthSchema, n as snowflake, o as snowflakeOfficialIntegration, r as snowflakeAuthModeSchema, t as parseSnowflakeCredentials } from "./integration-Dptv8L0L.mjs";
+
+export { parseSnowflakeCredentials, snowflake, snowflakeAuthModeSchema, snowflakeAuthSchema, snowflakeBundle, snowflakeOfficialIntegration };

package/dist/databases.d.mts

@@ -0,0 +1,2 @@
+import { CatalogResult, FindDatabasesOptions, ShowDatabasesOptions, findDatabases, showDatabases } from "./catalog.mjs";
+export { type CatalogResult, type FindDatabasesOptions, type ShowDatabasesOptions, findDatabases, showDatabases };

package/dist/databases.mjs

@@ -0,0 +1,3 @@
+import { findDatabases, showDatabases } from "./catalog.mjs";
+
+export { findDatabases, showDatabases };

package/dist/errors-DKnc9o_a.mjs

@@ -0,0 +1,95 @@
+//#region src/errors.ts
+/**
+* Structured Snowflake error. Always thrown by the client on transport or
+* HTTP-level failure, and by higher-level helpers when they wrap those
+* failures with extra context.
+*/
+var SnowflakeApiError = class extends Error {
+	kind;
+	status;
+	body;
+	providerCode;
+	requestId;
+	retryAfterMs;
+	retryable;
+	constructor(init) {
+		super(init.message, init.cause !== void 0 ? { cause: init.cause } : void 0);
+		this.name = "SnowflakeApiError";
+		this.kind = init.kind;
+		this.status = init.status;
+		this.body = init.body;
+		this.providerCode = init.providerCode;
+		this.requestId = init.requestId;
+		this.retryAfterMs = init.retryAfterMs;
+		this.retryable = init.retryable ?? defaultRetryability(init.kind);
+	}
+};
+/**
+* SQL-level failure emitted by the SQL API on status 422. Callers should
+* branch on `sqlState` / `code` when they need to recover from known
+* SQL-layer errors (for example `42S02` table-not-found).
+*/
+var SnowflakeSqlError = class extends SnowflakeApiError {
+	sqlState;
+	code;
+	statementHandle;
+	constructor(init) {
+		super({
+			...init,
+			kind: "sql"
+		});
+		this.name = "SnowflakeSqlError";
+		this.sqlState = init.sqlState;
+		this.code = init.code;
+		this.statementHandle = init.statementHandle;
+	}
+};
+function defaultRetryability(kind) {
+	return kind === "rate_limit" || kind === "server_error" || kind === "timeout" || kind === "network";
+}
+function classifySnowflakeHttpStatus(status) {
+	if (status === 401) return "auth";
+	if (status === 403) return "auth";
+	if (status === 404) return "not_found";
+	if (status === 408) return "timeout";
+	if (status === 409) return "conflict";
+	if (status === 422) return "sql";
+	if (status === 429) return "rate_limit";
+	if (status >= 500 && status <= 599) return "server_error";
+	if (status >= 400 && status <= 499) return "validation";
+	return "unknown";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function extractSnowflakeMessage(body) {
+	if (!isRecord(body)) return void 0;
+	if (typeof body.message === "string") return body.message;
+	if (typeof body.error === "string") return body.error;
+	if (typeof body.errorMessage === "string") return body.errorMessage;
+}
+function extractSnowflakeCode(body) {
+	if (!isRecord(body)) return void 0;
+	if (typeof body.code === "string") return body.code;
+	if (typeof body.errorCode === "string") return body.errorCode;
+}
+function extractSnowflakeSqlState(body) {
+	if (!isRecord(body)) return void 0;
+	if (typeof body.sqlState === "string") return body.sqlState;
+	if (typeof body.sql_state === "string") return body.sql_state;
+}
+function extractSnowflakeStatementHandle(body) {
+	if (!isRecord(body)) return void 0;
+	if (typeof body.statementHandle === "string") return body.statementHandle;
+	if (typeof body.statement_handle === "string") return body.statement_handle;
+}
+function parseRetryAfterHeader(headerValue) {
+	if (!headerValue) return void 0;
+	const asNumber = Number(headerValue);
+	if (Number.isFinite(asNumber) && asNumber >= 0) return asNumber * 1e3;
+	const asDate = Date.parse(headerValue);
+	if (!Number.isNaN(asDate)) return Math.max(0, asDate - Date.now());
+}
+
+//#endregion
+export { extractSnowflakeMessage as a, parseRetryAfterHeader as c, extractSnowflakeCode as i, SnowflakeSqlError as n, extractSnowflakeSqlState as o, classifySnowflakeHttpStatus as r, extractSnowflakeStatementHandle as s, SnowflakeApiError as t };