@keystrokehq/snowflake 0.0.16 → 0.0.18

package/dist/verification/index.mjs

@@ -1,512 +0,0 @@
-import { azureEventGridEventSchema, gcsPubSubPushSchema, snsNotificationSchema } from "../events/index.mjs";
-import { z } from "zod";
-import { X509Certificate, createPublicKey, createVerify } from "node:crypto";
-
-//#region src/verification/index.ts
-/**
-* Signature / authenticity verification helpers for the three
-* Snowflake auto-ingest webhook triggers. Everything here is
-* credential-free: each function is called from the webhook trigger
-* `verify` callback with request + expected-trust inputs extracted
-* from the relevant `CredentialSet`.
-*
-* All verifiers throw {@link SnowflakeWebhookVerificationError} on
-* failure. Callers should let the error propagate; Keystroke surfaces
-* it to the pipeline audit log and returns 4xx to the caller.
-*/
-/**
-* Thrown whenever a webhook verifier rejects a request. Includes a
-* compact `reason` code so callers can distinguish transport problems
-* (signature mismatch) from policy problems (wrong audience).
-*/
-var SnowflakeWebhookVerificationError = class extends Error {
-	name = "SnowflakeWebhookVerificationError";
-	reason;
-	provider;
-	constructor(input) {
-		super(input.message, input.cause !== void 0 ? { cause: input.cause } : void 0);
-		this.reason = input.reason;
-		this.provider = input.provider ?? "unknown";
-	}
-};
-function defaultFetch() {
-	if (typeof fetch === "function") return fetch;
-	throw new SnowflakeWebhookVerificationError({
-		message: "global fetch is not available; pass a custom fetchImpl to the verifier.",
-		reason: "no-fetch"
-	});
-}
-function base64UrlDecode(value) {
-	const pad = value.length % 4 === 0 ? "" : "=".repeat(4 - value.length % 4);
-	return Buffer.from(value.replace(/-/gu, "+").replace(/_/gu, "/") + pad, "base64");
-}
-function readHeader(headers, name) {
-	const lower = name.toLowerCase();
-	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === lower && typeof value === "string") return value;
-}
-const DEFAULT_SNS_HOST_PATTERN = /^sns\.[a-z0-9-]+\.amazonaws\.com(\.cn)?$/u;
-/**
-* Parse an SNS HTTP(S) notification body into a typed envelope. Throws
-* if the body is not valid JSON or doesn't match the SNS schema.
-*/
-function parseSnsNotification(rawBody) {
-	let json;
-	try {
-		json = JSON.parse(rawBody);
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "SNS body is not valid JSON.",
-			reason: "invalid-json",
-			provider: "aws-s3",
-			cause
-		});
-	}
-	const parsed = snsNotificationSchema.safeParse(json);
-	if (!parsed.success) throw new SnowflakeWebhookVerificationError({
-		message: `SNS body failed schema validation: ${parsed.error.message}`,
-		reason: "schema",
-		provider: "aws-s3",
-		cause: parsed.error
-	});
-	return parsed.data;
-}
-/**
-* Build the canonical string that SNS signs. The SNS spec fixes the
-* field order per message type — do not re-order keys.
-*
-* @see https://docs.aws.amazon.com/sns/latest/dg/sns-verify-signature-of-message.html
-*/
-function canonicalSnsString(message) {
-	const lines = [];
-	if (message.Type === "Notification") {
-		lines.push("Message", message.Message);
-		lines.push("MessageId", message.MessageId);
-		if (message.Subject !== void 0) lines.push("Subject", message.Subject);
-		lines.push("Timestamp", message.Timestamp);
-		lines.push("TopicArn", message.TopicArn);
-		lines.push("Type", message.Type);
-	} else {
-		lines.push("Message", message.Message);
-		lines.push("MessageId", message.MessageId);
-		if (message.SubscribeURL !== void 0) lines.push("SubscribeURL", message.SubscribeURL);
-		lines.push("Timestamp", message.Timestamp);
-		if (message.Token !== void 0) lines.push("Token", message.Token);
-		lines.push("TopicArn", message.TopicArn);
-		lines.push("Type", message.Type);
-	}
-	return `${lines.join("\n")}\n`;
-}
-async function fetchSigningCertPem(signingCertUrl, options) {
-	if (options.resolveCert) return options.resolveCert(signingCertUrl);
-	const response = await (options.fetchImpl ?? defaultFetch())(signingCertUrl);
-	if (!response.ok) throw new SnowflakeWebhookVerificationError({
-		message: `Unable to fetch SNS signing certificate: ${response.status}`,
-		reason: "cert-fetch",
-		provider: "aws-s3"
-	});
-	return response.text();
-}
-/**
-* Verify an SNS notification. Performs:
-*  1. Topic-ARN pinning (if provided).
-*  2. SigningCertURL host allowlist (default: AWS SNS hosts only —
-*     prevents SSRF against arbitrary URLs).
-*  3. Cert fetch + signature verification (SHA1 or SHA256 per
-*     `SignatureVersion`).
-*
-* Returns the parsed notification on success.
-*/
-async function verifySnsMessage(rawBody, options = {}) {
-	const message = parseSnsNotification(rawBody);
-	if (options.expectedTopicArn && message.TopicArn !== options.expectedTopicArn) throw new SnowflakeWebhookVerificationError({
-		message: `SNS TopicArn mismatch: received ${message.TopicArn}, expected ${options.expectedTopicArn}.`,
-		reason: "topic-arn-mismatch",
-		provider: "aws-s3"
-	});
-	const hostPattern = options.allowedSigningCertHostPattern ? new RegExp(options.allowedSigningCertHostPattern, "u") : DEFAULT_SNS_HOST_PATTERN;
-	let certUrl;
-	try {
-		certUrl = new URL(message.SigningCertURL);
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "SNS SigningCertURL is not a valid URL.",
-			reason: "cert-url-invalid",
-			provider: "aws-s3",
-			cause
-		});
-	}
-	if (certUrl.protocol !== "https:" || !hostPattern.test(certUrl.hostname)) throw new SnowflakeWebhookVerificationError({
-		message: `SNS SigningCertURL host ${certUrl.hostname} not in allowlist.`,
-		reason: "cert-url-host",
-		provider: "aws-s3"
-	});
-	const pem = await fetchSigningCertPem(message.SigningCertURL, options);
-	let cert;
-	try {
-		cert = new X509Certificate(pem);
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "SNS signing certificate is not a valid X.509 PEM.",
-			reason: "cert-parse",
-			provider: "aws-s3",
-			cause
-		});
-	}
-	const verifier = createVerify(message.SignatureVersion === "2" ? "RSA-SHA256" : "RSA-SHA1");
-	verifier.update(canonicalSnsString(message), "utf8");
-	if (!verifier.verify(cert.publicKey, message.Signature, "base64")) throw new SnowflakeWebhookVerificationError({
-		message: "SNS signature did not verify against the signing certificate.",
-		reason: "signature",
-		provider: "aws-s3"
-	});
-	return message;
-}
-const googleJwksKeySchema = z.object({
-	kid: z.string(),
-	kty: z.string(),
-	alg: z.string().optional(),
-	use: z.string().optional(),
-	n: z.string(),
-	e: z.string()
-}).catchall(z.unknown());
-const googleJwksResponseSchema = z.object({ keys: z.array(googleJwksKeySchema) });
-const jwtHeaderSchema = z.object({
-	alg: z.string(),
-	kid: z.string().optional(),
-	typ: z.string().optional()
-}).catchall(z.unknown());
-const googleOidcClaimsSchema = z.object({
-	iss: z.string(),
-	aud: z.union([z.string(), z.array(z.string())]).optional(),
-	sub: z.string().optional(),
-	email: z.string().optional(),
-	email_verified: z.boolean().optional(),
-	exp: z.number(),
-	iat: z.number().optional(),
-	nbf: z.number().optional()
-}).catchall(z.unknown());
-const jwksCache = /* @__PURE__ */ new Map();
-async function resolveJwksKeys(jwksUri, options) {
-	if (options.resolveJwks) return options.resolveJwks(jwksUri);
-	if (!options.disableCache) {
-		const cached = jwksCache.get(jwksUri);
-		const now = options.now ? options.now() : Date.now();
-		if (cached && cached.expiresAt > now) return cached.keys;
-	}
-	const response = await (options.fetchImpl ?? defaultFetch())(jwksUri);
-	if (!response.ok) throw new SnowflakeWebhookVerificationError({
-		message: `Unable to fetch JWKS ${jwksUri}: ${response.status}`,
-		reason: "jwks-fetch",
-		provider: "gcp-gcs"
-	});
-	const json = await response.json();
-	const parsed = googleJwksResponseSchema.safeParse(json);
-	if (!parsed.success) throw new SnowflakeWebhookVerificationError({
-		message: `JWKS payload failed schema validation: ${parsed.error.message}`,
-		reason: "jwks-schema",
-		provider: "gcp-gcs",
-		cause: parsed.error
-	});
-	if (!options.disableCache) {
-		const now = options.now ? options.now() : Date.now();
-		jwksCache.set(jwksUri, {
-			expiresAt: now + 36e5,
-			keys: parsed.data.keys
-		});
-	}
-	return parsed.data.keys;
-}
-/**
-* Verify the OIDC JWT that GCP Pub/Sub push sends in `Authorization:
-* Bearer <token>`. Returns the decoded claims on success.
-*/
-async function verifyPubSubPushAuthorization(authorizationHeader, options) {
-	if (!authorizationHeader) throw new SnowflakeWebhookVerificationError({
-		message: "Missing Authorization header on Pub/Sub push request.",
-		reason: "missing-auth-header",
-		provider: "gcp-gcs"
-	});
-	const match = authorizationHeader.match(/^Bearer\s+(\S+)$/u);
-	if (!match) throw new SnowflakeWebhookVerificationError({
-		message: "Authorization header is not a Bearer token.",
-		reason: "bad-auth-header",
-		provider: "gcp-gcs"
-	});
-	const parts = (match[1] ?? "").split(".");
-	if (parts.length !== 3) throw new SnowflakeWebhookVerificationError({
-		message: "JWT must have three segments.",
-		reason: "jwt-shape",
-		provider: "gcp-gcs"
-	});
-	const [encodedHeader, encodedPayload, encodedSignature] = parts;
-	let header;
-	let claims;
-	try {
-		header = jwtHeaderSchema.parse(JSON.parse(base64UrlDecode(encodedHeader).toString("utf8")));
-		claims = googleOidcClaimsSchema.parse(JSON.parse(base64UrlDecode(encodedPayload).toString("utf8")));
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "JWT header or payload did not decode cleanly.",
-			reason: "jwt-decode",
-			provider: "gcp-gcs",
-			cause
-		});
-	}
-	if (header.alg !== "RS256") throw new SnowflakeWebhookVerificationError({
-		message: `Unsupported JWT algorithm ${header.alg}; only RS256 is accepted.`,
-		reason: "jwt-alg",
-		provider: "gcp-gcs"
-	});
-	const keys = await resolveJwksKeys(options.jwksUri ?? "https://www.googleapis.com/oauth2/v3/certs", options);
-	const jwk = header.kid ? keys.find((k) => k.kid === header.kid) : keys[0];
-	if (!jwk) throw new SnowflakeWebhookVerificationError({
-		message: `No JWKS key matched kid ${header.kid ?? "(none)"}.`,
-		reason: "jwks-kid-miss",
-		provider: "gcp-gcs"
-	});
-	const publicKey = createPublicKey({
-		key: jwk,
-		format: "jwk"
-	});
-	const verifier = createVerify("RSA-SHA256");
-	verifier.update(`${encodedHeader}.${encodedPayload}`, "utf8");
-	if (!verifier.verify(publicKey, base64UrlDecode(encodedSignature))) throw new SnowflakeWebhookVerificationError({
-		message: "JWT signature did not verify.",
-		reason: "jwt-signature",
-		provider: "gcp-gcs"
-	});
-	const expectedIssuer = options.issuer ?? "https://accounts.google.com";
-	if (claims.iss !== expectedIssuer) throw new SnowflakeWebhookVerificationError({
-		message: `JWT iss ${claims.iss} != expected ${expectedIssuer}.`,
-		reason: "jwt-issuer",
-		provider: "gcp-gcs"
-	});
-	if (!(claims.aud === void 0 ? [] : Array.isArray(claims.aud) ? claims.aud : [claims.aud]).includes(options.expectedAudience)) throw new SnowflakeWebhookVerificationError({
-		message: `JWT aud does not include ${options.expectedAudience}.`,
-		reason: "jwt-audience",
-		provider: "gcp-gcs"
-	});
-	if (claims.email !== options.expectedServiceAccount) throw new SnowflakeWebhookVerificationError({
-		message: `JWT email ${claims.email} != expected service account ${options.expectedServiceAccount}.`,
-		reason: "jwt-email",
-		provider: "gcp-gcs"
-	});
-	const now = Math.floor((options.now ? options.now() : Date.now()) / 1e3);
-	if (claims.exp < now) throw new SnowflakeWebhookVerificationError({
-		message: "JWT is expired.",
-		reason: "jwt-expired",
-		provider: "gcp-gcs"
-	});
-	if (claims.nbf !== void 0 && claims.nbf > now + 60) throw new SnowflakeWebhookVerificationError({
-		message: "JWT nbf is in the future.",
-		reason: "jwt-nbf",
-		provider: "gcp-gcs"
-	});
-	return claims;
-}
-/** Parse a Pub/Sub push envelope. Does not verify anything. */
-function parsePubSubPush(rawBody) {
-	let json;
-	try {
-		json = JSON.parse(rawBody);
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "Pub/Sub body is not valid JSON.",
-			reason: "invalid-json",
-			provider: "gcp-gcs",
-			cause
-		});
-	}
-	const parsed = gcsPubSubPushSchema.safeParse(json);
-	if (!parsed.success) throw new SnowflakeWebhookVerificationError({
-		message: `Pub/Sub body failed schema validation: ${parsed.error.message}`,
-		reason: "schema",
-		provider: "gcp-gcs",
-		cause: parsed.error
-	});
-	return parsed.data;
-}
-/**
-* Event Grid sends its validation request as a single-event array with
-* `eventType: 'Microsoft.EventGrid.SubscriptionValidationEvent'`. The
-* Keystroke webhook primitive does not support dynamic responses, so
-* operators must use **manual validation** (VSCode extension, portal
-* click-through, or a curl to `validationUrl`) rather than relying on
-* synchronous `validationResponse`.
-*/
-const EVENT_GRID_VALIDATION_EVENT_TYPE = "Microsoft.EventGrid.SubscriptionValidationEvent";
-/** Parse an Event Grid batch. Validates each envelope with Zod. */
-function parseEventGridBatch(rawBody) {
-	let json;
-	try {
-		json = JSON.parse(rawBody);
-	} catch (cause) {
-		throw new SnowflakeWebhookVerificationError({
-			message: "Event Grid body is not valid JSON.",
-			reason: "invalid-json",
-			provider: "azure-blob",
-			cause
-		});
-	}
-	if (!Array.isArray(json)) throw new SnowflakeWebhookVerificationError({
-		message: "Event Grid body must be a JSON array.",
-		reason: "shape",
-		provider: "azure-blob"
-	});
-	const events = [];
-	const validationEvents = [];
-	for (const entry of json) {
-		const parsed = azureEventGridEventSchema.safeParse(entry);
-		if (!parsed.success) throw new SnowflakeWebhookVerificationError({
-			message: `Event Grid event failed schema validation: ${parsed.error.message}`,
-			reason: "schema",
-			provider: "azure-blob",
-			cause: parsed.error
-		});
-		const event = parsed.data;
-		events.push(event);
-		if (event.eventType === EVENT_GRID_VALIDATION_EVENT_TYPE) {
-			const data = event.data;
-			if (typeof data.validationCode === "string") validationEvents.push({
-				event,
-				data: {
-					validationCode: data.validationCode,
-					...typeof data.validationUrl === "string" ? { validationUrl: data.validationUrl } : {}
-				}
-			});
-		}
-	}
-	return {
-		events,
-		validationEvents
-	};
-}
-/**
-* Verify an Event Grid request. Event Grid's trust model is
-* primarily the delivery handshake + network ACLs, but operators can
-* wire a shared secret into a custom header. This verifier:
-*
-*  - Checks the shared secret (if configured on both ends).
-*  - Parses + schema-validates the event batch.
-*  - Optionally enforces a topic-ARN pin.
-*/
-function verifyEventGridRequest(input, options = {}) {
-	const batch = parseEventGridBatch(input.rawBody);
-	if (options.sharedSecret) {
-		const headerName = options.sharedSecretHeader ?? "aeg-subscription-secret";
-		if (readHeader(input.headers, headerName) !== options.sharedSecret) throw new SnowflakeWebhookVerificationError({
-			message: `Event Grid shared-secret header ${headerName} did not match.`,
-			reason: "shared-secret",
-			provider: "azure-blob"
-		});
-	}
-	if (options.expectedTopic) {
-		for (const event of batch.events) if (event.topic && event.topic !== options.expectedTopic) throw new SnowflakeWebhookVerificationError({
-			message: `Event Grid topic ${event.topic} != expected ${options.expectedTopic}.`,
-			reason: "topic",
-			provider: "azure-blob"
-		});
-	}
-	return batch;
-}
-const s3EventRecordSchema = z.object({
-	eventTime: z.string().optional(),
-	eventName: z.string().optional(),
-	awsRegion: z.string().optional(),
-	requestParameters: z.object({ sourceIPAddress: z.string().optional() }).catchall(z.unknown()).optional(),
-	s3: z.object({
-		bucket: z.object({ name: z.string() }).catchall(z.unknown()).optional(),
-		object: z.object({
-			key: z.string().optional(),
-			size: z.number().optional(),
-			eTag: z.string().optional(),
-			sequencer: z.string().optional()
-		}).catchall(z.unknown()).optional()
-	}).catchall(z.unknown()).optional()
-}).catchall(z.unknown());
-const s3EventEnvelopeSchema = z.object({ Records: z.array(s3EventRecordSchema) }).catchall(z.unknown());
-/**
-* Extract S3 object events out of the inner {@link SnsNotification}
-* message body. SNS forwards the verbatim S3 notification JSON in
-* `Message`.
-*/
-function extractS3Records(snsMessage) {
-	if (snsMessage.Type !== "Notification") return [];
-	let inner;
-	try {
-		inner = JSON.parse(snsMessage.Message);
-	} catch {
-		return [];
-	}
-	const parsed = s3EventEnvelopeSchema.safeParse(inner);
-	if (!parsed.success) return [];
-	return parsed.data.Records;
-}
-const gcsObjectPayloadSchema = z.object({
-	bucket: z.string().optional(),
-	name: z.string().optional(),
-	size: z.union([z.string(), z.number()]).optional(),
-	etag: z.string().optional(),
-	generation: z.string().optional(),
-	timeCreated: z.string().optional(),
-	updated: z.string().optional()
-}).catchall(z.unknown());
-/**
-* Decode + validate the inner GCS object payload from a Pub/Sub push.
-* Returns `undefined` if the `message.data` field is missing or the
-* decoded body does not shape-match a GCS Object Change notification.
-*/
-function extractGcsObjectPayload(push) {
-	const encoded = push.message.data;
-	if (typeof encoded !== "string" || encoded.length === 0) return void 0;
-	let json;
-	try {
-		json = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
-	} catch {
-		return;
-	}
-	const parsed = gcsObjectPayloadSchema.safeParse(json);
-	return parsed.success ? parsed.data : void 0;
-}
-const azureBlobDataSchema = z.object({
-	api: z.string().optional(),
-	blobType: z.string().optional(),
-	contentLength: z.number().optional(),
-	contentType: z.string().optional(),
-	eTag: z.string().optional(),
-	url: z.string().optional(),
-	sequencer: z.string().optional(),
-	storageDiagnostics: z.unknown().optional()
-}).catchall(z.unknown());
-/**
-* Extract `bucket` + `key` from the `url` or `subject` fields of an
-* Event Grid blob event. Event Grid populates `subject` as
-* `/blobServices/default/containers/<container>/blobs/<key>` so we can
-* parse either.
-*/
-function parseAzureBlobLocation(event) {
-	const subject = event.subject ?? "";
-	const match = subject.match(/\/containers\/([^/]+)\/blobs\/(.+)$/u);
-	if (match?.[1] && match[2]) return {
-		bucket: match[1],
-		key: match[2]
-	};
-	const data = azureBlobDataSchema.safeParse(event.data);
-	if (data.success && typeof data.data.url === "string") try {
-		const parts = new URL(data.data.url).pathname.replace(/^\//u, "").split("/");
-		if (parts.length >= 2) {
-			const [container, ...rest] = parts;
-			return {
-				bucket: container ?? "",
-				key: rest.join("/")
-			};
-		}
-	} catch {}
-	return {
-		bucket: "",
-		key: subject
-	};
-}
-
-//#endregion
-export { EVENT_GRID_VALIDATION_EVENT_TYPE, SnowflakeWebhookVerificationError, canonicalSnsString, extractGcsObjectPayload, extractS3Records, parseAzureBlobLocation, parseEventGridBatch, parsePubSubPush, parseSnsNotification, verifyEventGridRequest, verifyPubSubPushAuthorization, verifySnsMessage };

package/dist/views/index.d.mts

@@ -1,2 +0,0 @@
-import { CatalogResult, ShowMaterializedViewsOptions, ShowViewsOptions, showMaterializedViews, showViews } from "../catalog/index.mjs";
-export { type CatalogResult, type ShowMaterializedViewsOptions, type ShowViewsOptions, showMaterializedViews, showViews };

package/dist/views/index.mjs

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

package/dist/warehouses/index.d.mts

@@ -1,68 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow } from "../statements-DJL0qVNA.mjs";
-import { t as OptionMap } from "../sql-options-2k5xQ-oS.mjs";
-import { CatalogResult, ShowOptions, showWarehouses } from "../catalog/index.mjs";
-
-//#region src/warehouses/index.d.ts
-interface WarehouseContext {
-  readonly warehouse?: string;
-  readonly role?: string;
-}
-interface CreateWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-  readonly orReplace?: boolean;
-  readonly ifNotExists?: boolean;
-  /** `WAREHOUSE_SIZE = 'X-SMALL'`, `AUTO_SUSPEND = 60`, `AUTO_RESUME = TRUE`, etc. */
-  readonly options?: OptionMap;
-  readonly comment?: string;
-}
-declare function createWarehouse(client: SnowflakeClient, options: CreateWarehouseOptions): Promise<void>;
-interface AlterWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-  readonly rename?: string;
-  readonly set?: OptionMap;
-  readonly unset?: readonly string[];
-  readonly comment?: string;
-  readonly ifExists?: boolean;
-}
-declare function alterWarehouse(client: SnowflakeClient, options: AlterWarehouseOptions): Promise<void>;
-interface DropWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-  readonly ifExists?: boolean;
-}
-declare function dropWarehouse(client: SnowflakeClient, options: DropWarehouseOptions): Promise<void>;
-interface ResumeWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-  readonly ifSuspended?: boolean;
-}
-declare function resumeWarehouse(client: SnowflakeClient, options: ResumeWarehouseOptions): Promise<void>;
-interface SuspendWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-}
-declare function suspendWarehouse(client: SnowflakeClient, options: SuspendWarehouseOptions): Promise<void>;
-interface DescribeWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-}
-declare function describeWarehouse(client: SnowflakeClient, options: DescribeWarehouseOptions): Promise<readonly HydratedRow[]>;
-interface UseWarehouseOptions extends WarehouseContext {
-  readonly name: string;
-}
-declare function useWarehouse(client: SnowflakeClient, options: UseWarehouseOptions): Promise<void>;
-interface WarehouseHistoryOptions extends WarehouseContext {
-  readonly warehouseName?: string;
-  /** ISO-8601 timestamp (passed to `TO_TIMESTAMP_LTZ`). */
-  readonly startTime?: string;
-  readonly endTime?: string;
-}
-/**
- * `TABLE(INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY(...))` — queued / running
- * load metrics for a single warehouse.
- */
-declare function warehouseLoadHistory(client: SnowflakeClient, options?: WarehouseHistoryOptions): Promise<readonly HydratedRow[]>;
-/**
- * `TABLE(INFORMATION_SCHEMA.WAREHOUSE_METERING_HISTORY(...))` — credit usage
- * broken out by hour.
- */
-declare function warehouseMeteringHistory(client: SnowflakeClient, options?: WarehouseHistoryOptions): Promise<readonly HydratedRow[]>;
-//#endregion
-export { AlterWarehouseOptions, type CatalogResult, CreateWarehouseOptions, DescribeWarehouseOptions, DropWarehouseOptions, ResumeWarehouseOptions, type ShowOptions, SuspendWarehouseOptions, UseWarehouseOptions, WarehouseContext, WarehouseHistoryOptions, alterWarehouse, createWarehouse, describeWarehouse, dropWarehouse, resumeWarehouse, showWarehouses, suspendWarehouse, useWarehouse, warehouseLoadHistory, warehouseMeteringHistory };

