@malloy-publisher/server 0.0.194 → 0.0.195

package/dist/server.mjs

@@ -220381,6 +220381,7 @@ import fs from "fs/promises";
 import path2 from "path";
 
 // src/service/connection_config.ts
+import { createPrivateKey } from "crypto";
 import path from "path";
 var PUBLISHER_DUCKDB_API_FIELDS = new Set(["attachedDatabases"]);
 function normalizeSnowflakePrivateKey(privateKey) {
@@ -220399,6 +220400,12 @@ function normalizeSnowflakePrivateKey(privateKey) {
         endRegex: /-----END\s+PRIVATE\s+KEY-----/i,
         beginMarker: "-----BEGIN PRIVATE KEY-----",
         endMarker: "-----END PRIVATE KEY-----"
+      },
+      {
+        beginRegex: /-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i,
+        endRegex: /-----END\s+RSA\s+PRIVATE\s+KEY-----/i,
+        beginMarker: "-----BEGIN RSA PRIVATE KEY-----",
+        endMarker: "-----END RSA PRIVATE KEY-----"
       }
     ];
     for (const pattern of keyPatterns) {
@@ -220425,6 +220432,21 @@ ${pattern.endMarker}
     privateKeyContent += `
 `;
   }
+  if (/-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i.test(privateKeyContent)) {
+    try {
+      privateKeyContent = createPrivateKey({
+        key: privateKeyContent,
+        format: "pem"
+      }).export({ type: "pkcs8", format: "pem" }).toString();
+    } catch (err) {
+      throw new Error(`Failed to convert Snowflake RSA private key (PKCS#1) to PKCS#8: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!privateKeyContent.endsWith(`
+`)) {
+      privateKeyContent += `
+`;
+    }
+  }
   return privateKeyContent;
 }
 function validateDuckdbApiSurface(connection) {
@@ -231556,6 +231578,9 @@ class Project {
       this.metadata.readme = payload.readme;
       await this.writeProjectReadme(payload.readme);
     }
+    if (payload.materializationStorage !== undefined) {
+      this.metadata.materializationStorage = payload.materializationStorage;
+    }
     if (payload.connections) {
       const payloadConnections = payload.connections;
       await this.runConnectionUpdateExclusive(async () => {
@@ -232407,6 +232432,9 @@ class ProjectStore {
     if (!newProject.metadata)
       newProject.metadata = {};
     newProject.metadata.location = absoluteProjectPath;
+    if (project.materializationStorage !== undefined) {
+      newProject.metadata.materializationStorage = project.materializationStorage;
+    }
     this.projects.set(projectName, newProject);
     project?.packages?.forEach((_package) => {
       if (_package.name) {

package/package.json

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

package/src/service/connection_config.spec.ts

@@ -1,5 +1,9 @@
+import { generateKeyPairSync } from "crypto";
 import { describe, expect, it } from "bun:test";
-import { assembleProjectConnections } from "./connection_config";
+import {
+   assembleProjectConnections,
+   normalizeSnowflakePrivateKey,
+} from "./connection_config";
 import { components } from "../api";
 
 type ApiConnection = components["schemas"]["Connection"];
@@ -121,3 +125,44 @@ describe("assembleProjectConnections — databricks", () => {
       );
    });
 });
+
+describe("normalizeSnowflakePrivateKey", () => {
+   const { privateKey: pkcs8Pem } = generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      privateKeyEncoding: { type: "pkcs8", format: "pem" },
+      publicKeyEncoding: { type: "spki", format: "pem" },
+   });
+   const { privateKey: pkcs1Pem } = generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      privateKeyEncoding: { type: "pkcs1", format: "pem" },
+      publicKeyEncoding: { type: "pkcs1", format: "pem" },
+   });
+
+   it("passes a multi-line PKCS#8 key through and adds a trailing newline", () => {
+      const trimmed = (pkcs8Pem as string).trimEnd();
+      const result = normalizeSnowflakePrivateKey(trimmed);
+      expect(result).toContain("-----BEGIN PRIVATE KEY-----");
+      expect(result.endsWith("\n")).toBe(true);
+   });
+
+   it("converts a multi-line PKCS#1 RSA key to PKCS#8", () => {
+      const result = normalizeSnowflakePrivateKey(pkcs1Pem as string);
+      expect(result).toContain("-----BEGIN PRIVATE KEY-----");
+      expect(result).not.toContain("BEGIN RSA PRIVATE KEY");
+      expect(result.endsWith("\n")).toBe(true);
+   });
+
+   it("converts a single-line PKCS#1 RSA key to PKCS#8", () => {
+      const singleLine = (pkcs1Pem as string).replace(/\n/g, "");
+      const result = normalizeSnowflakePrivateKey(singleLine);
+      expect(result).toContain("-----BEGIN PRIVATE KEY-----");
+      expect(result).not.toContain("BEGIN RSA PRIVATE KEY");
+   });
+
+   it("reconstructs a single-line PKCS#8 key without conversion", () => {
+      const singleLine = (pkcs8Pem as string).replace(/\n/g, "");
+      const result = normalizeSnowflakePrivateKey(singleLine);
+      expect(result.startsWith("-----BEGIN PRIVATE KEY-----\n")).toBe(true);
+      expect(result.endsWith("-----END PRIVATE KEY-----\n")).toBe(true);
+   });
+});

package/src/service/connection_config.ts

@@ -1,3 +1,4 @@
+import { createPrivateKey } from "crypto";
 import path from "path";
 import { components } from "../api";
 
@@ -48,6 +49,12 @@ export function normalizeSnowflakePrivateKey(privateKey: string): string {
             beginMarker: "-----BEGIN PRIVATE KEY-----",
             endMarker: "-----END PRIVATE KEY-----",
          },
+         {
+            beginRegex: /-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i,
+            endRegex: /-----END\s+RSA\s+PRIVATE\s+KEY-----/i,
+            beginMarker: "-----BEGIN RSA PRIVATE KEY-----",
+            endMarker: "-----END RSA PRIVATE KEY-----",
+         },
       ];
 
       for (const pattern of keyPatterns) {
@@ -73,6 +80,28 @@ export function normalizeSnowflakePrivateKey(privateKey: string): string {
       privateKeyContent += "\n";
    }
 
+   // Snowflake's Node SDK requires PKCS#8 ("BEGIN PRIVATE KEY"). Convert
+   // PKCS#1 ("BEGIN RSA PRIVATE KEY") so users can paste either format.
+   if (/-----BEGIN\s+RSA\s+PRIVATE\s+KEY-----/i.test(privateKeyContent)) {
+      try {
+         privateKeyContent = createPrivateKey({
+            key: privateKeyContent,
+            format: "pem",
+         })
+            .export({ type: "pkcs8", format: "pem" })
+            .toString();
+      } catch (err) {
+         throw new Error(
+            `Failed to convert Snowflake RSA private key (PKCS#1) to PKCS#8: ${
+               err instanceof Error ? err.message : String(err)
+            }`,
+         );
+      }
+      if (!privateKeyContent.endsWith("\n")) {
+         privateKeyContent += "\n";
+      }
+   }
+
    return privateKeyContent;
 }
 

package/src/service/project.ts

@@ -99,6 +99,10 @@ export class Project {
          await this.writeProjectReadme(payload.readme);
       }
 
+      if (payload.materializationStorage !== undefined) {
+         this.metadata.materializationStorage = payload.materializationStorage;
+      }
+
       // Handle connections update
       // TODO: Update project connections should have its own API endpoint
       if (payload.connections) {

package/src/service/project_store.spec.ts

@@ -10,6 +10,11 @@ import { ProjectStore } from "./project_store";
 
 type MockData = Record<string, unknown>;
 
+const initializeDuckLakeCalls: Array<{
+   projectId: string;
+   config: { catalogUrl: string; dataPath: string };
+}> = [];
+
 mock.module("../storage/StorageManager", () => {
    return {
       StorageManager: class MockStorageManager {
@@ -17,6 +22,13 @@ mock.module("../storage/StorageManager", () => {
             return;
          }
 
+         async initializeDuckLakeForProject(
+            projectId: string,
+            config: { catalogUrl: string; dataPath: string },
+         ): Promise<void> {
+            initializeDuckLakeCalls.push({ projectId, config });
+         }
+
          getRepository() {
             return {
                // ===== PROJECT METHODS =====
@@ -467,6 +479,69 @@ describe("ProjectStore Service", () => {
       expect(readmeContent).toBe("Updated README content");
    });
 
+   it("should propagate materializationStorage on addProject for new project", async () => {
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({ frozenConfig: false, projects: [] }),
+      );
+
+      await projectStore.finishedInitialization;
+
+      const materializationStorage = {
+         catalogUrl:
+            "postgres:host=localhost port=5432 dbname=ducklake user=u password=p",
+         dataPath: "gs://test-bucket",
+      };
+
+      initializeDuckLakeCalls.length = 0;
+      const project = await projectStore.addProject({
+         name: projectName,
+         materializationStorage,
+      });
+
+      expect(project.metadata.materializationStorage).toEqual(
+         materializationStorage,
+      );
+      expect(initializeDuckLakeCalls).toHaveLength(1);
+      expect(initializeDuckLakeCalls[0].config).toEqual(materializationStorage);
+   });
+
+   it("should propagate materializationStorage on update", async () => {
+      const projectPath = path.join(serverRootPath, projectName);
+      mkdirSync(projectPath, { recursive: true });
+      writeFileSync(
+         path.join(projectPath, "publisher.json"),
+         JSON.stringify({ name: projectName, description: "Test package" }),
+      );
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            projects: [
+               {
+                  name: projectName,
+                  packages: [{ name: projectName, location: projectPath }],
+               },
+            ],
+         }),
+      );
+
+      await projectStore.finishedInitialization;
+      const project = await projectStore.getProject(projectName);
+
+      const materializationStorage = {
+         catalogUrl:
+            "postgres:host=localhost port=5432 dbname=ducklake user=u password=p",
+         dataPath: "gs://test-bucket",
+      };
+
+      await project.update({ name: projectName, materializationStorage });
+
+      expect(project.metadata.materializationStorage).toEqual(
+         materializationStorage,
+      );
+   });
+
    it(
       "should handle project reload",
       async () => {

package/src/service/project_store.ts

@@ -807,6 +807,10 @@ export class ProjectStore {
 
       if (!newProject.metadata) newProject.metadata = {};
       newProject.metadata.location = absoluteProjectPath;
+      if (project.materializationStorage !== undefined) {
+         newProject.metadata.materializationStorage =
+            project.materializationStorage;
+      }
 
       this.projects.set(projectName, newProject);