@malloy-publisher/server 0.0.205 → 0.0.206

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

@@ -150,11 +150,14 @@ describe("DuckDB legacy projects schema cleanup", () => {
          ["p1"],
       );
       expect(mats.length).toBe(0);
-      const manifests = await db.all<{ id: string }>(
-         "SELECT id FROM build_manifests WHERE environment_id = ?",
-         ["p1"],
+
+      // The legacy `build_manifests` table is dropped and not recreated: the
+      // two-round refactor folds the manifest into a JSON column on the
+      // `materializations` row, so no standalone manifest table remains.
+      const manifestTable = await db.all<{ name: string }>(
+         "SELECT name FROM sqlite_master WHERE type='table' AND name='build_manifests'",
       );
-      expect(manifests.length).toBe(0);
+      expect(manifestTable.length).toBe(0);
 
       await db.close();
    });

package/src/controller/manifest.controller.ts

@@ -1,38 +0,0 @@
-import { EnvironmentStore } from "../service/environment_store";
-import { ManifestService } from "../service/manifest_service";
-import { resolveEnvironmentId } from "../service/resolve_environment";
-
-export class ManifestController {
-   constructor(
-      private environmentStore: EnvironmentStore,
-      private manifestService: ManifestService,
-   ) {}
-
-   async getManifest(environmentName: string, packageName: string) {
-      const repository = this.environmentStore.storageManager.getRepository();
-      const environmentId = await resolveEnvironmentId(
-         repository,
-         environmentName,
-      );
-      // Verify the package exists so we return 404 instead of an empty manifest.
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      await environment.getPackage(packageName, false);
-      return this.manifestService.getManifest(environmentId, packageName);
-   }
-
-   async reloadManifest(environmentName: string, packageName: string) {
-      const repository = this.environmentStore.storageManager.getRepository();
-      const environmentId = await resolveEnvironmentId(
-         repository,
-         environmentName,
-      );
-      return this.manifestService.reloadManifest(
-         environmentId,
-         packageName,
-         environmentName,
-      );
-   }
-}

package/src/service/manifest_service.spec.ts

