@malloy-publisher/server 0.0.242 → 0.0.243

package/dist/app/api-doc.yaml

@@ -4141,25 +4141,31 @@ components:
           type: string
           description: Snowflake username for authentication
         password:
-          type: string
+          type: ["string", "null"]
           description: Snowflake password for authentication
         privateKey:
           type: string
           description: Snowflake private key for authentication
         privateKeyPass:
-          type: string
+          type: ["string", "null"]
           description: Passphrase for the Snowflake private key
         warehouse:
           type: string
           description: Snowflake warehouse name
         database:
-          type: string
-          description: Snowflake database name
+          type: ["string", "null"]
+          description:
+            Snowflake database name. Omitted or null connects with no current
+            database, so names must be fully qualified as
+            DATABASE.SCHEMA.TABLE and schema discovery spans the account.
         schema:
-          type: string
-          description: Snowflake schema name
+          type: ["string", "null"]
+          description:
+            Snowflake schema name. Sets the session default schema and forms part
+            of the connection's identity, so it determines what a materialization
+            build runs as. It does not restrict which schemas are discoverable.
         role:
-          type: string
+          type: ["string", "null"]
           description: Snowflake role name
         responseTimeoutMilliseconds:
           type: integer

package/dist/server.mjs

@@ -265609,6 +265609,9 @@ var PROXIED_SSLMODES = [
   "verify-full"
 ];
 var PUBLISHER_DUCKDB_API_FIELDS = new Set(["attachedDatabases"]);
