@malloy-publisher/server 0.0.196-dev → 0.0.197-dev

package/src/service/{project_store.spec.ts → environment_store.spec.ts}

@@ -5,14 +5,14 @@ import * as sinon from "sinon";
 import { components } from "../api";
 import { isPublisherConfigFrozen } from "../config";
 import { TEMP_DIR_PATH } from "../constants";
-import { Project } from "./project";
-import { ProjectStore } from "./project_store";
+import { Environment } from "./environment";
+import { EnvironmentStore } from "./environment_store";
 
 type MockData = Record<string, unknown>;
 
 const initializeDuckLakeCalls: Array<{
-   projectId: string;
-   projectName: string;
+   environmentId: string;
+   environmentName: string;
    config: { catalogUrl: string; dataPath: string };
 }> = [];
 
@@ -23,20 +23,24 @@ mock.module("../storage/StorageManager", () => {
             return;
          }
 
-         async initializeDuckLakeForProject(
-            projectId: string,
-            projectName: string,
+         async initializeDuckLakeForEnvironment(
+            environmentId: string,
+            environmentName: string,
             config: { catalogUrl: string; dataPath: string },
          ): Promise<void> {
-            initializeDuckLakeCalls.push({ projectId, projectName, config });
+            initializeDuckLakeCalls.push({
+               environmentId,
+               environmentName,
+               config,
+            });
          }
 
          getRepository() {
             return {
                // ===== PROJECT METHODS =====
-               listProjects: async (): Promise<unknown[]> => [],
+               listEnvironments: async (): Promise<unknown[]> => [],
 
-               getProjectById: async (
+               getEnvironmentById: async (
                   id: string,
                ): Promise<MockData | null> => ({
                   id,
@@ -48,14 +52,16 @@ mock.module("../storage/StorageManager", () => {
                   updatedAt: new Date(),
                }),
 
-               getProjectByName: async (
+               getEnvironmentByName: async (
                   _name: string,
                ): Promise<MockData | null> => {
                   // Return null to simulate "project doesn't exist yet"
                   return null;
                },
 
-               createProject: async (data: MockData): Promise<MockData> => ({
+               createEnvironment: async (
+                  data: MockData,
+               ): Promise<MockData> => ({
                   id: "test-project-id",
                   name: data.name,
                   path: data.path,
@@ -65,7 +71,7 @@ mock.module("../storage/StorageManager", () => {
                   updatedAt: new Date(),
                }),
 
-               updateProject: async (
+               updateEnvironment: async (
                   id: string,
                   data: MockData,
                ): Promise<MockData> => ({
@@ -81,18 +87,18 @@ mock.module("../storage/StorageManager", () => {
                   updatedAt: new Date(),
                }),
 
-               deleteProject: async (_id: string): Promise<void> => {},
+               deleteEnvironment: async (_id: string): Promise<void> => {},
 
                // ===== PACKAGE METHODS =====
                listPackages: async (
-                  _projectId: string,
+                  _environmentId: string,
                ): Promise<unknown[]> => [],
 
                getPackageById: async (
                   id: string,
                ): Promise<MockData | null> => ({
                   id,
-                  projectId: "test-project-id",
+                  environmentId: "test-project-id",
                   name: "test-package",
                   description: "Test package",
                   manifestPath: "/test/manifest.json",
@@ -102,13 +108,13 @@ mock.module("../storage/StorageManager", () => {
                }),
 
                getPackageByName: async (
-                  _projectId: string,
+                  _environmentId: string,
                   _name: string,
                ): Promise<MockData | null> => null,
 
                createPackage: async (data: MockData): Promise<MockData> => ({
                   id: "test-package-id",
-                  projectId: data.projectId,
+                  environmentId: data.environmentId,
                   name: data.name,
                   description: data.description,
                   manifestPath: data.manifestPath,
@@ -122,7 +128,7 @@ mock.module("../storage/StorageManager", () => {
                   data: MockData,
                ): Promise<MockData> => ({
                   id,
-                  projectId: "test-project-id",
+                  environmentId: "test-project-id",
                   name: "test-package",
                   description: data.description,
                   manifestPath: "/test/manifest.json",
@@ -135,14 +141,14 @@ mock.module("../storage/StorageManager", () => {
 
                // ===== CONNECTION METHODS =====
                listConnections: async (
-                  _projectId: string,
+                  _environmentId: string,
                ): Promise<unknown[]> => [],
 
                getConnectionById: async (
                   id: string,
                ): Promise<MockData | null> => ({
                   id,
-                  projectId: "test-project-id",
+                  environmentId: "test-project-id",
                   name: "test-connection",
                   type: "postgres",
                   config: {},
@@ -151,13 +157,13 @@ mock.module("../storage/StorageManager", () => {
                }),
 
                getConnectionByName: async (
-                  _projectId: string,
+                  _environmentId: string,
                   _name: string,
                ): Promise<MockData | null> => null,
 
                createConnection: async (data: MockData): Promise<MockData> => ({
                   id: "test-connection-id",
-                  projectId: data.projectId,
+                  environmentId: data.environmentId,
                   name: data.name,
                   type: data.type,
                   config: data.config,
@@ -170,7 +176,7 @@ mock.module("../storage/StorageManager", () => {
                   data: MockData,
                ): Promise<MockData> => ({
                   id,
-                  projectId: "test-project-id",
+                  environmentId: "test-project-id",
                   name: "test-connection",
                   type: "postgres",
                   config: data.config || {},
@@ -196,8 +202,8 @@ const projectName = "organizationName-projectName";
 
 let sandbox: sinon.SinonSandbox;
 
-describe("ProjectStore Service", () => {
-   let projectStore: ProjectStore;
+describe("EnvironmentStore Service", () => {
+   let environmentStore: EnvironmentStore;
 
    beforeEach(async () => {
       // Clean up any existing test directory
@@ -214,7 +220,7 @@ describe("ProjectStore Service", () => {
       }));
 
       // Create project store after mocking
-      projectStore = new ProjectStore(serverRootPath);
+      environmentStore = new EnvironmentStore(serverRootPath);
    });
 
    afterEach(async () => {
@@ -228,7 +234,7 @@ describe("ProjectStore Service", () => {
 
    it("should not load a package if the project does not exist", async () => {
       await expect(
-         projectStore.getProject("non-existent-project"),
+         environmentStore.getEnvironment("non-existent-project"),
       ).rejects.toThrow();
    });
 
@@ -256,7 +262,7 @@ describe("ProjectStore Service", () => {
             publisherConfigPath,
             JSON.stringify({
                frozenConfig: false,
-               projects: [
+               environments: [
                   {
                      name: projectName,
                      packages: [
@@ -277,8 +283,8 @@ describe("ProjectStore Service", () => {
          );
 
          // Test that the project can be retrieved
-         const project = await projectStore.getProject(projectName);
-         expect(project).toBeInstanceOf(Project);
+         const project = await environmentStore.getEnvironment(projectName);
+         expect(project).toBeInstanceOf(Environment);
          expect(project.metadata.name).toBe(projectName);
       },
       { timeout: 30000 },
@@ -303,7 +309,7 @@ describe("ProjectStore Service", () => {
          publisherConfigPath,
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   name: projectName1,
                   packages: [
@@ -340,11 +346,11 @@ describe("ProjectStore Service", () => {
       );
 
       // Create a new project store that will read the configuration
-      const newProjectStore = new ProjectStore(serverRootPath);
-      await newProjectStore.finishedInitialization;
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
 
       // Test that both projects can be listed
-      const projects = await newProjectStore.listProjects();
+      const projects = await newEnvironmentStore.listEnvironments();
       expect(projects).toBeInstanceOf(Array);
       expect(projects.length).toBe(2);
       expect(projects.map((p) => p.name)).toContain(projectName1);
@@ -382,7 +388,7 @@ describe("ProjectStore Service", () => {
          publisherConfigPath,
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   name: invalidProjectName,
                   packages: [
@@ -413,13 +419,13 @@ describe("ProjectStore Service", () => {
          }),
       );
 
-      const newProjectStore = new ProjectStore(serverRootPath);
-      await newProjectStore.finishedInitialization;
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
 
-      const projects = await newProjectStore.listProjects();
+      const projects = await newEnvironmentStore.listEnvironments();
       expect(projects.map((p) => p.name)).toEqual([validProjectName]);
       await expect(
-         newProjectStore.getProject(invalidProjectName),
+         newEnvironmentStore.getEnvironment(invalidProjectName),
       ).rejects.toThrow();
    });
 
@@ -444,7 +450,7 @@ describe("ProjectStore Service", () => {
          publisherConfigPath,
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   name: projectName,
                   packages: [
@@ -458,10 +464,10 @@ describe("ProjectStore Service", () => {
          }),
       );
 
-      await projectStore.finishedInitialization;
+      await environmentStore.finishedInitialization;
 
       // Get the project
-      const project = await projectStore.getProject(projectName);
+      const project = await environmentStore.getEnvironment(projectName);
 
       // Update the project
       await project.update({
@@ -481,13 +487,13 @@ describe("ProjectStore Service", () => {
       expect(readmeContent).toBe("Updated README content");
    });
 
-   it("should propagate materializationStorage on addProject for new project", async () => {
+   it("should propagate materializationStorage on addEnvironment for new environment", async () => {
       writeFileSync(
          path.join(serverRootPath, "publisher.config.json"),
-         JSON.stringify({ frozenConfig: false, projects: [] }),
+         JSON.stringify({ frozenConfig: false, environments: [] }),
       );
 
-      await projectStore.finishedInitialization;
+      await environmentStore.finishedInitialization;
 
       const materializationStorage = {
          catalogUrl:
@@ -496,7 +502,7 @@ describe("ProjectStore Service", () => {
       };
 
       initializeDuckLakeCalls.length = 0;
-      const project = await projectStore.addProject({
+      const project = await environmentStore.addEnvironment({
          name: projectName,
          materializationStorage,
       });
@@ -519,7 +525,7 @@ describe("ProjectStore Service", () => {
          path.join(serverRootPath, "publisher.config.json"),
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   name: projectName,
                   packages: [{ name: projectName, location: projectPath }],
@@ -528,8 +534,8 @@ describe("ProjectStore Service", () => {
          }),
       );
 
-      await projectStore.finishedInitialization;
-      const project = await projectStore.getProject(projectName);
+      await environmentStore.finishedInitialization;
+      const project = await environmentStore.getEnvironment(projectName);
 
       const materializationStorage = {
          catalogUrl:
@@ -567,7 +573,7 @@ describe("ProjectStore Service", () => {
          writeFileSync(
             publisherConfigPath,
             JSON.stringify({
-               projects: [
+               environments: [
                   {
                      name: projectName,
                      packages: [
@@ -582,13 +588,16 @@ describe("ProjectStore Service", () => {
          );
 
          // Get the project
-         const project1 = await projectStore.getProject(projectName);
+         const project1 = await environmentStore.getEnvironment(projectName);
 
          // Get the project again with reload=true
-         const project2 = await projectStore.getProject(projectName, true);
+         const project2 = await environmentStore.getEnvironment(
+            projectName,
+            true,
+         );
 
-         expect(project1).toBeInstanceOf(Project);
-         expect(project2).toBeInstanceOf(Project);
+         expect(project1).toBeInstanceOf(Environment);
+         expect(project2).toBeInstanceOf(Environment);
          expect(project1.metadata.name).toBe(project2.metadata.name as string);
       },
       { timeout: 30000 },
@@ -603,7 +612,7 @@ describe("ProjectStore Service", () => {
       writeFileSync(
          publisherConfigPath,
          JSON.stringify({
-            projects: [
+            environments: [
                {
                   name: projectName,
                   packages: [
@@ -618,7 +627,9 @@ describe("ProjectStore Service", () => {
       );
 
       // Test that getting the project throws an error
-      await expect(projectStore.getProject(projectName)).rejects.toThrow();
+      await expect(
+         environmentStore.getEnvironment(projectName),
+      ).rejects.toThrow();
    });
 
    it("should handle invalid publisher config", async () => {
@@ -630,11 +641,11 @@ describe("ProjectStore Service", () => {
       writeFileSync(publisherConfigPath, "invalid json");
 
       // Create a new project store that will read the invalid config
-      const newProjectStore = new ProjectStore(serverRootPath);
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
 
       // Test that the project store handles invalid JSON gracefully by falling back to empty config
-      await newProjectStore.finishedInitialization;
-      const projects = await newProjectStore.listProjects();
+      await newEnvironmentStore.finishedInitialization;
+      const projects = await newEnvironmentStore.listEnvironments();
       expect(projects).toEqual([]);
    });
 
@@ -648,7 +659,7 @@ describe("ProjectStore Service", () => {
          publisherConfigPath,
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   invalidKey1: "malloy-samples", // Invalid: should be "name"
                   invalidKey2: [
@@ -671,11 +682,11 @@ describe("ProjectStore Service", () => {
       );
 
       // Create a new project store that will read the invalid config
-      const newProjectStore = new ProjectStore(serverRootPath);
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
 
       // Test that the project store handles invalid fields gracefully without crashing
-      await newProjectStore.finishedInitialization;
-      const projects = await newProjectStore.listProjects();
+      await newEnvironmentStore.finishedInitialization;
+      const projects = await newEnvironmentStore.listEnvironments();
 
       // Should not crash and should return empty array since invalid projects are filtered out
       expect(projects).toEqual([]);
@@ -701,7 +712,7 @@ describe("ProjectStore Service", () => {
          publisherConfigPath,
          JSON.stringify({
             frozenConfig: false,
-            projects: [
+            environments: [
                {
                   // Invalid project: missing "name" field
                   packages: [
@@ -746,11 +757,11 @@ describe("ProjectStore Service", () => {
       );
 
       // Create a new project store that will read the config
-      const newProjectStore = new ProjectStore(serverRootPath);
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
 
       // Test that invalid projects are filtered out
-      await newProjectStore.finishedInitialization;
-      const projects = await newProjectStore.listProjects();
+      await newEnvironmentStore.finishedInitialization;
+      const projects = await newEnvironmentStore.listEnvironments();
 
       // Should only have the valid project
       expect(projects.length).toBe(1);
@@ -780,7 +791,7 @@ describe("ProjectStore Service", () => {
             publisherConfigPath,
             JSON.stringify({
                frozenConfig: false,
-               projects: [
+               environments: [
                   {
                      name: projectName,
                      packages: [
@@ -800,18 +811,18 @@ describe("ProjectStore Service", () => {
             }),
          );
 
-         await projectStore.finishedInitialization;
+         await environmentStore.finishedInitialization;
 
          // Test concurrent access to the same project
          const promises = Array.from({ length: 5 }, () =>
-            projectStore.getProject(projectName),
+            environmentStore.getEnvironment(projectName),
          );
 
          const projects = await Promise.all(promises);
 
          expect(projects).toHaveLength(5);
          projects.forEach((project) => {
-            expect(project).toBeInstanceOf(Project);
+            expect(project).toBeInstanceOf(Environment);
             expect(project.metadata.name).toBe(projectName);
          });
       },
@@ -821,7 +832,7 @@ describe("ProjectStore Service", () => {
 
 describe("Project Service Error Recovery", () => {
    let sandbox: sinon.SinonSandbox;
-   let projectStore: ProjectStore;
+   let environmentStore: EnvironmentStore;
    const serverRootPath = path.join(
       TEMP_DIR_PATH,
       "pathways-worker-publisher-error-recovery-test",
@@ -852,7 +863,7 @@ describe("Project Service Error Recovery", () => {
       }));
 
       // Create project store after mocking
-      projectStore = new ProjectStore(serverRootPath);
+      environmentStore = new EnvironmentStore(serverRootPath);
    });
 
    afterEach(async () => {
@@ -872,7 +883,7 @@ describe("Project Service Error Recovery", () => {
          writeFileSync(
             publisherConfigPath,
             JSON.stringify({
-               projects: [
+               environments: [
                   {
                      name: projectName,
                      packages: [
@@ -890,7 +901,9 @@ describe("Project Service Error Recovery", () => {
          );
 
          // Test that the project store handles the missing directory
-         await expect(projectStore.getProject(projectName)).rejects.toThrow();
+         await expect(
+            environmentStore.getEnvironment(projectName),
+         ).rejects.toThrow();
       });
 
       it(
@@ -923,7 +936,7 @@ describe("Project Service Error Recovery", () => {
             writeFileSync(
                publisherConfigPath,
                JSON.stringify({
-                  projects: [
+                  environments: [
                      {
                         name: projectName,
                         packages: [
@@ -939,8 +952,8 @@ describe("Project Service Error Recovery", () => {
 
             // Test that the project store handles corrupted connection files gracefully
             // (The current implementation loads the project even with corrupted connection files)
-            const project = await projectStore.getProject(projectName);
-            expect(project).toBeInstanceOf(Project);
+            const project = await environmentStore.getEnvironment(projectName);
+            expect(project).toBeInstanceOf(Environment);
             expect(project.metadata.name).toBe(projectName);
          },
          { timeout: 30000 },
@@ -974,7 +987,7 @@ describe("Project Service Error Recovery", () => {
             writeFileSync(
                publisherConfigPath,
                JSON.stringify({
-                  projects: [
+                  environments: [
                      {
                         name: projectName,
                         packages: [
@@ -989,17 +1002,18 @@ describe("Project Service Error Recovery", () => {
             );
 
             // Get the project successfully
-            const project = await projectStore.getProject(projectName);
-            expect(project).toBeInstanceOf(Project);
+            const project = await environmentStore.getEnvironment(projectName);
+            expect(project).toBeInstanceOf(Environment);
 
             // Try to get a non-existent project
             await expect(
-               projectStore.getProject("non-existent"),
+               environmentStore.getEnvironment("non-existent"),
             ).rejects.toThrow();
 
             // Verify the original project is still accessible
-            const projectAgain = await projectStore.getProject(projectName);
-            expect(projectAgain).toBeInstanceOf(Project);
+            const projectAgain =
+               await environmentStore.getEnvironment(projectName);
+            expect(projectAgain).toBeInstanceOf(Environment);
             expect(projectAgain.metadata.name).toBe(projectName);
          },
          { timeout: 30000 },