@keystrokehq/snowflake 0.0.16 → 0.0.18

package/dist/retry-B4-9MZIp.mjs

@@ -1,164 +0,0 @@
-//#region src/jwt.ts
-/**
-* Snowflake JWT signing + public-key fingerprint (RS256, key-pair auth).
-*
-* Isolate-safe — built on `globalThis.crypto.subtle`, no Node `crypto`
-* imports, no native SDKs. Works in Cloudflare Workers, Node 19+,
-* and any modern V8/JSC isolate.
-*
-* Reference: https://docs.snowflake.com/en/user-guide/key-pair-auth
-*/
-const DEFAULT_JWT_LIFETIME_SECONDS = 3300;
-async function createSnowflakeJwt(input) {
-	const now = Math.floor((input.now?.() ?? Date.now()) / 1e3);
-	const exp = now + (input.lifetimeSeconds ?? DEFAULT_JWT_LIFETIME_SECONDS);
-	const account = normalizeAccountForJwt(input.account).toUpperCase();
-	const user = input.user.toUpperCase();
-	const privateKey = await importRsaPrivateKey(input.privateKeyPem);
-	const fingerprint = input.publicKeyFingerprint ?? await derivePublicKeyFingerprint(privateKey);
-	const issuer = `${account}.${user}.${fingerprint}`;
-	const subject = `${account}.${user}`;
-	const header = {
-		alg: "RS256",
-		typ: "JWT"
-	};
-	const payload = {
-		iss: issuer,
-		sub: subject,
-		iat: now,
-		exp
-	};
-	const signingInput = `${base64UrlEncode(JSON.stringify(header))}.${base64UrlEncode(JSON.stringify(payload))}`;
-	const signature = await crypto.subtle.sign({ name: "RSASSA-PKCS1-v1_5" }, privateKey, new TextEncoder().encode(signingInput));
-	return {
-		token: `${signingInput}.${base64UrlEncode(new Uint8Array(signature))}`,
-		expiresAt: exp,
-		fingerprint,
-		issuer,
-		subject
-	};
-}
-/**
-* Compute `SHA256:<base64>` fingerprint over the DER-encoded SPKI public key
-* derived from the PKCS#8 private key. Matches Snowflake's
-* `RSA_PUBLIC_KEY_FP` value shown by `DESC USER`.
-*/
-async function derivePublicKeyFingerprint(privateKey) {
-	const publicKey = await extractPublicKey(privateKey);
-	const spkiDer = await crypto.subtle.exportKey("spki", publicKey);
-	const digest = await crypto.subtle.digest("SHA-256", spkiDer);
-	return `SHA256:${base64Encode(new Uint8Array(digest))}`;
-}
-async function extractPublicKey(privateKey) {
-	const jwk = await crypto.subtle.exportKey("jwk", privateKey);
-	const publicJwk = {
-		kty: jwk.kty,
-		n: jwk.n,
-		e: jwk.e,
-		alg: jwk.alg,
-		ext: true
-	};
-	return crypto.subtle.importKey("jwk", publicJwk, {
-		name: "RSASSA-PKCS1-v1_5",
-		hash: "SHA-256"
-	}, true, ["verify"]);
-}
-async function importRsaPrivateKey(pem) {
-	const armor = peekPemArmor(pem);
-	if (!armor) throw new TypeError("SNOWFLAKE_PRIVATE_KEY is not a PEM-encoded key.");
-	if (armor.type !== "PRIVATE KEY") throw new TypeError(`Unsupported PEM type "${armor.type}". Expected PKCS#8 PEM ("-----BEGIN PRIVATE KEY-----"). Convert PKCS#1 keys with \`openssl pkcs8 -topk8 -nocrypt\`.`);
-	return crypto.subtle.importKey("pkcs8", toArrayBuffer(base64Decode(armor.body)), {
-		name: "RSASSA-PKCS1-v1_5",
-		hash: "SHA-256"
-	}, true, ["sign"]);
-}
-function toArrayBuffer(view) {
-	const copy = new Uint8Array(view.byteLength);
-	copy.set(view);
-	return copy.buffer;
-}
-function peekPemArmor(pem) {
-	const match = pem.match(/-----BEGIN ([A-Z ]+)-----([\s\S]*?)-----END \1-----/u);
-	if (!match) return void 0;
-	const type = match[1]?.trim();
-	const body = match[2]?.replace(/\s+/gu, "");
-	if (!type || !body) return void 0;
-	return {
-		type,
-		body
-	};
-}
-/**
-* Account identifiers accepted by Snowflake take one of these shapes:
-*   - `orgname-accountname` (preferred)
-*   - `account_locator.region`
-*   - `account_locator.region.aws`
-*   - `account_locator` (legacy single-region)
-*
-* The JWT `iss`/`sub` require just the account segment (everything before the
-* first dot for locator-form identifiers) — the org-account hyphen form is
-* passed through as-is.
-*/
-function normalizeAccountForJwt(account) {
-	const trimmed = account.trim();
-	const firstDot = trimmed.indexOf(".");
-	return firstDot === -1 ? trimmed : trimmed.slice(0, firstDot);
-}
-function base64UrlEncode(input) {
-	return base64Encode(typeof input === "string" ? new TextEncoder().encode(input) : input).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
-}
-function base64Encode(bytes) {
-	let binary = "";
-	for (let i = 0; i < bytes.byteLength; i += 1) binary += String.fromCharCode(bytes[i] ?? 0);
-	if (typeof btoa === "function") return btoa(binary);
-	/* c8 ignore next */
-	return Buffer.from(bytes).toString("base64");
-}
-function base64Decode(input) {
-	if (typeof atob === "function") {
-		const binary = atob(input);
-		const bytes = new Uint8Array(binary.length);
-		for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
-		return bytes;
-	}
-	/* c8 ignore next */
-	return new Uint8Array(Buffer.from(input, "base64"));
-}
-
-//#endregion
-//#region src/retry.ts
-const DEFAULT_RETRY_POLICY = {
-	maxRetries: 4,
-	baseDelayMs: 500,
-	maxDelayMs: 2e4,
-	jitterMs: 250
-};
-const RETRYABLE_KINDS = new Set([
-	"rate_limit",
-	"server_error",
-	"timeout",
-	"network"
-]);
-function shouldRetry(kind, attempt, policy = DEFAULT_RETRY_POLICY) {
-	if (attempt >= policy.maxRetries) return false;
-	return RETRYABLE_KINDS.has(kind);
-}
-/**
-* Compute the delay (ms) before the next retry. If the server provided a
-* `Retry-After` header we respect it (clamped to `maxDelayMs`). Otherwise we
-* use `baseDelayMs * 2^attempt` with additive jitter, capped at `maxDelayMs`.
-*/
-function computeBackoffMs({ attempt, retryAfterMs, policy = DEFAULT_RETRY_POLICY, random = Math.random }) {
-	if (retryAfterMs !== void 0 && retryAfterMs >= 0) return Math.min(retryAfterMs, policy.maxDelayMs);
-	const exponent = Math.max(0, attempt - 1);
-	const base = policy.baseDelayMs * 2 ** exponent;
-	const jitter = policy.jitterMs > 0 ? random() * policy.jitterMs : 0;
-	return Math.min(policy.maxDelayMs, Math.floor(base + jitter));
-}
-async function defaultSleep(ms) {
-	if (ms <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-export { createSnowflakeJwt as a, shouldRetry as i, computeBackoffMs as n, defaultSleep as r, DEFAULT_RETRY_POLICY as t };

package/dist/retry-w7cTp1QL.d.mts

@@ -1,10 +0,0 @@
-//#region src/retry.d.ts
-interface RetryPolicy {
-  readonly maxRetries: number;
-  readonly baseDelayMs: number;
-  readonly maxDelayMs: number;
-  /** Adds up to `jitterMs` random ms on top of each backoff. */
-  readonly jitterMs: number;
-}
-//#endregion
-export { RetryPolicy as t };

package/dist/roles/index.d.mts

@@ -1,60 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { t as OptionMap } from "../sql-options-2k5xQ-oS.mjs";
-import { CatalogResult, ShowOptions, showRoles } from "../catalog/index.mjs";
-
-//#region src/roles/index.d.ts
-interface RoleContext {
-  readonly warehouse?: string;
-  readonly sessionRole?: string;
-}
-interface CreateRoleOptions extends RoleContext {
-  readonly name: string;
-  readonly orReplace?: boolean;
-  readonly ifNotExists?: boolean;
-  readonly comment?: string;
-  readonly options?: OptionMap;
-}
-declare function createRole(client: SnowflakeClient, options: CreateRoleOptions): Promise<void>;
-interface AlterRoleOptions extends RoleContext {
-  readonly name: string;
-  readonly rename?: string;
-  readonly set?: OptionMap;
-  readonly unset?: readonly string[];
-  readonly comment?: string;
-  readonly ifExists?: boolean;
-}
-declare function alterRole(client: SnowflakeClient, options: AlterRoleOptions): Promise<void>;
-interface DropRoleOptions extends RoleContext {
-  readonly name: string;
-  readonly ifExists?: boolean;
-}
-declare function dropRole(client: SnowflakeClient, options: DropRoleOptions): Promise<void>;
-interface UseRoleOptions extends RoleContext {
-  readonly name: string;
-}
-declare function useRole(client: SnowflakeClient, options: UseRoleOptions): Promise<void>;
-interface GrantRoleToUserOptions extends RoleContext {
-  /** Role being granted. */
-  readonly role: string;
-  readonly user: string;
-}
-declare function grantRoleToUser(client: SnowflakeClient, options: GrantRoleToUserOptions): Promise<void>;
-interface RevokeRoleFromUserOptions extends RoleContext {
-  readonly role: string;
-  readonly user: string;
-}
-declare function revokeRoleFromUser(client: SnowflakeClient, options: RevokeRoleFromUserOptions): Promise<void>;
-interface GrantRoleToRoleOptions extends RoleContext {
-  /** The child role being granted. */
-  readonly role: string;
-  /** The parent role that will inherit `role`. */
-  readonly parentRole: string;
-}
-declare function grantRoleToRole(client: SnowflakeClient, options: GrantRoleToRoleOptions): Promise<void>;
-interface RevokeRoleFromRoleOptions extends RoleContext {
-  readonly role: string;
-  readonly parentRole: string;
-}
-declare function revokeRoleFromRole(client: SnowflakeClient, options: RevokeRoleFromRoleOptions): Promise<void>;
-//#endregion
-export { AlterRoleOptions, type CatalogResult, CreateRoleOptions, DropRoleOptions, GrantRoleToRoleOptions, GrantRoleToUserOptions, RevokeRoleFromRoleOptions, RevokeRoleFromUserOptions, RoleContext, type ShowOptions, UseRoleOptions, alterRole, createRole, dropRole, grantRoleToRole, grantRoleToUser, revokeRoleFromRole, revokeRoleFromUser, showRoles, useRole };

package/dist/roles/index.mjs

@@ -1,74 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { a as quoteLiteral, i as quoteIdentifier } from "../sql-safety-BZpAPsq6.mjs";
-import { t as formatOptions } from "../sql-options-D6GEa21F.mjs";
-import { showRoles } from "../catalog/index.mjs";
-
-//#region src/roles/index.ts
-async function createRole(client, options) {
-	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""} ROLE${options.ifNotExists ? " IF NOT EXISTS" : ""}`;
-	const body = options.options && Object.keys(options.options).length > 0 ? ` ${formatOptions(options.options)}` : "";
-	const comment = options.comment ? ` COMMENT = ${quoteLiteral(options.comment)}` : "";
-	await executeSql(client, {
-		statement: `${prefix} ${quoteIdentifier(options.name)}${body}${comment}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function alterRole(client, options) {
-	let tail;
-	if (options.rename) tail = `RENAME TO ${quoteIdentifier(options.rename)}`;
-	else if (options.set && Object.keys(options.set).length > 0) tail = `SET ${formatOptions(options.set)}`;
-	else if (options.unset && options.unset.length > 0) tail = `UNSET ${options.unset.map((k) => k.toUpperCase()).join(", ")}`;
-	else if (options.comment !== void 0) tail = `SET COMMENT = ${quoteLiteral(options.comment)}`;
-	else throw new Error("alterRole requires one of: rename / set / unset / comment");
-	await executeSql(client, {
-		statement: `ALTER ROLE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)} ${tail}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function dropRole(client, options) {
-	await executeSql(client, {
-		statement: `DROP ROLE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function useRole(client, options) {
-	await executeSql(client, {
-		statement: `USE ROLE ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function grantRoleToUser(client, options) {
-	await executeSql(client, {
-		statement: `GRANT ROLE ${quoteIdentifier(options.role)} TO USER ${quoteIdentifier(options.user)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function revokeRoleFromUser(client, options) {
-	await executeSql(client, {
-		statement: `REVOKE ROLE ${quoteIdentifier(options.role)} FROM USER ${quoteIdentifier(options.user)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function grantRoleToRole(client, options) {
-	await executeSql(client, {
-		statement: `GRANT ROLE ${quoteIdentifier(options.role)} TO ROLE ${quoteIdentifier(options.parentRole)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-async function revokeRoleFromRole(client, options) {
-	await executeSql(client, {
-		statement: `REVOKE ROLE ${quoteIdentifier(options.role)} FROM ROLE ${quoteIdentifier(options.parentRole)}`,
-		warehouse: options.warehouse,
-		role: options.sessionRole
-	});
-}
-
-//#endregion
-export { alterRole, createRole, dropRole, grantRoleToRole, grantRoleToUser, revokeRoleFromRole, revokeRoleFromUser, showRoles, useRole };

package/dist/rows/index.d.mts

@@ -1,106 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow, v as SqlBinding } from "../statements-DJL0qVNA.mjs";
-//#region src/rows/index.d.ts
-/**
- * A value a caller can pass into an `insert` / `update` / `where` map. The
- * binding helper below maps each JS primitive onto a Snowflake type (`TEXT`,
- * `FIXED`, `REAL`, `BOOLEAN`, `TIMESTAMP_LTZ`) so the SQL API receives a
- * faithful typed value. Callers needing a specific Snowflake type can pass a
- * pre-built `SqlBinding` directly.
- */
-type RowValue = string | number | bigint | boolean | Date | null | undefined | SqlBinding;
-type RowRecord = Readonly<Record<string, RowValue>>;
-interface RowTableRef {
-  readonly database?: string;
-  readonly schema?: string;
-  readonly table: string;
-}
-interface RowContext {
-  readonly warehouse?: string;
-  readonly role?: string;
-}
-/**
- * Map a JS value to its Snowflake typed binding. Callers who need full
- * control can pre-build a `{type, value}` object and pass it through.
- */
-declare function inferBinding(value: RowValue): SqlBinding;
-/**
- * Mutable binding builder. Internally indexes bindings starting at 1 and
- * returns the `?` placeholder for each append so callers can weave them into
- * their SQL composition.
- */
-declare class BindingBuilder {
-  private readonly map;
-  private counter;
-  add(value: RowValue): string;
-  toRecord(): Readonly<Record<string, SqlBinding>>;
-  size(): number;
-}
-type OrderDirection = 'ASC' | 'DESC';
-interface FindRowsOptions extends RowTableRef, RowContext {
-  readonly where?: RowRecord;
-  readonly columns?: readonly string[];
-  readonly orderBy?: readonly {
-    readonly column: string;
-    readonly direction?: OrderDirection;
-  }[];
-  readonly limit?: number;
-  readonly offset?: number;
-}
-interface FindRowOptions extends RowTableRef, RowContext {
-  readonly where: RowRecord;
-  readonly columns?: readonly string[];
-}
-declare function findRows(client: SnowflakeClient, options: FindRowsOptions): Promise<readonly HydratedRow[]>;
-declare function findRow(client: SnowflakeClient, options: FindRowOptions): Promise<HydratedRow | undefined>;
-interface InsertRowOptions extends RowTableRef, RowContext {
-  readonly row: RowRecord;
-}
-declare function insertRow(client: SnowflakeClient, options: InsertRowOptions): Promise<number>;
-interface BatchInsertOptions extends RowTableRef, RowContext {
-  readonly rows: readonly RowRecord[];
-  /**
-   * When provided, use this explicit column list and look up each row's
-   * value by column; when missing, use the union of keys from the first
-   * row (all subsequent rows must share the same shape).
-   */
-  readonly columns?: readonly string[];
-}
-declare function batchInsert(client: SnowflakeClient, options: BatchInsertOptions): Promise<number>;
-interface UpdateRowOptions extends RowTableRef, RowContext {
-  readonly where: RowRecord;
-  readonly set: RowRecord;
-}
-declare function updateRow(client: SnowflakeClient, options: UpdateRowOptions): Promise<number>;
-interface DeleteRowOptions extends RowTableRef, RowContext {
-  readonly where: RowRecord;
-}
-declare function deleteRow(client: SnowflakeClient, options: DeleteRowOptions): Promise<number>;
-interface UpsertRowOptions extends RowTableRef, RowContext {
-  readonly row: RowRecord;
-  /** Columns whose equality defines the MATCH condition. */
-  readonly matchColumns: readonly string[];
-  /**
-   * Columns to write on UPDATE (defaults to every column in `row` except the
-   * match columns, which are left untouched on match).
-   */
-  readonly updateColumns?: readonly string[];
-}
-interface UpsertRowResult {
-  readonly inserted: number;
-  readonly updated: number;
-}
-declare function upsertRow(client: SnowflakeClient, options: UpsertRowOptions): Promise<UpsertRowResult>;
-interface MergeRowsOptions extends RowTableRef, RowContext {
-  /**
-   * Raw MERGE statement source. Useful when callers want full control over
-   * a merge and just want the client/context/binding infra. `statement`
-   * should already reference the resolved FQN from
-   * {@link buildFqn}/{@link quoteIdentifier}.
-   */
-  readonly statement: string;
-  readonly bindings?: Readonly<Record<string, SqlBinding>>;
-}
-declare function mergeRows(client: SnowflakeClient, options: MergeRowsOptions): Promise<UpsertRowResult>;
-//#endregion
-export { BatchInsertOptions, BindingBuilder, DeleteRowOptions, FindRowOptions, FindRowsOptions, InsertRowOptions, MergeRowsOptions, OrderDirection, RowContext, RowRecord, RowTableRef, RowValue, UpdateRowOptions, UpsertRowOptions, UpsertRowResult, batchInsert, deleteRow, findRow, findRows, inferBinding, insertRow, mergeRows, updateRow, upsertRow };

package/dist/rows/index.mjs

@@ -1,223 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { i as quoteIdentifier, t as buildFqn } from "../sql-safety-BZpAPsq6.mjs";
-
-//#region src/rows/index.ts
-function isSqlBinding(value) {
-	return typeof value === "object" && value !== null && "type" in value && "value" in value && typeof value.type === "string";
-}
-/**
-* Map a JS value to its Snowflake typed binding. Callers who need full
-* control can pre-build a `{type, value}` object and pass it through.
-*/
-function inferBinding(value) {
-	if (isSqlBinding(value)) return value;
-	if (value === null || value === void 0) return {
-		type: "TEXT",
-		value: null
-	};
-	if (typeof value === "string") return {
-		type: "TEXT",
-		value
-	};
-	if (typeof value === "boolean") return {
-		type: "BOOLEAN",
-		value: value ? "true" : "false"
-	};
-	if (typeof value === "bigint") return {
-		type: "FIXED",
-		value: value.toString()
-	};
-	if (typeof value === "number") {
-		if (Number.isNaN(value) || !Number.isFinite(value)) throw new TypeError("Cannot bind NaN or Infinity as a Snowflake value");
-		return Number.isInteger(value) ? {
-			type: "FIXED",
-			value: value.toString()
-		} : {
-			type: "REAL",
-			value: value.toString()
-		};
-	}
-	if (value instanceof Date) return {
-		type: "TIMESTAMP_LTZ",
-		value: value.toISOString()
-	};
-	const unreachable = value;
-	throw new TypeError(`Unsupported binding type: ${typeof unreachable}`);
-}
-/**
-* Mutable binding builder. Internally indexes bindings starting at 1 and
-* returns the `?` placeholder for each append so callers can weave them into
-* their SQL composition.
-*/
-var BindingBuilder = class {
-	map = {};
-	counter = 0;
-	add(value) {
-		this.counter += 1;
-		this.map[String(this.counter)] = inferBinding(value);
-		return "?";
-	}
-	toRecord() {
-		return this.map;
-	}
-	size() {
-		return this.counter;
-	}
-};
-function composeWhere(where, bindings) {
-	const clauses = [];
-	for (const [column, value] of Object.entries(where)) {
-		if (value === null || value === void 0) {
-			clauses.push(`${quoteIdentifier(column)} IS NULL`);
-			continue;
-		}
-		clauses.push(`${quoteIdentifier(column)} = ${bindings.add(value)}`);
-	}
-	return clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
-}
-function composeSet(set, bindings) {
-	const fragments = Object.entries(set).map(([column, value]) => `${quoteIdentifier(column)} = ${bindings.add(value)}`);
-	if (fragments.length === 0) throw new Error("updateRow requires at least one column in `set`");
-	return fragments.join(", ");
-}
-function executeRowStatement(client, sql, bindings, ctx) {
-	return executeSql(client, {
-		statement: sql,
-		warehouse: ctx.warehouse,
-		role: ctx.role,
-		database: ctx.database,
-		schema: ctx.schema,
-		bindings: bindings.size() > 0 ? bindings.toRecord() : void 0
-	});
-}
-/**
-* Read the first numeric value from the first row of a DML result.
-* Snowflake returns INSERT/UPDATE/DELETE stats as a single row with a
-* column like `"number of rows inserted"`.
-*/
-function readAffectedRows(result) {
-	if (result.rows.length === 0) return 0;
-	const firstRow = result.rows[0];
-	if (!firstRow) return 0;
-	const values = Array.isArray(firstRow) ? firstRow : Object.values(firstRow);
-	for (const value of values) {
-		if (typeof value === "number") return value;
-		if (typeof value === "bigint") return Number(value);
-		if (typeof value === "string") {
-			const parsed = Number(value);
-			if (!Number.isNaN(parsed)) return parsed;
-		}
-	}
-	return 0;
-}
-function composeColumnList(columns) {
-	if (!columns || columns.length === 0) return "*";
-	return columns.map((c) => quoteIdentifier(c)).join(", ");
-}
-function composeOrderBy(orderBy) {
-	if (!orderBy || orderBy.length === 0) return "";
-	return ` ORDER BY ${orderBy.map(({ column, direction }) => {
-		const dir = direction === "DESC" ? " DESC" : " ASC";
-		return `${quoteIdentifier(column)}${dir}`;
-	}).join(", ")}`;
-}
-function composeLimitOffset(limit, offset) {
-	let out = "";
-	if (typeof limit === "number" && limit >= 0) out += ` LIMIT ${Math.floor(limit)}`;
-	if (typeof offset === "number" && offset > 0) out += ` OFFSET ${Math.floor(offset)}`;
-	return out;
-}
-async function findRows(client, options) {
-	const bindings = new BindingBuilder();
-	return (await executeRowStatement(client, `SELECT ${composeColumnList(options.columns)} FROM ${buildFqn(options.database, options.schema, options.table)}` + composeWhere(options.where ?? {}, bindings) + composeOrderBy(options.orderBy) + composeLimitOffset(options.limit, options.offset), bindings, options)).rows;
-}
-async function findRow(client, options) {
-	return (await findRows(client, {
-		...options,
-		limit: 1
-	}))[0];
-}
-async function insertRow(client, options) {
-	const columns = Object.keys(options.row);
-	if (columns.length === 0) throw new Error("insertRow requires at least one column in `row`");
-	const bindings = new BindingBuilder();
-	const placeholders = columns.map((column) => bindings.add(options.row[column]));
-	return readAffectedRows(await executeRowStatement(client, `INSERT INTO ${buildFqn(options.database, options.schema, options.table)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES (${placeholders.join(", ")})`, bindings, options));
-}
-async function batchInsert(client, options) {
-	if (options.rows.length === 0) return 0;
-	const first = options.rows[0];
-	if (!first) return 0;
-	const columns = options.columns ?? Object.keys(first);
-	if (columns.length === 0) throw new Error("batchInsert requires at least one column");
-	const bindings = new BindingBuilder();
-	const valueTuples = options.rows.map((row) => {
-		return `(${columns.map((column) => bindings.add(row[column])).join(", ")})`;
-	});
-	return readAffectedRows(await executeRowStatement(client, `INSERT INTO ${buildFqn(options.database, options.schema, options.table)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES ${valueTuples.join(", ")}`, bindings, options));
-}
-async function updateRow(client, options) {
-	const bindings = new BindingBuilder();
-	const setClause = composeSet(options.set, bindings);
-	const whereClause = composeWhere(options.where, bindings);
-	return readAffectedRows(await executeRowStatement(client, `UPDATE ${buildFqn(options.database, options.schema, options.table)} SET ${setClause}${whereClause}`, bindings, options));
-}
-async function deleteRow(client, options) {
-	if (Object.keys(options.where).length === 0) throw new Error("deleteRow refuses an empty where filter; call executeSql to truncate intentionally");
-	const bindings = new BindingBuilder();
-	const whereClause = composeWhere(options.where, bindings);
-	return readAffectedRows(await executeRowStatement(client, `DELETE FROM ${buildFqn(options.database, options.schema, options.table)}${whereClause}`, bindings, options));
-}
-function readMergeStats(result) {
-	if (result.rows.length === 0) return {
-		inserted: 0,
-		updated: 0
-	};
-	const firstRow = result.rows[0];
-	if (!firstRow) return {
-		inserted: 0,
-		updated: 0
-	};
-	const entries = Array.isArray(firstRow) ? result.columns.map((col, idx) => [col.name, firstRow[idx]]) : Object.entries(firstRow);
-	let inserted = 0;
-	let updated = 0;
-	for (const [name, value] of entries) {
-		const numeric = typeof value === "number" ? value : Number(value);
-		if (!Number.isFinite(numeric)) continue;
-		const key = name.toLowerCase();
-		if (key.includes("insert")) inserted = numeric;
-		else if (key.includes("update")) updated = numeric;
-	}
-	return {
-		inserted,
-		updated
-	};
-}
-async function upsertRow(client, options) {
-	const rowColumns = Object.keys(options.row);
-	if (rowColumns.length === 0) throw new Error("upsertRow requires at least one column in `row`");
-	if (options.matchColumns.length === 0) throw new Error("upsertRow requires at least one match column");
-	for (const column of options.matchColumns) if (!rowColumns.includes(column)) throw new Error(`upsertRow match column "${column}" is missing from row`);
-	const bindings = new BindingBuilder();
-	const srcTuples = rowColumns.map((column) => bindings.add(options.row[column]));
-	const fqn = buildFqn(options.database, options.schema, options.table);
-	rowColumns.map((c) => quoteIdentifier(c)).join(", ");
-	const matchPredicate = options.matchColumns.map((column) => `t.${quoteIdentifier(column)} = s.${quoteIdentifier(column)}`).join(" AND ");
-	const updateSet = (options.updateColumns ?? rowColumns.filter((c) => !options.matchColumns.includes(c))).map((column) => `${quoteIdentifier(column)} = s.${quoteIdentifier(column)}`).join(", ");
-	const insertCols = rowColumns.map((c) => quoteIdentifier(c)).join(", ");
-	const insertVals = rowColumns.map((c) => `s.${quoteIdentifier(c)}`).join(", ");
-	return readMergeStats(await executeRowStatement(client, `MERGE INTO ${fqn} t USING (SELECT ${srcTuples.map((placeholder, idx) => `${placeholder} AS ${quoteIdentifier(rowColumns[idx] ?? "")}`).join(", ")}) s ON ${matchPredicate}` + (updateSet ? ` WHEN MATCHED THEN UPDATE SET ${updateSet}` : "") + ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`, bindings, options));
-}
-async function mergeRows(client, options) {
-	return readMergeStats(await executeSql(client, {
-		statement: options.statement,
-		warehouse: options.warehouse,
-		role: options.role,
-		database: options.database,
-		schema: options.schema,
-		bindings: options.bindings
-	}));
-}
-
-//#endregion
-export { BindingBuilder, batchInsert, deleteRow, findRow, findRows, inferBinding, insertRow, mergeRows, updateRow, upsertRow };

package/dist/schemas/index.d.mts

@@ -1,2 +0,0 @@
-import { C as resultSetMetaDataSchema, D as sqlBindingValueSchema, E as snowflakeObjectRowSchema, O as sqlBindingsSchema, S as partitionInfoSchema, T as snowflakeIdentifier, _ as SnowflakeObjectRow, a as SubmitStatementInput, b as StatementContext, c as statementStatus, d as HydratedRow, f as PartitionResponse, g as ResultSetMetaData, h as PartitionInfo, i as StatementTerminalStatus, k as statementContextSchema, l as statementStatusCodeSchema, m as ColumnMeta, n as StatementResponse, o as cancelStatementResponseSchema, p as partitionResponseSchema, r as StatementStatus, s as statementResponseSchema, t as CancelStatementResponse, u as submitStatementInputSchema, v as SqlBinding, w as snowflakeFqn, x as columnMetaSchema, y as SqlBindings } from "../statements-DJL0qVNA.mjs";
-export { CancelStatementResponse, ColumnMeta, HydratedRow, PartitionInfo, PartitionResponse, ResultSetMetaData, SnowflakeObjectRow, SqlBinding, SqlBindings, StatementContext, StatementResponse, StatementStatus, StatementTerminalStatus, SubmitStatementInput, cancelStatementResponseSchema, columnMetaSchema, partitionInfoSchema, partitionResponseSchema, resultSetMetaDataSchema, snowflakeFqn, snowflakeIdentifier, snowflakeObjectRowSchema, sqlBindingValueSchema, sqlBindingsSchema, statementContextSchema, statementResponseSchema, statementStatus, statementStatusCodeSchema, submitStatementInputSchema };

package/dist/schemas/index.mjs

@@ -1,4 +0,0 @@
-import { a as snowflakeIdentifier, c as sqlBindingsSchema, i as snowflakeFqn, l as statementContextSchema, n as partitionInfoSchema, o as snowflakeObjectRowSchema, r as resultSetMetaDataSchema, s as sqlBindingValueSchema, t as columnMetaSchema } from "../common-DfpCwJx5.mjs";
-import { a as submitStatementInputSchema, i as statementStatusCodeSchema, n as statementResponseSchema, o as partitionResponseSchema, r as statementStatus, t as cancelStatementResponseSchema } from "../statements-BumhMhN4.mjs";
-
-export { cancelStatementResponseSchema, columnMetaSchema, partitionInfoSchema, partitionResponseSchema, resultSetMetaDataSchema, snowflakeFqn, snowflakeIdentifier, snowflakeObjectRowSchema, sqlBindingValueSchema, sqlBindingsSchema, statementContextSchema, statementResponseSchema, statementStatus, statementStatusCodeSchema, submitStatementInputSchema };

package/dist/schemas-catalog/index.d.mts

@@ -1,2 +0,0 @@
-import { CatalogResult, FindSchemasOptions, ShowSchemasOptions, findSchemas, showSchemas } from "../catalog/index.mjs";
-export { type CatalogResult, type FindSchemasOptions, type ShowSchemasOptions, findSchemas, showSchemas };

package/dist/schemas-catalog/index.mjs

@@ -1,3 +0,0 @@
-import { findSchemas, showSchemas } from "../catalog/index.mjs";
-
-export { findSchemas, showSchemas };