+function nullToUndefined(value) {
+  return value ?? undefined;
+}
 function normalizeSnowflakePrivateKey(privateKey) {
   let privateKeyContent = privateKey.trim();
   if (!privateKeyContent.includes(`
@@ -266129,13 +266132,13 @@ function assembleEnvironmentConnections(connections = [], environmentPath = "")
           is: "snowflake",
           account: connection.snowflakeConnection?.account,
           username: connection.snowflakeConnection?.username,
-          password: connection.snowflakeConnection?.password,
+          password: nullToUndefined(connection.snowflakeConnection?.password),
           privateKey: connection.snowflakeConnection?.privateKey ? normalizeSnowflakePrivateKey(connection.snowflakeConnection.privateKey) : undefined,
-          privateKeyPass: connection.snowflakeConnection?.privateKeyPass,
+          privateKeyPass: nullToUndefined(connection.snowflakeConnection?.privateKeyPass),
           warehouse: connection.snowflakeConnection?.warehouse,
-          database: connection.snowflakeConnection?.database,
-          schema: connection.snowflakeConnection?.schema,
-          role: connection.snowflakeConnection?.role,
+          database: nullToUndefined(connection.snowflakeConnection?.database),
+          schema: nullToUndefined(connection.snowflakeConnection?.schema),
+          role: nullToUndefined(connection.snowflakeConnection?.role),
           timeoutMs: connection.snowflakeConnection?.responseTimeoutMilliseconds,
           poolMin: 1,
           poolMax: 20
@@ -266657,32 +266660,44 @@ async function federateSnowflake(connection, config) {
   if (!sf) {
     throw new Error(`Snowflake connection configuration missing for: ${config.name}`);
   }
-  const required = {
+  for (const [field, value] of Object.entries({
     account: sf.account,
-    username: sf.username,
-    password: sf.password
-  };
-  for (const [field, value] of Object.entries(required)) {
+    username: sf.username
+  })) {
     if (!value) {
       throw new Error(`Snowflake ${field} is required for: ${config.name}`);
     }
   }
+  const usesKeyPair = !!sf.privateKey;
+  if (!usesKeyPair && !sf.password) {
+    throw new Error(`Snowflake privateKey or password is required for: ${config.name}`);
+  }
   await installAndLoadExtension(connection, "snowflake", true);
   const params = {
     account: escapeSQL(sf.account || ""),
     user: escapeSQL(sf.username || ""),
-    password: escapeSQL(sf.password || ""),
+    password: sf.password ? escapeSQL(sf.password) : undefined,
+    privateKey: sf.privateKey ? escapeSQL(normalizeSnowflakePrivateKey(sf.privateKey)) : undefined,
+    privateKeyPass: sf.privateKeyPass ? escapeSQL(sf.privateKeyPass) : undefined,
     database: sf.database ? escapeSQL(sf.database) : undefined,
-    warehouse: sf.warehouse ? escapeSQL(sf.warehouse) : undefined
+    warehouse: sf.warehouse ? escapeSQL(sf.warehouse) : undefined,
+    schema: sf.schema ? escapeSQL(sf.schema) : undefined,
+    role: sf.role ? escapeSQL(sf.role) : undefined
   };
   const secretName = sanitizeSecretName(`snowflake_${config.name}`);
   const secretLines = [
     `   TYPE snowflake`,
     `   ACCOUNT '${params.account}'`,
     `   USER '${params.user}'`,
-    `   PASSWORD '${params.password}'`,
+    ...usesKeyPair ? [
+      `   AUTH_TYPE 'key_pair'`,
+      `   PRIVATE_KEY '${params.privateKey}'`,
+      ...params.privateKeyPass ? [`   PRIVATE_KEY_PASSWORD '${params.privateKeyPass}'`] : []
+    ] : [`   PASSWORD '${params.password}'`],
     ...params.database ? [`   DATABASE '${params.database}'`] : [],
-    ...params.warehouse ? [`   WAREHOUSE '${params.warehouse}'`] : []
+    ...params.warehouse ? [`   WAREHOUSE '${params.warehouse}'`] : [],
+    ...params.schema ? [`   SCHEMA '${params.schema}'`] : [],
+    ...params.role ? [`   ROLE '${params.role}'`] : []
   ];
   await connection.runSQL(`CREATE OR REPLACE SECRET ${secretName} (
 ${secretLines.join(`,
@@ -267004,7 +267019,7 @@ function entryToDuckDBOptions(name, entry, workingDirectory) {
   return { ...removeUndefined(rest), name };
 }
 function removeUndefined(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== undefined));
+  return Object.fromEntries(Object.entries(value).filter(([, fieldValue]) => fieldValue !== undefined && fieldValue !== null));
 }
 function buildSnowflakePrivateKeyConnection(metadata) {
   const name = metadata.apiConnection.name;
@@ -267905,6 +267920,52 @@ async function getSchemasForMySQL(connection) {
     }
   ];
 }
+var SNOWFLAKE_SYSTEM_DATABASES = new Set([
+  "SNOWFLAKE",
+  "SNOWFLAKE_SAMPLE_DATA"
+]);
+async function listSnowflakeSchemasInDatabase(connection, malloyConnection, database, schema) {
+  const filters = [
+    `CATALOG_NAME = '${sqlLiteral(database, connection.type)}'`
+  ];
+  if (schema) {
+    filters.push(`SCHEMA_NAME = '${sqlLiteral(schema, connection.type)}'`);
+  }
+  assertSafeSqlIdentifier(database, "database name");
+  const result = await runIntrospectionSQL(malloyConnection, `SELECT CATALOG_NAME, SCHEMA_NAME, SCHEMA_OWNER FROM ${database}.INFORMATION_SCHEMA.SCHEMATA WHERE ${filters.join(" AND ")} ORDER BY SCHEMA_NAME`);
+  return standardizeRunSQLResult2(result).map((row) => {
+    const r = row;
+    return {
+      catalogName: String(r.CATALOG_NAME ?? r.catalog_name ?? ""),
+      schemaName: String(r.SCHEMA_NAME ?? r.schema_name ?? ""),
+      owner: String(r.SCHEMA_OWNER ?? r.schema_owner ?? "")
+    };
+  });
+}
+var SNOWFLAKE_SHOW_ROW_LIMIT = 1e4;
+async function listSnowflakeSchemasInAccount(malloyConnection) {
+  const result = await runIntrospectionSQL(malloyConnection, `SHOW SCHEMAS IN ACCOUNT LIMIT ${SNOWFLAKE_SHOW_ROW_LIMIT}`);
+  const returnedRows = standardizeRunSQLResult2(result);
+  if (returnedRows.length >= SNOWFLAKE_SHOW_ROW_LIMIT) {
+    logger.warn("Snowflake account-wide schema listing hit the SHOW row limit; the schema list is incomplete and some tables will not be discoverable", {
+      rowLimit: SNOWFLAKE_SHOW_ROW_LIMIT,
+      returnedRows: returnedRows.length
+    });
+  }
+  const parsed = returnedRows.map((row) => {
+    const r = row;
+    return {
+      catalogName: String(r.database_name ?? r.DATABASE_NAME ?? ""),
+      schemaName: String(r.name ?? r.NAME ?? ""),
+      owner: String(r.owner ?? r.OWNER ?? "")
+    };
+  });
+  const usable = parsed.filter((r) => r.catalogName && r.schemaName);
+  if (usable.length < parsed.length) {
+    logger.warn("Dropped Snowflake schema rows missing a database or schema name; the schema list is incomplete", { dropped: parsed.length - usable.length, returned: parsed.length });
+  }
+  return usable.sort((a, b) => a.catalogName.localeCompare(b.catalogName) || a.schemaName.localeCompare(b.schemaName));
+}
 async function getSchemasForSnowflake(connection, malloyConnection) {
   if (!connection.snowflakeConnection) {
     throw new Error("Snowflake connection is required");
@@ -267912,28 +267973,15 @@ async function getSchemasForSnowflake(connection, malloyConnection) {
   try {
     const database = connection.snowflakeConnection.database;
     const schema = connection.snowflakeConnection.schema;
-    const filters = [];
-    if (database) {
-      filters.push(`CATALOG_NAME = '${sqlLiteral(database, connection.type)}'`);
-    }
-    if (schema) {
-      filters.push(`SCHEMA_NAME = '${sqlLiteral(schema, connection.type)}'`);
-    }
-    const whereClause = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
-    const result = await runIntrospectionSQL(malloyConnection, `SELECT CATALOG_NAME, SCHEMA_NAME, SCHEMA_OWNER FROM ${database ? `${database}.` : ""}INFORMATION_SCHEMA.SCHEMATA ${whereClause} ORDER BY SCHEMA_NAME`);
-    const rows = standardizeRunSQLResult2(result);
-    return rows.map((row) => {
-      const typedRow = row;
-      const catalogName = String(typedRow.CATALOG_NAME ?? typedRow.catalog_name ?? "");
-      const schemaName = String(typedRow.SCHEMA_NAME ?? typedRow.schema_name ?? "");
-      const owner = String(typedRow.SCHEMA_OWNER ?? typedRow.schema_owner ?? "");
-      return {
-        name: `${catalogName}.${schemaName}`,
-        isHidden: ["SNOWFLAKE", ""].includes(owner) || schemaName === "INFORMATION_SCHEMA",
-        isDefault: schema ? schemaName === schema : false
-      };
-    });
+    const rows = database ? await listSnowflakeSchemasInDatabase(connection, malloyConnection, database, schema) : await listSnowflakeSchemasInAccount(malloyConnection);
+    return rows.map(({ catalogName, schemaName, owner }) => ({
+      name: `${catalogName}.${schemaName}`,
+      isHidden: owner === "SNOWFLAKE" || Boolean(database) && owner === "" || schemaName === "INFORMATION_SCHEMA" || !database && SNOWFLAKE_SYSTEM_DATABASES.has(catalogName),
+      isDefault: Boolean(database) && Boolean(schema) && schemaName === schema
+    }));
   } catch (error) {
+    if (error instanceof BadRequestError)
+      throw error;
     logger.error(`Error getting schemas for Snowflake connection ${connection.name}`, { error });
     throw new Error(`Failed to get schemas for Snowflake connection ${connection.name}: ${error.message}`);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.242",
+   "version": "0.0.243",
    "main": "dist/server.mjs",
    "bin": {
       "malloy-publisher": "dist/server.mjs"