@malloy-publisher/server 0.0.195 → 0.0.196

package/src/service/manifest_service.spec.ts

@@ -7,12 +7,12 @@ import {
    ResourceRepository,
 } from "../storage/DatabaseInterface";
 import { ManifestService } from "./manifest_service";
-import { ProjectStore } from "./project_store";
+import { EnvironmentStore } from "./environment_store";
 
 function makeEntry(overrides: Partial<ManifestEntry> = {}): ManifestEntry {
    return {
       id: "entry-1",
-      projectId: "proj-1",
+      environmentId: "proj-1",
       packageName: "pkg",
       buildId: "build-abc",
       tableName: "my_table",
@@ -44,26 +44,26 @@ function createMocks() {
       reloadAllModels,
    };
 
-   const project = {
+   const environment = {
       getPackage: sandbox.stub().resolves(pkg),
    };
 
-   const projectStore = {
+   const environmentStore = {
       storageManager: {
-         getManifestStore: (_projectId?: string) => manifestStore,
+         getManifestStore: (_environmentId?: string) => manifestStore,
          getRepository: () => repository,
       },
-      getProject: sandbox.stub().resolves(project),
-   } as unknown as ProjectStore;
+      getEnvironment: sandbox.stub().resolves(environment),
+   } as unknown as EnvironmentStore;
 
-   const service = new ManifestService(projectStore);
+   const service = new ManifestService(environmentStore);
 
    return {
       sandbox,
       manifestStore,
       repository,
-      projectStore,
-      project,
+      environmentStore,
+      environment,
       pkg,
       reloadAllModels,
       service,
@@ -142,17 +142,17 @@ describe("ManifestService", () => {
          const result = await ctx.service.reloadManifest(
             "proj-1",
             "pkg",
-            "my-project",
+            "my-environment",
          );
 
          expect(result).toEqual(manifest);
          expect(
-            (ctx.projectStore.getProject as sinon.SinonStub).calledWith(
-               "my-project",
+            (ctx.environmentStore.getEnvironment as sinon.SinonStub).calledWith(
+               "my-environment",
                false,
             ),
          ).toBe(true);
-         expect(ctx.project.getPackage.calledWith("pkg", false)).toBe(true);
+         expect(ctx.environment.getPackage.calledWith("pkg", false)).toBe(true);
          expect(ctx.reloadAllModels.calledWith(manifest.entries)).toBe(true);
       });
 
@@ -166,7 +166,7 @@ describe("ManifestService", () => {
          const result = await ctx.service.reloadManifest(
             "proj-1",
             "pkg",
-            "my-project",
+            "my-environment",
          );
 
          expect(result.entries).toEqual({});

package/src/service/manifest_service.ts

@@ -4,7 +4,7 @@ import {
    ManifestEntry,
    ManifestStore,
 } from "../storage/DatabaseInterface";
-import { ProjectStore } from "./project_store";
+import { EnvironmentStore } from "./environment_store";
 
 /**
  * Manages build manifests that map source names to materialized table names.
@@ -23,32 +23,34 @@ import { ProjectStore } from "./project_store";
  * is either the local DuckDB store (standalone) or DuckLake (orchestrated).
  */
 export class ManifestService {
-   constructor(private projectStore: ProjectStore) {}
+   constructor(private environmentStore: EnvironmentStore) {}
 
-   private manifestStoreFor(projectId: string): ManifestStore {
-      return this.projectStore.storageManager.getManifestStore(projectId);
+   private manifestStoreFor(environmentId: string): ManifestStore {
+      return this.environmentStore.storageManager.getManifestStore(
+         environmentId,
+      );
    }
 
    async getManifest(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<BuildManifest> {
-      return this.manifestStoreFor(projectId).getManifest(
-         projectId,
+      return this.manifestStoreFor(environmentId).getManifest(
+         environmentId,
          packageName,
       );
    }
 
    async writeEntry(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       buildId: string,
       tableName: string,
       sourceName: string,
       connectionName: string,
    ): Promise<void> {
-      await this.manifestStoreFor(projectId).writeEntry(
-         projectId,
+      await this.manifestStoreFor(environmentId).writeEntry(
+         environmentId,
          packageName,
          buildId,
          tableName,
@@ -57,8 +59,8 @@ export class ManifestService {
       );
    }
 
-   async deleteEntry(projectId: string, entryId: string): Promise<void> {
-      await this.manifestStoreFor(projectId).deleteEntry(entryId);
+   async deleteEntry(environmentId: string, entryId: string): Promise<void> {
+      await this.manifestStoreFor(environmentId).deleteEntry(entryId);
    }
 
    /**
@@ -70,18 +72,21 @@ export class ManifestService {
     * storage — the worker pulls the manifest down and recompiles.
     */
    async reloadManifest(
-      projectId: string,
+      environmentId: string,
       packageName: string,
-      projectName: string,
+      environmentName: string,
    ): Promise<BuildManifest> {
-      const manifest = await this.getManifest(projectId, packageName);
+      const manifest = await this.getManifest(environmentId, packageName);
 
-      const project = await this.projectStore.getProject(projectName, false);
-      const pkg = await project.getPackage(packageName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const pkg = await environment.getPackage(packageName, false);
       await pkg.reloadAllModels(manifest.entries);
 
       logger.info("Reloaded manifest and recompiled models", {
-         projectId,
+         environmentId,
          packageName,
          entryCount: Object.keys(manifest.entries).length,
       });
@@ -95,11 +100,11 @@ export class ManifestService {
     * catalog instead of the local DuckDB table.
     */
    async listEntries(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<ManifestEntry[]> {
-      return this.manifestStoreFor(projectId).listEntries(
-         projectId,
+      return this.manifestStoreFor(environmentId).listEntries(
+         environmentId,
          packageName,
       );
    }

package/src/service/materialization_service.spec.ts

@@ -2,32 +2,32 @@ import type { Connection } from "@malloydata/malloy";
 import { beforeEach, describe, expect, it } from "bun:test";
 import * as sinon from "sinon";
 import {
+   EnvironmentNotFoundError,
    InvalidStateTransitionError,
    MaterializationConflictError,
    MaterializationNotFoundError,
-   ProjectNotFoundError,
 } from "../errors";
-import { DuplicateActiveMaterializationError } from "../storage/duckdb/MaterializationRepository";
 import {
    ManifestEntry,
    Materialization,
    MaterializationStatus,
    ResourceRepository,
 } from "../storage/DatabaseInterface";
+import { DuplicateActiveMaterializationError } from "../storage/duckdb/MaterializationRepository";
+import { EnvironmentStore } from "./environment_store";
 import { ManifestService } from "./manifest_service";
 import {
    manifestTableKey,
    MaterializationService,
    tablePhysicallyExists,
 } from "./materialization_service";
-import { ProjectStore } from "./project_store";
 
 function makeExecution(
    overrides: Partial<Materialization> = {},
 ): Materialization {
    return {
       id: "exec-1",
-      projectId: "proj-1",
+      environmentId: "proj-1",
       packageName: "pkg",
       status: "PENDING",
       startedAt: null,
@@ -46,12 +46,12 @@ function createMocks() {
    const sandbox = sinon.createSandbox();
 
    const repository: MockRepo = {
-      listProjects: sandbox.stub(),
-      getProjectById: sandbox.stub(),
-      getProjectByName: sandbox.stub(),
-      createProject: sandbox.stub(),
-      updateProject: sandbox.stub(),
-      deleteProject: sandbox.stub(),
+      listEnvironments: sandbox.stub(),
+      getEnvironmentById: sandbox.stub(),
+      getEnvironmentByName: sandbox.stub(),
+      createEnvironment: sandbox.stub(),
+      updateEnvironment: sandbox.stub(),
+      deleteEnvironment: sandbox.stub(),
       listPackages: sandbox.stub(),
       getPackageById: sandbox.stub(),
       getPackageByName: sandbox.stub(),
@@ -80,10 +80,10 @@ function createMocks() {
       getManifestStore: sandbox.stub(),
    };
 
-   const projectStore = {
+   const environmentStore = {
       storageManager,
-      getProject: sandbox.stub(),
-   } as unknown as ProjectStore;
+      getEnvironment: sandbox.stub(),
+   } as unknown as EnvironmentStore;
 
    const manifestService = {
       getManifest: sandbox.stub().resolves({ entries: {}, strict: false }),
@@ -94,20 +94,20 @@ function createMocks() {
    } as unknown as sinon.SinonStubbedInstance<ManifestService>;
 
    const service = new MaterializationService(
-      projectStore,
+      environmentStore,
       manifestService as unknown as ManifestService,
    );
 
-   // Default: resolveProjectId succeeds
-   repository.getProjectByName.resolves({
+   // Default: resolveEnvironmentId succeeds
+   repository.getEnvironmentByName.resolves({
       id: "proj-1",
-      name: "my-project",
+      name: "my-environment",
       path: "/test",
       createdAt: new Date(),
       updatedAt: new Date(),
    });
 
-   return { sandbox, repository, projectStore, manifestService, service };
+   return { sandbox, repository, environmentStore, manifestService, service };
 }
 
 describe("MaterializationService", () => {
@@ -117,15 +117,15 @@ describe("MaterializationService", () => {
       ctx = createMocks();
    });
 
-   // ==================== resolveProjectId ====================
+   // ==================== resolveEnvironmentId ====================
 
-   describe("resolveProjectId (via listMaterializations)", () => {
-      it("should throw ProjectNotFoundError when project is not in DB", async () => {
-         ctx.repository.getProjectByName.resolves(null);
+   describe("resolveEnvironmentId (via listMaterializations)", () => {
+      it("should throw EnvironmentNotFoundError when environment is not in DB", async () => {
+         ctx.repository.getEnvironmentByName.resolves(null);
 
          await expect(
             ctx.service.listMaterializations("unknown", "pkg"),
-         ).rejects.toThrow(ProjectNotFoundError);
+         ).rejects.toThrow(EnvironmentNotFoundError);
       });
    });
 
@@ -137,7 +137,7 @@ describe("MaterializationService", () => {
          ctx.repository.listMaterializations.resolves(builds);
 
          const result = await ctx.service.listMaterializations(
-            "my-project",
+            "my-environment",
             "pkg",
          );
 
@@ -151,7 +151,7 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(exec);
 
          const result = await ctx.service.getMaterialization(
-            "my-project",
+            "my-environment",
             "pkg",
             "exec-1",
          );
@@ -163,7 +163,7 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(null);
 
          await expect(
-            ctx.service.getMaterialization("my-project", "pkg", "missing"),
+            ctx.service.getMaterialization("my-environment", "pkg", "missing"),
          ).rejects.toThrow(MaterializationNotFoundError);
       });
 
@@ -173,7 +173,7 @@ describe("MaterializationService", () => {
          );
 
          await expect(
-            ctx.service.getMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.getMaterialization("my-environment", "pkg", "exec-1"),
          ).rejects.toThrow(MaterializationNotFoundError);
       });
    });
@@ -216,7 +216,7 @@ describe("MaterializationService", () => {
             // Trigger via stopMaterialization for RUNNING->CANCELLED (orphaned path)
             if (from === "RUNNING" && to === "CANCELLED") {
                const result = await ctx.service.stopMaterialization(
-                  "my-project",
+                  "my-environment",
                   "pkg",
                   exec.id,
                );
@@ -242,7 +242,7 @@ describe("MaterializationService", () => {
 
    describe("createMaterialization", () => {
       it("should create a PENDING build", async () => {
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves({}),
          });
          ctx.repository.getActiveMaterialization.resolves(null);
@@ -253,7 +253,7 @@ describe("MaterializationService", () => {
          ctx.repository.createMaterialization.resolves(pending);
 
          const result = await ctx.service.createMaterialization(
-            "my-project",
+            "my-environment",
             "pkg",
             {
                autoLoadManifest: true,
@@ -276,7 +276,7 @@ describe("MaterializationService", () => {
       });
 
       it("should reject creation when an active materialization exists", async () => {
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves({}),
          });
          ctx.repository.getActiveMaterialization.resolves(
@@ -284,12 +284,12 @@ describe("MaterializationService", () => {
          );
 
          await expect(
-            ctx.service.createMaterialization("my-project", "pkg"),
+            ctx.service.createMaterialization("my-environment", "pkg"),
          ).rejects.toThrow(MaterializationConflictError);
       });
 
       it("should translate DuplicateActiveMaterializationError from a lost race", async () => {
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves({}),
          });
          // The pre-check finds nothing (race is still possible), but the
@@ -305,7 +305,7 @@ describe("MaterializationService", () => {
          );
 
          await expect(
-            ctx.service.createMaterialization("my-project", "pkg"),
+            ctx.service.createMaterialization("my-environment", "pkg"),
          ).rejects.toThrow(/winner/);
       });
    });
@@ -322,7 +322,7 @@ describe("MaterializationService", () => {
          ctx.repository.updateMaterialization.resolves(running);
 
          const result = await ctx.service.startMaterialization(
-            "my-project",
+            "my-environment",
             "pkg",
             "exec-1",
          );
@@ -335,7 +335,7 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(running);
 
          await expect(
-            ctx.service.startMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.startMaterialization("my-environment", "pkg", "exec-1"),
          ).rejects.toThrow(InvalidStateTransitionError);
       });
 
@@ -350,7 +350,7 @@ describe("MaterializationService", () => {
          );
 
          await expect(
-            ctx.service.startMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.startMaterialization("my-environment", "pkg", "exec-1"),
          ).rejects.toThrow(MaterializationConflictError);
       });
    });
@@ -364,7 +364,7 @@ describe("MaterializationService", () => {
          );
 
          const result = await ctx.service.stopMaterialization(
-            "my-project",
+            "my-environment",
             "pkg",
             "exec-1",
          );
@@ -380,7 +380,7 @@ describe("MaterializationService", () => {
          );
 
          const result = await ctx.service.stopMaterialization(
-            "my-project",
+            "my-environment",
             "pkg",
             "orphan",
          );
@@ -393,7 +393,7 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(succeeded);
 
          await expect(
-            ctx.service.stopMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.stopMaterialization("my-environment", "pkg", "exec-1"),
          ).rejects.toThrow(InvalidStateTransitionError);
       });
    });
@@ -406,7 +406,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(succeeded);
          ctx.repository.deleteMaterialization.resolves();
 
-         await ctx.service.deleteMaterialization("my-project", "pkg", "exec-1");
+         await ctx.service.deleteMaterialization(
+            "my-environment",
+            "pkg",
+            "exec-1",
+         );
 
          expect(ctx.repository.deleteMaterialization.calledOnce).toBe(true);
          expect(ctx.repository.deleteMaterialization.firstCall.args[0]).toBe(
@@ -419,7 +423,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(failed);
          ctx.repository.deleteMaterialization.resolves();
 
-         await ctx.service.deleteMaterialization("my-project", "pkg", "exec-1");
+         await ctx.service.deleteMaterialization(
+            "my-environment",
+            "pkg",
+            "exec-1",
+         );
 
          expect(ctx.repository.deleteMaterialization.calledOnce).toBe(true);
       });
@@ -429,7 +437,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(cancelled);
          ctx.repository.deleteMaterialization.resolves();
 
-         await ctx.service.deleteMaterialization("my-project", "pkg", "exec-1");
+         await ctx.service.deleteMaterialization(
+            "my-environment",
+            "pkg",
+            "exec-1",
+         );
 
          expect(ctx.repository.deleteMaterialization.calledOnce).toBe(true);
       });
@@ -439,7 +451,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(pending);
 
          await expect(
-            ctx.service.deleteMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.deleteMaterialization(
+               "my-environment",
+               "pkg",
+               "exec-1",
+            ),
          ).rejects.toThrow(InvalidStateTransitionError);
       });
 
@@ -448,7 +464,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(running);
 
          await expect(
-            ctx.service.deleteMaterialization("my-project", "pkg", "exec-1"),
+            ctx.service.deleteMaterialization(
+               "my-environment",
+               "pkg",
+               "exec-1",
+            ),
          ).rejects.toThrow(InvalidStateTransitionError);
       });
 
@@ -456,7 +476,11 @@ describe("MaterializationService", () => {
          ctx.repository.getMaterializationById.resolves(null);
 
          await expect(
-            ctx.service.deleteMaterialization("my-project", "pkg", "missing"),
+            ctx.service.deleteMaterialization(
+               "my-environment",
+               "pkg",
+               "missing",
+            ),
          ).rejects.toThrow(MaterializationNotFoundError);
       });
    });
@@ -470,7 +494,7 @@ describe("MaterializationService", () => {
          );
 
          await expect(
-            ctx.service.teardownPackage("my-project", "pkg"),
+            ctx.service.teardownPackage("my-environment", "pkg"),
          ).rejects.toThrow(MaterializationConflictError);
       });
 
@@ -486,14 +510,14 @@ describe("MaterializationService", () => {
                throw new Error(`unknown connection: ${name}`);
             },
          };
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves(pkg),
          });
          ctx.repository.getActiveMaterialization.resolves(null);
          const entries: ManifestEntry[] = [
             {
                id: "entry-1",
-               projectId: "proj-1",
+               environmentId: "proj-1",
                packageName: "pkg",
                buildId: "abcdef1234567890abcdef1234567890",
                tableName: "table_a",
@@ -504,7 +528,7 @@ describe("MaterializationService", () => {
             },
             {
                id: "entry-2",
-               projectId: "proj-1",
+               environmentId: "proj-1",
                packageName: "pkg",
                buildId: "1234567890abcdef1234567890abcdef",
                tableName: "table_b",
@@ -516,7 +540,10 @@ describe("MaterializationService", () => {
          ];
          (ctx.manifestService.listEntries as sinon.SinonStub).resolves(entries);
 
-         const result = await ctx.service.teardownPackage("my-project", "pkg");
+         const result = await ctx.service.teardownPackage(
+            "my-environment",
+            "pkg",
+         );
 
          expect(result.dropped).toHaveLength(2);
          expect(result.errors).toHaveLength(0);
@@ -543,14 +570,14 @@ describe("MaterializationService", () => {
                throw new Error(`unknown connection: ${name}`);
             },
          };
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves(pkg),
          });
          ctx.repository.getActiveMaterialization.resolves(null);
          const entries: ManifestEntry[] = [
             {
                id: "entry-ghost",
-               projectId: "proj-1",
+               environmentId: "proj-1",
                packageName: "pkg",
                buildId: "abcdef1234567890abcdef1234567890",
                tableName: "table_ghost",
@@ -562,7 +589,10 @@ describe("MaterializationService", () => {
          ];
          (ctx.manifestService.listEntries as sinon.SinonStub).resolves(entries);
 
-         const result = await ctx.service.teardownPackage("my-project", "pkg");
+         const result = await ctx.service.teardownPackage(
+            "my-environment",
+            "pkg",
+         );
 
          expect(result.dropped).toHaveLength(1);
          expect(result.dropped[0].targetDropSkipped).toBe(true);
@@ -586,13 +616,13 @@ describe("MaterializationService", () => {
                throw new Error(`unknown connection: ${name}`);
             },
          };
-         (ctx.projectStore.getProject as sinon.SinonStub).resolves({
+         (ctx.environmentStore.getEnvironment as sinon.SinonStub).resolves({
             getPackage: sinon.stub().resolves(pkg),
          });
          ctx.repository.getActiveMaterialization.resolves(null);
          const entry: ManifestEntry = {
             id: "entry-1",
-            projectId: "proj-1",
+            environmentId: "proj-1",
             packageName: "pkg",
             buildId: "abcdef1234567890abcdef1234567890",
             tableName: "orphan",
@@ -603,9 +633,13 @@ describe("MaterializationService", () => {
          };
          (ctx.manifestService.listEntries as sinon.SinonStub).resolves([entry]);
 
-         const result = await ctx.service.teardownPackage("my-project", "pkg", {
-            dryRun: true,
-         });
+         const result = await ctx.service.teardownPackage(
+            "my-environment",
+            "pkg",
+            {
+               dryRun: true,
+            },
+         );
 
          expect(result.dropped).toHaveLength(1);
          expect(result.dropped[0].tableName).toBe("orphan");