@malloy-publisher/server 0.0.196-dev → 0.0.196

package/src/storage/duckdb/DuckDBRepository.ts

@@ -1,73 +1,73 @@
 import {
    Connection,
+   Environment,
    ManifestEntry,
    Materialization,
    MaterializationStatus,
    Package,
-   Project,
    ResourceRepository,
 } from "../DatabaseInterface";
 import { ConnectionRepository } from "./ConnectionRepository";
 import { DuckDBConnection } from "./DuckDBConnection";
+import { EnvironmentRepository } from "./EnvironmentRepository";
 import { ManifestRepository } from "./ManifestRepository";
 import { MaterializationRepository } from "./MaterializationRepository";
 import { PackageRepository } from "./PackageRepository";
-import { ProjectRepository } from "./ProjectRepository";
 
 export class DuckDBRepository implements ResourceRepository {
-   private projectRepo: ProjectRepository;
+   private environmentRepo: EnvironmentRepository;
    private packageRepo: PackageRepository;
    private connectionRepo: ConnectionRepository;
    private materializationRepo: MaterializationRepository;
    private manifestRepo: ManifestRepository;
 
    constructor(public db: DuckDBConnection) {
-      this.projectRepo = new ProjectRepository(db);
+      this.environmentRepo = new EnvironmentRepository(db);
       this.packageRepo = new PackageRepository(db);
       this.connectionRepo = new ConnectionRepository(db);
       this.materializationRepo = new MaterializationRepository(db);
       this.manifestRepo = new ManifestRepository(db);
    }
 
-   // ==================== PROJECTS ====================
+   // ==================== ENVIRONMENTS ====================
 
-   async listProjects(): Promise<Project[]> {
-      return this.projectRepo.listProjects();
+   async listEnvironments(): Promise<Environment[]> {
+      return this.environmentRepo.listEnvironments();
    }
 
-   async getProjectById(id: string): Promise<Project | null> {
-      return this.projectRepo.getProjectById(id);
+   async getEnvironmentById(id: string): Promise<Environment | null> {
+      return this.environmentRepo.getEnvironmentById(id);
    }
 
-   async getProjectByName(name: string): Promise<Project | null> {
-      return this.projectRepo.getProjectByName(name);
+   async getEnvironmentByName(name: string): Promise<Environment | null> {
+      return this.environmentRepo.getEnvironmentByName(name);
    }
 
-   async createProject(
-      project: Omit<Project, "id" | "createdAt" | "updatedAt">,
-   ): Promise<Project> {
-      return this.projectRepo.createProject(project);
+   async createEnvironment(
+      environment: Omit<Environment, "id" | "createdAt" | "updatedAt">,
+   ): Promise<Environment> {
+      return this.environmentRepo.createEnvironment(environment);
    }
 
-   async updateProject(
+   async updateEnvironment(
       id: string,
-      updates: Partial<Project>,
-   ): Promise<Project> {
-      return this.projectRepo.updateProject(id, updates);
+      updates: Partial<Environment>,
+   ): Promise<Environment> {
+      return this.environmentRepo.updateEnvironment(id, updates);
    }
 
-   async deleteProject(id: string): Promise<void> {
-      await this.manifestRepo.deleteEntriesByProjectId(id);
-      await this.materializationRepo.deleteByProjectId(id);
-      await this.connectionRepo.deleteConnectionsByProjectId(id);
-      await this.packageRepo.deletePackagesByProjectId(id);
-      await this.projectRepo.deleteProject(id);
+   async deleteEnvironment(id: string): Promise<void> {
+      await this.manifestRepo.deleteEntriesByEnvironmentId(id);
+      await this.materializationRepo.deleteByEnvironmentId(id);
+      await this.connectionRepo.deleteConnectionsByEnvironmentId(id);
+      await this.packageRepo.deletePackagesByEnvironmentId(id);
+      await this.environmentRepo.deleteEnvironment(id);
    }
 
    // ==================== PACKAGES ====================
 
-   async listPackages(projectId: string): Promise<Package[]> {
-      return this.packageRepo.listPackages(projectId);
+   async listPackages(environmentId: string): Promise<Package[]> {
+      return this.packageRepo.listPackages(environmentId);
    }
 
    async getPackageById(id: string): Promise<Package | null> {
@@ -75,10 +75,10 @@ export class DuckDBRepository implements ResourceRepository {
    }
 
    async getPackageByName(
-      projectId: string,
+      environmentId: string,
       name: string,
    ): Promise<Package | null> {
-      return this.packageRepo.getPackageByName(projectId, name);
+      return this.packageRepo.getPackageByName(environmentId, name);
    }
 
    async createPackage(
@@ -98,25 +98,25 @@ export class DuckDBRepository implements ResourceRepository {
       const pkg = await this.packageRepo.getPackageById(id);
       if (pkg) {
          await this.manifestRepo.deleteEntriesByPackage(
-            pkg.projectId,
+            pkg.environmentId,
             pkg.name,
          );
          await this.materializationRepo.deleteByPackage(
-            pkg.projectId,
+            pkg.environmentId,
             pkg.name,
          );
       }
       await this.packageRepo.deletePackage(id);
    }
 
-   async deletePackagesByProjectId(id: string): Promise<void> {
-      return this.packageRepo.deletePackagesByProjectId(id);
+   async deletePackagesByEnvironmentId(id: string): Promise<void> {
+      return this.packageRepo.deletePackagesByEnvironmentId(id);
    }
 
    // ==================== CONNECTIONS ====================
 
-   async listConnections(projectId: string): Promise<Connection[]> {
-      return this.connectionRepo.listConnections(projectId);
+   async listConnections(environmentId: string): Promise<Connection[]> {
+      return this.connectionRepo.listConnections(environmentId);
    }
 
    async getConnectionById(id: string): Promise<Connection | null> {
@@ -124,10 +124,10 @@ export class DuckDBRepository implements ResourceRepository {
    }
 
    async getConnectionByName(
-      projectId: string,
+      environmentId: string,
       name: string,
    ): Promise<Connection | null> {
-      return this.connectionRepo.getConnectionByName(projectId, name);
+      return this.connectionRepo.getConnectionByName(environmentId, name);
    }
 
    async createConnection(
@@ -147,18 +147,18 @@ export class DuckDBRepository implements ResourceRepository {
       return this.connectionRepo.deleteConnection(id);
    }
 
-   async deleteConnectionsByProjectId(id: string): Promise<void> {
-      return this.connectionRepo.deleteConnectionsByProjectId(id);
+   async deleteConnectionsByEnvironmentId(id: string): Promise<void> {
+      return this.connectionRepo.deleteConnectionsByEnvironmentId(id);
    }
 
    // ==================== MATERIALIZATIONS ====================
 
    async listMaterializations(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       options?: { limit?: number; offset?: number },
    ): Promise<Materialization[]> {
-      return this.materializationRepo.list(projectId, packageName, options);
+      return this.materializationRepo.list(environmentId, packageName, options);
    }
 
    async getMaterializationById(id: string): Promise<Materialization | null> {
@@ -166,20 +166,20 @@ export class DuckDBRepository implements ResourceRepository {
    }
 
    async getActiveMaterialization(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<Materialization | null> {
-      return this.materializationRepo.getActive(projectId, packageName);
+      return this.materializationRepo.getActive(environmentId, packageName);
    }
 
    async createMaterialization(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       status: MaterializationStatus = "PENDING",
       metadata: Record<string, unknown> | null = null,
    ): Promise<Materialization> {
       return this.materializationRepo.create(
-         projectId,
+         environmentId,
          packageName,
          status,
          metadata,
@@ -206,10 +206,10 @@ export class DuckDBRepository implements ResourceRepository {
    // ==================== BUILD MANIFESTS ====================
 
    async listManifestEntries(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<ManifestEntry[]> {
-      return this.manifestRepo.listEntries(projectId, packageName);
+      return this.manifestRepo.listEntries(environmentId, packageName);
    }
 
    async upsertManifestEntry(

package/src/storage/duckdb/{ProjectRepository.ts → EnvironmentRepository.ts}

@@ -1,7 +1,7 @@
-import { Project } from "../DatabaseInterface";
+import { Environment } from "../DatabaseInterface";
 import { DuckDBConnection } from "./DuckDBConnection";
 
-export class ProjectRepository {
+export class EnvironmentRepository {
    constructor(private db: DuckDBConnection) {}
 
    private generateId(): string {
@@ -12,85 +12,85 @@ export class ProjectRepository {
       return new Date();
    }
 
-   async listProjects(): Promise<Project[]> {
+   async listEnvironments(): Promise<Environment[]> {
       const rows = await this.db.all<Record<string, unknown>>(
-         "SELECT * FROM projects ORDER BY name",
+         "SELECT * FROM environments ORDER BY name",
       );
-      return rows.map(this.mapToProject);
+      return rows.map(this.mapToEnvironment);
    }
 
-   async getProjectById(id: string): Promise<Project | null> {
+   async getEnvironmentById(id: string): Promise<Environment | null> {
       const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM projects WHERE id = ?",
+         "SELECT * FROM environments WHERE id = ?",
          [id],
       );
-      return row ? this.mapToProject(row) : null;
+      return row ? this.mapToEnvironment(row) : null;
    }
 
-   async getProjectByName(name: string): Promise<Project | null> {
+   async getEnvironmentByName(name: string): Promise<Environment | null> {
       const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM projects WHERE name = ?",
+         "SELECT * FROM environments WHERE name = ?",
          [name],
       );
-      return row ? this.mapToProject(row) : null;
+      return row ? this.mapToEnvironment(row) : null;
    }
 
-   async createProject(
-      project: Omit<Project, "id" | "createdAt" | "updatedAt">,
-   ): Promise<Project> {
+   async createEnvironment(
+      environment: Omit<Environment, "id" | "createdAt" | "updatedAt">,
+   ): Promise<Environment> {
       const id = this.generateId();
       const now = this.now();
 
       const params = [
          id,
-         project.name,
-         project.path,
-         project.description || null,
-         project.metadata ? JSON.stringify(project.metadata) : null,
+         environment.name,
+         environment.path,
+         environment.description || null,
+         environment.metadata ? JSON.stringify(environment.metadata) : null,
          now.toISOString(),
          now.toISOString(),
       ];
 
       try {
          await this.db.run(
-            `INSERT INTO projects (id, name, path, description, metadata, created_at, updated_at)
+            `INSERT INTO environments (id, name, path, description, metadata, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?, ?, ?)`,
             params,
          );
 
          return {
             id,
-            ...project,
+            ...environment,
             createdAt: now,
             updatedAt: now,
          };
       } catch (err: unknown) {
          const error = err as Error;
-         // If unique constraint violation, return existing project
+         // If unique constraint violation, return existing environment
          if (
             error.message?.includes("UNIQUE") ||
             error.message?.includes("Constraint")
          ) {
             const existing = await this.db.get<Record<string, unknown>>(
-               "SELECT * FROM projects WHERE name = ?",
-               [project.name],
+               "SELECT * FROM environments WHERE name = ?",
+               [environment.name],
             );
             if (existing) {
-               console.log("Returning existing project");
-               return this.mapToProject(existing);
+               console.log("Returning existing environment");
+               return this.mapToEnvironment(existing);
             }
          }
          throw error;
       }
    }
 
-   async updateProject(
+   async updateEnvironment(
       id: string,
-      updates: Partial<Project>,
-   ): Promise<Project> {
-      const existing = await this.getProjectById(id);
+      updates: Partial<Environment>,
+   ): Promise<Environment> {
+      const existing = await this.getEnvironmentById(id);
       if (!existing) {
-         throw new Error(`Project with id ${id} not found`);
+         throw new Error(`Environment with id ${id} not found`);
       }
 
       const now = this.now();
@@ -121,18 +121,18 @@ export class ProjectRepository {
       params.push(id);
 
       await this.db.run(
-         `UPDATE projects SET ${setClauses.join(", ")} WHERE id = ?`,
+         `UPDATE environments SET ${setClauses.join(", ")} WHERE id = ?`,
          params,
       );
 
-      return this.getProjectById(id) as Promise<Project>;
+      return this.getEnvironmentById(id) as Promise<Environment>;
    }
 
-   async deleteProject(id: string): Promise<void> {
-      await this.db.run("DELETE FROM projects WHERE id = ?", [id]);
+   async deleteEnvironment(id: string): Promise<void> {
+      await this.db.run("DELETE FROM environments WHERE id = ?", [id]);
    }
 
-   private mapToProject(row: Record<string, unknown>): Project {
+   private mapToEnvironment(row: Record<string, unknown>): Environment {
       return {
          id: row.id as string,
          name: row.name as string,

package/src/storage/duckdb/ManifestRepository.ts

@@ -6,7 +6,7 @@ import { DuckDBConnection } from "./DuckDBConnection";
  *
  * A build manifest records the materialized table produced by a specific build
  * of a package, linking it back to the Malloy source and connection that
- * generated it. Manifests are keyed by (project, package, build) and enable
+ * generated it. Manifests are keyed by (environment, package, build) and enable
  * downstream consumers to discover which physical tables correspond to a given
  * package version.
  */
@@ -19,32 +19,32 @@ export class ManifestRepository {
 
    /** Returns all manifest entries for a package, most recent first. */
    async listEntries(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<ManifestEntry[]> {
       const rows = await this.db.all<Record<string, unknown>>(
-         "SELECT * FROM build_manifests WHERE project_id = ? AND package_name = ? ORDER BY created_at DESC",
-         [projectId, packageName],
+         "SELECT * FROM build_manifests WHERE environment_id = ? AND package_name = ? ORDER BY created_at DESC",
+         [environmentId, packageName],
       );
       return rows.map(this.mapToEntry);
    }
 
    /** Looks up the manifest entry for a specific build, or null if none exists. */
    async getEntryByBuildId(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       buildId: string,
    ): Promise<ManifestEntry | null> {
       const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM build_manifests WHERE project_id = ? AND package_name = ? AND build_id = ?",
-         [projectId, packageName, buildId],
+         "SELECT * FROM build_manifests WHERE environment_id = ? AND package_name = ? AND build_id = ?",
+         [environmentId, packageName, buildId],
       );
       return row ? this.mapToEntry(row) : null;
    }
 
    /**
     * Inserts a new manifest entry, or updates the existing one if a row with
-    * the same (project, package, build) triple already exists. Uses INSERT ON
+    * the same (environment, package, build) triple already exists. Uses INSERT ON
     * CONFLICT to avoid the TOCTOU race of SELECT-then-INSERT/UPDATE.
     */
    async upsertEntry(
@@ -55,9 +55,9 @@ export class ManifestRepository {
       const iso = now.toISOString();
 
       const rows = await this.db.all<Record<string, unknown>>(
-         `INSERT INTO build_manifests (id, project_id, package_name, build_id, table_name, source_name, connection_name, created_at, updated_at)
+         `INSERT INTO build_manifests (id, environment_id, package_name, build_id, table_name, source_name, connection_name, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT (project_id, package_name, build_id)
+         ON CONFLICT (environment_id, package_name, build_id)
          DO UPDATE SET table_name = EXCLUDED.table_name,
                        source_name = EXCLUDED.source_name,
                        connection_name = EXCLUDED.connection_name,
@@ -65,7 +65,7 @@ export class ManifestRepository {
          RETURNING *`,
          [
             id,
-            entry.projectId,
+            entry.environmentId,
             entry.packageName,
             entry.buildId,
             entry.tableName,
@@ -84,21 +84,22 @@ export class ManifestRepository {
       await this.db.run("DELETE FROM build_manifests WHERE id = ?", [id]);
    }
 
-   /** Removes all manifest entries belonging to a project (used on project deletion). */
-   async deleteEntriesByProjectId(projectId: string): Promise<void> {
-      await this.db.run("DELETE FROM build_manifests WHERE project_id = ?", [
-         projectId,
-      ]);
+   /** Removes all manifest entries belonging to an environment (used on environment deletion). */
+   async deleteEntriesByEnvironmentId(environmentId: string): Promise<void> {
+      await this.db.run(
+         "DELETE FROM build_manifests WHERE environment_id = ?",
+         [environmentId],
+      );
    }
 
    /** Removes all manifest entries for a specific package. */
    async deleteEntriesByPackage(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<void> {
       await this.db.run(
-         "DELETE FROM build_manifests WHERE project_id = ? AND package_name = ?",
-         [projectId, packageName],
+         "DELETE FROM build_manifests WHERE environment_id = ? AND package_name = ?",
+         [environmentId, packageName],
       );
    }
 
@@ -106,7 +107,7 @@ export class ManifestRepository {
    private mapToEntry(row: Record<string, unknown>): ManifestEntry {
       return {
          id: row.id as string,
-         projectId: row.project_id as string,
+         environmentId: row.environment_id as string,
          packageName: row.package_name as string,
          buildId: row.build_id as string,
          tableName: row.table_name as string,

package/src/storage/duckdb/MaterializationRepository.ts

@@ -7,19 +7,19 @@ const TERMINAL_STATUSES: ReadonlySet<MaterializationStatus> = new Set([
    "CANCELLED",
 ]);
 
-function activeKeyFor(projectId: string, packageName: string): string {
-   return `${projectId}|${packageName}`;
+function activeKeyFor(environmentId: string, packageName: string): string {
+   return `${environmentId}|${packageName}`;
 }
 
 /**
- * Thrown when an atomic insert loses a race on (project, package) active
+ * Thrown when an atomic insert loses a race on (environment, package) active
  * materialization. Surfaced separately from a generic DB error so the service
  * layer can translate to `MaterializationConflictError`.
  */
 export class DuplicateActiveMaterializationError extends Error {
-   constructor(projectId: string, packageName: string) {
+   constructor(environmentId: string, packageName: string) {
       super(
-         `Active materialization already exists for (${projectId}, ${packageName})`,
+         `Active materialization already exists for (${environmentId}, ${packageName})`,
       );
    }
 }
@@ -27,7 +27,7 @@ export class DuplicateActiveMaterializationError extends Error {
 /**
  * DuckDB-backed repository for package materializations.
  *
- * A Materialization tracks a single build run for a (project, package) pair
+ * A Materialization tracks a single build run for an (environment, package) pair
  * through its lifecycle: PENDING -> RUNNING -> SUCCESS | FAILED | CANCELLED.
  */
 export class MaterializationRepository {
@@ -42,13 +42,13 @@ export class MaterializationRepository {
    }
 
    async list(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       options?: { limit?: number; offset?: number },
    ): Promise<Materialization[]> {
       let sql =
-         "SELECT * FROM materializations WHERE project_id = ? AND package_name = ? ORDER BY created_at DESC";
-      const params: unknown[] = [projectId, packageName];
+         "SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? ORDER BY created_at DESC";
+      const params: unknown[] = [environmentId, packageName];
       if (options?.limit !== undefined) {
          sql += " LIMIT ?";
          params.push(options.limit);
@@ -70,18 +70,18 @@ export class MaterializationRepository {
    }
 
    async getActive(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<Materialization | null> {
       const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM materializations WHERE project_id = ? AND package_name = ? AND status IN ('PENDING', 'RUNNING')",
-         [projectId, packageName],
+         "SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? AND status IN ('PENDING', 'RUNNING')",
+         [environmentId, packageName],
       );
       return row ? this.mapRow(row) : null;
    }
 
    async create(
-      projectId: string,
+      environmentId: string,
       packageName: string,
       status: MaterializationStatus = "PENDING",
       metadata: Record<string, unknown> | null = null,
@@ -91,21 +91,21 @@ export class MaterializationRepository {
       const iso = now.toISOString();
       // Set active_key iff the row is in a non-terminal state. The unique
       // index on active_key makes the race-free conditional insert: a second
-      // concurrent create on the same (project, package) fails here rather
+      // concurrent create on the same (environment, package) fails here rather
       // than in a check-then-write window.
       const activeKey = TERMINAL_STATUSES.has(status)
          ? null
-         : activeKeyFor(projectId, packageName);
+         : activeKeyFor(environmentId, packageName);
       const metadataJson = metadata ? JSON.stringify(metadata) : null;
 
       try {
          const rows = await this.db.all<Record<string, unknown>>(
-            `INSERT INTO materializations (id, project_id, package_name, status, active_key, metadata, created_at, updated_at)
+            `INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?)
             RETURNING *`,
             [
                id,
-               projectId,
+               environmentId,
                packageName,
                status,
                activeKey,
@@ -118,7 +118,7 @@ export class MaterializationRepository {
       } catch (err) {
          if (isUniqueViolation(err, "idx_materializations_active_key")) {
             throw new DuplicateActiveMaterializationError(
-               projectId,
+               environmentId,
                packageName,
             );
          }
@@ -146,11 +146,13 @@ export class MaterializationRepository {
          // Clear active_key on any transition to a terminal state; set it on
          // any transition to a non-terminal state. The unique index
          // guarantees we can never end up with two active rows for the same
-         // (project, package).
+         // (environment, package).
          if (TERMINAL_STATUSES.has(updates.status)) {
             setClauses.push(`active_key = NULL`);
          } else {
-            setClauses.push(`active_key = project_id || '|' || package_name`);
+            setClauses.push(
+               `active_key = environment_id || '|' || package_name`,
+            );
          }
       }
       if (updates.startedAt !== undefined) {
@@ -188,10 +190,11 @@ export class MaterializationRepository {
       return updated;
    }
 
-   async deleteByProjectId(projectId: string): Promise<void> {
-      await this.db.run("DELETE FROM materializations WHERE project_id = ?", [
-         projectId,
-      ]);
+   async deleteByEnvironmentId(environmentId: string): Promise<void> {
+      await this.db.run(
+         "DELETE FROM materializations WHERE environment_id = ?",
+         [environmentId],
+      );
    }
 
    async deleteById(id: string): Promise<void> {
@@ -199,12 +202,12 @@ export class MaterializationRepository {
    }
 
    async deleteByPackage(
-      projectId: string,
+      environmentId: string,
       packageName: string,
    ): Promise<void> {
       await this.db.run(
-         "DELETE FROM materializations WHERE project_id = ? AND package_name = ?",
-         [projectId, packageName],
+         "DELETE FROM materializations WHERE environment_id = ? AND package_name = ?",
+         [environmentId, packageName],
       );
    }
 
@@ -220,7 +223,7 @@ export class MaterializationRepository {
 
       return {
          id: row.id as string,
-         projectId: row.project_id as string,
+         environmentId: row.environment_id as string,
          packageName: row.package_name as string,
          status: row.status as MaterializationStatus,
          startedAt: row.started_at ? new Date(row.started_at as string) : null,