package/dist/warehouses/index.mjs

@@ -1,101 +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 { showWarehouses } from "../catalog/index.mjs";
-
-//#region src/warehouses/index.ts
-async function createWarehouse(client, options) {
-	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""} WAREHOUSE${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.role
-	});
-}
-async function alterWarehouse(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("alterWarehouse requires one of: rename / set / unset / comment");
-	await executeSql(client, {
-		statement: `ALTER WAREHOUSE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)} ${tail}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function dropWarehouse(client, options) {
-	await executeSql(client, {
-		statement: `DROP WAREHOUSE${options.ifExists ? " IF EXISTS" : ""} ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function resumeWarehouse(client, options) {
-	const suffix = options.ifSuspended ? " IF SUSPENDED" : "";
-	await executeSql(client, {
-		statement: `ALTER WAREHOUSE ${quoteIdentifier(options.name)} RESUME${suffix}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function suspendWarehouse(client, options) {
-	await executeSql(client, {
-		statement: `ALTER WAREHOUSE ${quoteIdentifier(options.name)} SUSPEND`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function describeWarehouse(client, options) {
-	return (await executeSql(client, {
-		statement: `DESCRIBE WAREHOUSE ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-async function useWarehouse(client, options) {
-	await executeSql(client, {
-		statement: `USE WAREHOUSE ${quoteIdentifier(options.name)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-function renderTimestampArg(value) {
-	return value ? `TO_TIMESTAMP_LTZ(${quoteLiteral(value)})` : "NULL";
-}
-/**
-* `TABLE(INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY(...))` — queued / running
-* load metrics for a single warehouse.
-*/
-async function warehouseLoadHistory(client, options = {}) {
-	const args = [];
-	if (options.startTime !== void 0) args.push(`DATE_RANGE_START => ${renderTimestampArg(options.startTime)}`);
-	if (options.endTime !== void 0) args.push(`DATE_RANGE_END => ${renderTimestampArg(options.endTime)}`);
-	if (options.warehouseName) args.push(`WAREHOUSE_NAME => ${quoteLiteral(options.warehouseName)}`);
-	return (await executeSql(client, {
-		statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY(${args.join(", ")}))`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-/**
-* `TABLE(INFORMATION_SCHEMA.WAREHOUSE_METERING_HISTORY(...))` — credit usage
-* broken out by hour.
-*/
-async function warehouseMeteringHistory(client, options = {}) {
-	const args = [];
-	if (options.startTime !== void 0) args.push(`DATE_RANGE_START => ${renderTimestampArg(options.startTime)}`);
-	if (options.endTime !== void 0) args.push(`DATE_RANGE_END => ${renderTimestampArg(options.endTime)}`);
-	if (options.warehouseName) args.push(`WAREHOUSE_NAME => ${quoteLiteral(options.warehouseName)}`);
-	return (await executeSql(client, {
-		statement: `SELECT * FROM TABLE(INFORMATION_SCHEMA.WAREHOUSE_METERING_HISTORY(${args.join(", ")}))`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-
-//#endregion
-export { alterWarehouse, createWarehouse, describeWarehouse, dropWarehouse, resumeWarehouse, showWarehouses, suspendWarehouse, useWarehouse, warehouseLoadHistory, warehouseMeteringHistory };