@malloy-publisher/server 0.0.192 → 0.0.193

package/src/service/project_store.spec.ts

@@ -337,6 +337,78 @@ describe("ProjectStore Service", () => {
       expect(projects.map((p) => p.name)).toContain(projectName2);
    });
 
+   it("should skip a project with invalid startup connection config", async () => {
+      const validProjectName = "valid-project";
+      const invalidProjectName = "invalid-motherduck-project";
+      const validProjectPath = path.join(serverRootPath, validProjectName);
+      const invalidProjectPath = path.join(serverRootPath, invalidProjectName);
+
+      mkdirSync(validProjectPath, { recursive: true });
+      mkdirSync(invalidProjectPath, { recursive: true });
+      writeFileSync(
+         path.join(validProjectPath, "publisher.json"),
+         JSON.stringify({
+            name: validProjectName,
+            description: "Valid project",
+         }),
+      );
+      writeFileSync(
+         path.join(invalidProjectPath, "publisher.json"),
+         JSON.stringify({
+            name: invalidProjectName,
+            description: "Invalid project",
+         }),
+      );
+
+      const publisherConfigPath = path.join(
+         serverRootPath,
+         "publisher.config.json",
+      );
+      writeFileSync(
+         publisherConfigPath,
+         JSON.stringify({
+            frozenConfig: false,
+            projects: [
+               {
+                  name: invalidProjectName,
+                  packages: [
+                     {
+                        name: invalidProjectName,
+                        location: invalidProjectPath,
+                     },
+                  ],
+                  connections: [
+                     {
+                        name: "motherduck",
+                        type: "motherduck",
+                        motherduckConnection: {},
+                     },
+                  ],
+               },
+               {
+                  name: validProjectName,
+                  packages: [
+                     {
+                        name: validProjectName,
+                        location: validProjectPath,
+                     },
+                  ],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      const newProjectStore = new ProjectStore(serverRootPath);
+      await newProjectStore.finishedInitialization;
+
+      const projects = await newProjectStore.listProjects();
+      expect(projects.map((p) => p.name)).toEqual([validProjectName]);
+      await expect(
+         newProjectStore.getProject(invalidProjectName),
+      ).rejects.toThrow();
+   });
+
    it("should handle project updates", async () => {
       // Create a project directory
       const projectPath = path.join(serverRootPath, projectName);

package/src/service/project_store.ts

@@ -117,6 +117,33 @@ export class ProjectStore {
       this.finishedInitialization = this.initialize();
    }
 
+   private async addConfiguredProject(project: ProcessedProject) {
+      try {
+         await this.addProject(
+            {
+               name: project.name,
+               resource: `${API_PREFIX}/projects/${project.name}`,
+               connections: project.connections,
+               packages: project.packages,
+            },
+            true,
+         );
+      } catch (error) {
+         this.logProjectInitializationError(project.name, error);
+      }
+   }
+
+   private logProjectInitializationError(
+      projectName: string | undefined,
+      error: unknown,
+   ) {
+      const label = projectName ? ` "${projectName}"` : "";
+      logger.error(
+         `Error initializing project${label}; skipping project`,
+         this.extractErrorDataFromError(error),
+      );
+   }
+
    private async initialize() {
       const reInit = process.env.INITIALIZE_STORAGE === "true";
       const initialTime = performance.now();
@@ -140,15 +167,7 @@ export class ProjectStore {
             // Load projects from config file
             await Promise.all(
                projectManifest.projects.map(async (project) => {
-                  await this.addProject(
-                     {
-                        name: project.name,
-                        resource: `${API_PREFIX}/projects/${project.name}`,
-                        connections: project.connections,
-                        packages: project.packages,
-                     },
-                     true,
-                  );
+                  await this.addConfiguredProject(project);
                }),
             );
          } else {
@@ -159,88 +178,87 @@ export class ProjectStore {
                // Load projects from database
                await Promise.all(
                   existingProjects.map(async (dbProject) => {
-                     // Check if project files exist on disk
-                     const projectExists = await fs.promises
-                        .access(dbProject.path)
-                        .then(() => true)
-                        .catch(() => false);
-
-                     if (!projectExists) {
-                        // Try to find in config and reload
-                        const projectConfig = projectManifest.projects.find(
-                           (p) => p.name === dbProject.name,
-                        );
-
-                        if (projectConfig) {
-                           const projectInstance = await this.addProject(
-                              {
-                                 name: projectConfig.name,
-                                 resource: `${API_PREFIX}/projects/${projectConfig.name}`,
-                                 connections: projectConfig.connections,
-                                 packages: projectConfig.packages,
-                              },
-                              true,
+                     try {
+                        // Check if project files exist on disk
+                        const projectExists = await fs.promises
+                           .access(dbProject.path)
+                           .then(() => true)
+                           .catch(() => false);
+
+                        if (!projectExists) {
+                           // Try to find in config and reload
+                           const projectConfig = projectManifest.projects.find(
+                              (p) => p.name === dbProject.name,
                            );
 
-                           // Update database with new path
-                           await repository.updateProject(dbProject.id, {
-                              path: projectInstance.metadata.location,
-                           });
-
-                           return projectInstance.listPackages();
-                        } else {
-                           logger.error(
-                              `Project "${dbProject.name}" not found in config and files missing`,
-                           );
-                           return;
+                           if (projectConfig) {
+                              const projectInstance = await this.addProject(
+                                 {
+                                    name: projectConfig.name,
+                                    resource: `${API_PREFIX}/projects/${projectConfig.name}`,
+                                    connections: projectConfig.connections,
+                                    packages: projectConfig.packages,
+                                 },
+                                 true,
+                              );
+
+                              // Update database with new path
+                              await repository.updateProject(dbProject.id, {
+                                 path: projectInstance.metadata.location,
+                              });
+
+                              return projectInstance.listPackages();
+                           } else {
+                              logger.error(
+                                 `Project "${dbProject.name}" not found in config and files missing`,
+                              );
+                              return;
+                           }
                         }
-                     }
 
-                     // Get connections from database
-                     const connections = await repository.listConnections(
-                        dbProject.id,
-                     );
-
-                     const projectInstance = await Project.create(
-                        dbProject.name,
-                        dbProject.path,
-                        connections.map((conn) => ({
-                           name: conn.name,
-                           type: conn.type,
-                           resource: `${API_PREFIX}/connections/${conn.name}`,
-                           ...conn.config,
-                        })),
-                     );
-
-                     this.projects.set(dbProject.name, projectInstance);
-
-                     // Get packages from database
-                     const packages = await repository.listPackages(
-                        dbProject.id,
-                     );
-                     packages.forEach((pkg) => {
-                        projectInstance.setPackageStatus(
-                           pkg.name,
-                           PackageStatus.SERVING,
+                        // Get connections from database
+                        const connections = await repository.listConnections(
+                           dbProject.id,
+                        );
+
+                        const projectInstance = await Project.create(
+                           dbProject.name,
+                           dbProject.path,
+                           connections.map((conn) => ({
+                              name: conn.name,
+                              type: conn.type,
+                              resource: `${API_PREFIX}/connections/${conn.name}`,
+                              ...conn.config,
+                           })),
                         );
-                     });
 
-                     return projectInstance.listPackages();
+                        // Get packages from database
+                        const packages = await repository.listPackages(
+                           dbProject.id,
+                        );
+                        packages.forEach((pkg) => {
+                           projectInstance.setPackageStatus(
+                              pkg.name,
+                              PackageStatus.SERVING,
+                           );
+                        });
+
+                        this.projects.set(dbProject.name, projectInstance);
+
+                        return projectInstance.listPackages();
+                     } catch (error) {
+                        this.logProjectInitializationError(
+                           dbProject.name,
+                           error,
+                        );
+                     }
                   }),
                );
             } else {
                // Fallback to config file if database is empty
                await Promise.all(
                   projectManifest.projects.map(async (project) => {
-                     await this.addProject(
-                        {
-                           name: project.name,
-                           resource: `${API_PREFIX}/projects/${project.name}`,
-                           connections: project.connections,
-                           packages: project.packages,
-                        },
-                        true,
-                     );
+                     await this.addConfiguredProject(project);
                   }),
                );
             }
@@ -256,7 +274,6 @@ export class ProjectStore {
          markNotReady();
          const errorData = this.extractErrorDataFromError(error);
          logger.error("Error initializing project store", errorData);
-         process.exit(1);
       }
    }
 
@@ -856,7 +873,7 @@ export class ProjectStore {
       const projectPath = project.metadata?.location;
 
       // Close all connections before removing the project
-      project.closeAllConnections();
+      await project.closeAllConnections();
 
       this.projects.delete(projectName);
       await this.deleteProjectFromDatabase(projectName);

package/tests/unit/duckdb/attached_databases.test.ts

@@ -838,7 +838,7 @@ describe("createProjectConnections - DuckDB", () => {
          await expect(
             createProjectConnections(connections, PROJECT_TEST_DIR),
          ).rejects.toThrow(
-            "DuckDB attached databases names cannot conflict with connection name",
+            "DuckDB attached database names cannot conflict with connection name",
          );
       });
 
@@ -888,24 +888,6 @@ describe("createProjectConnections - DuckDB", () => {
          ).rejects.toThrow("DuckDB connection name cannot be 'duckdb'");
       });
 
-      it("should throw when DuckDB connection has no attached databases", async () => {
-         const connections: ApiConnection[] = [
-            {
-               name: "no_attached_db",
-               type: "duckdb",
-               duckdbConnection: {
-                  attachedDatabases: [],
-               },
-            },
-         ];
-
-         await expect(
-            createProjectConnections(connections, PROJECT_TEST_DIR),
-         ).rejects.toThrow(
-            "DuckDB connection must have at least one attached database",
-         );
-      });
-
       it("should throw on unsupported connection type", async () => {
          const connections = [
             {