@@ -1,206 +0,0 @@
-import { beforeEach, describe, expect, it } from "bun:test";
-import * as sinon from "sinon";
-import {
-   BuildManifest,
-   ManifestEntry,
-   ManifestStore,
-   ResourceRepository,
-} from "../storage/DatabaseInterface";
-import { ManifestService } from "./manifest_service";
-import { EnvironmentStore } from "./environment_store";
-
-function makeEntry(overrides: Partial<ManifestEntry> = {}): ManifestEntry {
-   return {
-      id: "entry-1",
-      environmentId: "proj-1",
-      packageName: "pkg",
-      buildId: "build-abc",
-      tableName: "my_table",
-      sourceName: "my_source",
-      connectionName: "duckdb",
-      createdAt: new Date("2025-01-01"),
-      updatedAt: new Date("2025-01-01"),
-      ...overrides,
-   };
-}
-
-function createMocks() {
-   const sandbox = sinon.createSandbox();
-
-   const manifestStore: sinon.SinonStubbedInstance<ManifestStore> = {
-      getManifest: sandbox.stub(),
-      writeEntry: sandbox.stub(),
-      deleteEntry: sandbox.stub(),
-      listEntries: sandbox.stub(),
-   };
-
-   const repository = {
-      listManifestEntries: sandbox.stub(),
-   } as unknown as sinon.SinonStubbedInstance<ResourceRepository>;
-
-   const reloadAllModels = sandbox.stub().resolves();
-   const reloadAllModelsForPackage = sandbox.stub().resolves();
-
-   const pkg = {
-      reloadAllModels,
-   };
-
-   const environment = {
-      getPackage: sandbox.stub().resolves(pkg),
-      reloadAllModelsForPackage,
-   };
-
-   const environmentStore = {
-      storageManager: {
-         getManifestStore: (_environmentId?: string) => manifestStore,
-         getRepository: () => repository,
-      },
-      getEnvironment: sandbox.stub().resolves(environment),
-   } as unknown as EnvironmentStore;
-
-   const service = new ManifestService(environmentStore);
-
-   return {
-      sandbox,
-      manifestStore,
-      repository,
-      environmentStore,
-      environment,
-      pkg,
-      reloadAllModels,
-      reloadAllModelsForPackage,
-      service,
-   };
-}
-
-describe("ManifestService", () => {
-   let ctx: ReturnType<typeof createMocks>;
-
-   beforeEach(() => {
-      ctx = createMocks();
-   });
-
-   describe("getManifest", () => {
-      it("should delegate to the manifest store", async () => {
-         const manifest: BuildManifest = {
-            entries: { "build-abc": { tableName: "tbl" } },
-            strict: false,
-         };
-         ctx.manifestStore.getManifest.resolves(manifest);
-
-         const result = await ctx.service.getManifest("proj-1", "pkg");
-
-         expect(result).toEqual(manifest);
-         expect(ctx.manifestStore.getManifest.calledWith("proj-1", "pkg")).toBe(
-            true,
-         );
-      });
-   });
-
-   describe("writeEntry", () => {
-      it("should delegate to the manifest store", async () => {
-         ctx.manifestStore.writeEntry.resolves();
-
-         await ctx.service.writeEntry(
-            "proj-1",
-            "pkg",
-            "build-abc",
-            "tbl",
-            "src",
-            "duckdb",
-         );
-
-         expect(ctx.manifestStore.writeEntry.calledOnce).toBe(true);
-         const args = ctx.manifestStore.writeEntry.firstCall.args;
-         expect(args[0]).toBe("proj-1");
-         expect(args[1]).toBe("pkg");
-         expect(args[2]).toBe("build-abc");
-         expect(args[3]).toBe("tbl");
-         expect(args[4]).toBe("src");
-         expect(args[5]).toBe("duckdb");
-      });
-   });
-
-   describe("deleteEntry", () => {
-      it("should delegate to the manifest store", async () => {
-         ctx.manifestStore.deleteEntry.resolves();
-
-         await ctx.service.deleteEntry("proj-1", "entry-1");
-
-         expect(ctx.manifestStore.deleteEntry.calledOnce).toBe(true);
-         expect(ctx.manifestStore.deleteEntry.firstCall.args[0]).toBe(
-            "entry-1",
-         );
-      });
-   });
-
-   describe("reloadManifest", () => {
-      it("should get manifest, reload it onto the package, and return it", async () => {
-         const manifest: BuildManifest = {
-            entries: { "build-abc": { tableName: "tbl" } },
-            strict: false,
-         };
-         ctx.manifestStore.getManifest.resolves(manifest);
-
-         const result = await ctx.service.reloadManifest(
-            "proj-1",
-            "pkg",
-            "my-environment",
-         );
-
-         expect(result).toEqual(manifest);
-         expect(
-            (ctx.environmentStore.getEnvironment as sinon.SinonStub).calledWith(
-               "my-environment",
-               false,
-            ),
-         ).toBe(true);
-         expect(ctx.environment.getPackage.calledWith("pkg", false)).toBe(true);
-         expect(
-            ctx.reloadAllModelsForPackage.calledWith("pkg", manifest.entries),
-         ).toBe(true);
-      });
-
-      it("should return an empty manifest when no entries exist", async () => {
-         const emptyManifest: BuildManifest = {
-            entries: {},
-            strict: false,
-         };
-         ctx.manifestStore.getManifest.resolves(emptyManifest);
-
-         const result = await ctx.service.reloadManifest(
-            "proj-1",
-            "pkg",
-            "my-environment",
-         );
-
-         expect(result.entries).toEqual({});
-         expect(ctx.reloadAllModelsForPackage.calledWith("pkg", {})).toBe(true);
-      });
-   });
-
-   describe("listEntries", () => {
-      it("should return entries from the manifest store", async () => {
-         const entries = [
-            makeEntry(),
-            makeEntry({ id: "entry-2", buildId: "build-def" }),
-         ];
-         ctx.manifestStore.listEntries.resolves(entries);
-
-         const result = await ctx.service.listEntries("proj-1", "pkg");
-
-         expect(result).toEqual(entries);
-         expect(ctx.manifestStore.listEntries.calledWith("proj-1", "pkg")).toBe(
-            true,
-         );
-      });
-
-      it("should return empty array when no entries exist", async () => {
-         ctx.manifestStore.listEntries.resolves([]);
-
-         const result = await ctx.service.listEntries("proj-1", "pkg");
-
-         expect(result).toEqual([]);
-      });
-   });
-});

package/src/service/manifest_service.ts

@@ -1,117 +0,0 @@
-import { logger } from "../logger";
-import {
-   BuildManifest,
-   ManifestEntry,
-   ManifestStore,
-} from "../storage/DatabaseInterface";
-import { EnvironmentStore } from "./environment_store";
-
-/**
- * Manages build manifests that map source names to materialized table names.
- *
- * A build manifest is produced during materialization: each entry records which
- * DuckDB table backs a given Malloy source.
- *
- * Two-phase lifecycle:
- *  1. **Persist** – `writeEntry` stores individual entries to the DB as they
- *     are produced during a build.
- *  2. **Reload** – `reloadManifest` reads the manifest from the DB and
- *     recompiles all models in the package so the Malloy Runtime resolves
- *     persist references to the materialized tables.
- *
- * All manifest operations delegate to the active {@link ManifestStore}, which
- * is either the local DuckDB store (standalone) or DuckLake (orchestrated).
- */
-export class ManifestService {
-   constructor(private environmentStore: EnvironmentStore) {}
-
-   private manifestStoreFor(environmentId: string): ManifestStore {
-      return this.environmentStore.storageManager.getManifestStore(
-         environmentId,
-      );
-   }
-
-   async getManifest(
-      environmentId: string,
-      packageName: string,
-   ): Promise<BuildManifest> {
-      return this.manifestStoreFor(environmentId).getManifest(
-         environmentId,
-         packageName,
-      );
-   }
-
-   async writeEntry(
-      environmentId: string,
-      packageName: string,
-      buildId: string,
-      tableName: string,
-      sourceName: string,
-      connectionName: string,
-   ): Promise<void> {
-      await this.manifestStoreFor(environmentId).writeEntry(
-         environmentId,
-         packageName,
-         buildId,
-         tableName,
-         sourceName,
-         connectionName,
-      );
-   }
-
-   async deleteEntry(environmentId: string, entryId: string): Promise<void> {
-      await this.manifestStoreFor(environmentId).deleteEntry(entryId);
-   }
-
-   /**
-    * Read the manifest from storage and reload it onto this worker's
-    * package so subsequent queries resolve persist references to
-    * materialized tables. This is what `POST .../manifest?action=reload` calls
-    * (used by orchestrated workers that need to pick up manifest state
-    * produced elsewhere). Despite the name, nothing is loaded *into*
-    * storage — the worker pulls the manifest down and recompiles.
-    */
-   async reloadManifest(
-      environmentId: string,
-      packageName: string,
-      environmentName: string,
-   ): Promise<BuildManifest> {
-      const manifest = await this.getManifest(environmentId, packageName);
-
-      const environment = await this.environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      // Ensure the package is loaded, then reload its models under the
-      // per-package mutex so the disk reads are serialized against
-      // installPackage / deletePackage.
-      await environment.getPackage(packageName, false);
-      await environment.reloadAllModelsForPackage(
-         packageName,
-         manifest.entries,
-      );
-
-      logger.info("Reloaded manifest and recompiled models", {
-         environmentId,
-         packageName,
-         entryCount: Object.keys(manifest.entries).length,
-      });
-
-      return manifest;
-   }
-
-   /**
-    * Get the manifest entries from the active store for inspection.
-    * Routes through ManifestStore so DuckLake mode reads the shared
-    * catalog instead of the local DuckDB table.
-    */
-   async listEntries(
-      environmentId: string,
-      packageName: string,
-   ): Promise<ManifestEntry[]> {
-      return this.manifestStoreFor(environmentId).listEntries(
-         environmentId,
-         packageName,
-      );
-   }
-}