@malloy-publisher/server 0.0.196-dev → 0.0.196

package/src/service/{project.ts → environment.ts}

@@ -7,16 +7,16 @@ import { components } from "../api";
 import { API_PREFIX, README_NAME } from "../constants";
 import {
    ConnectionNotFoundError,
+   EnvironmentNotFoundError,
    PackageNotFoundError,
-   ProjectNotFoundError,
 } from "../errors";
 import { logger } from "../logger";
 import { URL_READER } from "../utils";
 import {
-   buildProjectMalloyConfig,
+   buildEnvironmentMalloyConfig,
    deleteDuckLakeConnectionFile,
+   EnvironmentMalloyConfig,
    InternalConnection,
-   ProjectMalloyConfig,
 } from "./connection";
 import { ApiConnection } from "./model";
 import { Package } from "./package";
@@ -34,7 +34,7 @@ interface PackageInfo {
 }
 
 type ApiPackage = components["schemas"]["Package"];
-type ApiProject = components["schemas"]["Project"];
+type ApiEnvironment = components["schemas"]["Environment"];
 type RetiredConnectionGeneration = {
    label: string;
    releaseConnections: () => Promise<void>;
@@ -43,60 +43,62 @@ type RetiredConnectionGeneration = {
 
 const RETIRED_CONNECTION_DRAIN_MS = 30_000;
 
-export class Project {
+export class Environment {
    private packages: Map<string, Package> = new Map();
-   // Lock ordering: connectionMutex (project) MUST be acquired before any
+   // Lock ordering: connectionMutex (environment) MUST be acquired before any
    // packageMutex. Connection updates may invalidate cached package
-   // MalloyConfigs and force reloads, so the project lock is the outer one.
+   // MalloyConfigs and force reloads, so the environment lock is the outer one.
    // Never acquire connectionMutex while holding a packageMutex — that's the
    // AB/BA deadlock path.
    private packageMutexes = new Map<string, Mutex>();
    private packageStatuses: Map<string, PackageInfo> = new Map();
-   private malloyConfig: ProjectMalloyConfig;
+   private malloyConfig: EnvironmentMalloyConfig;
    private connectionMutex = new Mutex();
    private retiredConnectionGenerations =
       new Set<RetiredConnectionGeneration>();
    private apiConnections: ApiConnection[];
-   private projectPath: string;
-   private projectName: string;
-   public metadata: ApiProject;
+   private environmentPath: string;
+   private environmentName: string;
+   public metadata: ApiEnvironment;
 
    constructor(
-      projectName: string,
-      projectPath: string,
-      malloyConfig: ProjectMalloyConfig,
+      environmentName: string,
+      environmentPath: string,
+      malloyConfig: EnvironmentMalloyConfig,
       apiConnections: InternalConnection[],
    ) {
-      this.projectName = projectName;
-      this.projectPath = projectPath;
+      this.environmentName = environmentName;
+      this.environmentPath = environmentPath;
       this.malloyConfig = malloyConfig;
       this.apiConnections = apiConnections;
       this.metadata = {
-         resource: `${API_PREFIX}/projects/${this.projectName}`,
-         name: this.projectName,
-         location: this.projectPath,
+         resource: `${API_PREFIX}/environments/${this.environmentName}`,
+         name: this.environmentName,
+         location: this.environmentPath,
       };
-      void this.reloadProjectMetadata();
+      void this.reloadEnvironmentMetadata();
    }
 
-   private async writeProjectReadme(readme?: string): Promise<void> {
+   private async writeEnvironmentReadme(readme?: string): Promise<void> {
       if (readme === undefined) return;
 
-      const readmePath = path.join(this.projectPath, "README.md");
+      const readmePath = path.join(this.environmentPath, "README.md");
 
       try {
          await fs.promises.writeFile(readmePath, readme, "utf-8");
-         logger.info(`Updated README.md for project ${this.projectName}`);
+         logger.info(
+            `Updated README.md for environment ${this.environmentName}`,
+         );
       } catch (err) {
          logger.error(`Failed to write README.md`, { error: err });
-         throw new Error(`Failed to update project README`);
+         throw new Error(`Failed to update environment README`);
       }
    }
 
-   public async update(payload: ApiProject) {
+   public async update(payload: ApiEnvironment) {
       if (payload.readme !== undefined) {
          this.metadata.readme = payload.readme;
-         await this.writeProjectReadme(payload.readme);
+         await this.writeEnvironmentReadme(payload.readme);
       }
 
       if (payload.materializationStorage !== undefined) {
@@ -104,24 +106,24 @@ export class Project {
       }
 
       // Handle connections update
-      // TODO: Update project connections should have its own API endpoint
+      // TODO: Update environment connections should have its own API endpoint
       if (payload.connections) {
          const payloadConnections = payload.connections;
          await this.runConnectionUpdateExclusive(async () => {
             logger.info(
-               `Updating ${payloadConnections.length} connections for project ${this.projectName}`,
+               `Updating ${payloadConnections.length} connections for environment ${this.environmentName}`,
             );
             const isUpdateConnectionRequest = true;
-            const nextMalloyConfig = buildProjectMalloyConfig(
+            const nextMalloyConfig = buildEnvironmentMalloyConfig(
                payloadConnections,
-               this.projectPath,
+               this.environmentPath,
                isUpdateConnectionRequest,
             );
 
             this.updateConnections(nextMalloyConfig);
 
             logger.info(
-               `Successfully updated connections for project ${this.projectName}`,
+               `Successfully updated connections for environment ${this.environmentName}`,
                {
                   apiConnections: this.apiConnections.length,
                   internalConnections: this.apiConnections.length,
@@ -134,49 +136,54 @@ export class Project {
    }
 
    static async create(
-      projectName: string,
-      projectPath: string,
+      environmentName: string,
+      environmentPath: string,
       connections: ApiConnection[],
-   ): Promise<Project> {
-      if (!(await fs.promises.stat(projectPath))?.isDirectory()) {
-         throw new ProjectNotFoundError(
-            `Project path ${projectPath} not found`,
+   ): Promise<Environment> {
+      if (!(await fs.promises.stat(environmentPath))?.isDirectory()) {
+         throw new EnvironmentNotFoundError(
+            `Environment path ${environmentPath} not found`,
          );
       }
 
-      logger.info(`Creating project with connection configuration`);
-      const malloyConfig = buildProjectMalloyConfig(connections, projectPath);
+      logger.info(`Creating environment with connection configuration`);
+      const malloyConfig = buildEnvironmentMalloyConfig(
+         connections,
+         environmentPath,
+      );
 
       logger.info(
-         `Loaded ${malloyConfig.apiConnections.length} connections for project ${projectName}`,
+         `Loaded ${malloyConfig.apiConnections.length} connections for environment ${environmentName}`,
          {
             apiConnections: malloyConfig.apiConnections,
          },
       );
 
-      const project = new Project(
-         projectName,
-         projectPath,
+      const environment = new Environment(
+         environmentName,
+         environmentPath,
          malloyConfig,
          malloyConfig.apiConnections,
       );
 
-      return project;
+      return environment;
    }
 
-   public async reloadProjectMetadata(): Promise<ApiProject> {
+   public async reloadEnvironmentMetadata(): Promise<ApiEnvironment> {
       let readme = "";
       try {
          readme = (
-            await fs.promises.readFile(path.join(this.projectPath, README_NAME))
+            await fs.promises.readFile(
+               path.join(this.environmentPath, README_NAME),
+            )
          ).toString();
       } catch {
          // Readme not found, so we'll just return an empty string
       }
       this.metadata = {
          ...this.metadata,
-         resource: `${API_PREFIX}/projects/${this.projectName}`,
-         name: this.projectName,
+         resource: `${API_PREFIX}/environments/${this.environmentName}`,
+         name: this.environmentName,
          readme,
       };
       return this.metadata;
@@ -190,14 +197,14 @@ export class Project {
    ): Promise<{ problems: LogMessage[]; sql?: string }> {
       // Place the virtual file in the model's directory so relative imports resolve correctly.
       const modelDir = path.dirname(
-         path.join(this.projectPath, packageName, modelName),
+         path.join(this.environmentPath, packageName, modelName),
       );
       const virtualUri = `file://${path.join(modelDir, "__compile_check.malloy")}`;
       const virtualUrl = new URL(virtualUri);
 
       // Read the full model file so the submitted source inherits the model's
       // complete namespace — imports, source definitions, queries, etc.
-      const modelPath = path.join(this.projectPath, packageName, modelName);
+      const modelPath = path.join(this.environmentPath, packageName, modelName);
       let modelContent = "";
       try {
          modelContent = await fs.promises.readFile(modelPath, "utf8");
@@ -222,7 +229,7 @@ export class Project {
 
       // Initialize Runtime with the package's active MalloyConfig so compile
       // checks see the same package-scoped duckdb as execution. This runtime
-      // borrows the package config; the package/project lifecycle owns release.
+      // borrows the package config; the package/environment lifecycle owns release.
       const runtime = new Runtime({
          urlReader: interceptingReader,
          config: pkg.getMalloyConfig(),
@@ -279,7 +286,7 @@ export class Project {
       );
    }
 
-   public getProjectMalloyConfig() {
+   public getEnvironmentMalloyConfig() {
       return this.malloyConfig.malloyConfig;
    }
 
@@ -336,7 +343,9 @@ export class Project {
    }
 
    public async listPackages(): Promise<ApiPackage[]> {
-      logger.debug("Listing packages", { projectPath: this.projectPath });
+      logger.debug("Listing packages", {
+         environmentPath: this.environmentPath,
+      });
       try {
          const packageMetadata = await Promise.all(
             Array.from(this.packageStatuses.keys()).map(async (packageName) => {
@@ -422,9 +431,9 @@ export class Project {
 
          try {
             logger.debug(`Loading package ${packageName}...`);
-            const packagePath = path.join(this.projectPath, packageName);
+            const packagePath = path.join(this.environmentPath, packageName);
             const _package = await Package.create(
-               this.projectName,
+               this.environmentName,
                packageName,
                packagePath,
                () => this.malloyConfig.malloyConfig,
@@ -453,7 +462,7 @@ export class Project {
    }
 
    public async addPackage(packageName: string) {
-      const packagePath = path.join(this.projectPath, packageName);
+      const packagePath = path.join(this.environmentPath, packageName);
       if (
          !(await fs.promises
             .access(packagePath)
@@ -464,7 +473,7 @@ export class Project {
          throw new PackageNotFoundError(`Package ${packageName} not found`);
       }
       logger.info(
-         `Adding package ${packageName} to project ${this.projectName}`,
+         `Adding package ${packageName} to environment ${this.environmentName}`,
          {
             packagePath,
             malloyConfig: this.malloyConfig.malloyConfig,
@@ -475,7 +484,7 @@ export class Project {
          this.packages.set(
             packageName,
             await Package.create(
-               this.projectName,
+               this.environmentName,
                packageName,
                packagePath,
                () => this.malloyConfig.malloyConfig,
@@ -494,7 +503,7 @@ export class Project {
       packageName: string,
       metadata: { name: string; description?: string },
    ): Promise<void> {
-      const packagePath = path.join(this.projectPath, packageName);
+      const packagePath = path.join(this.environmentPath, packageName);
       const manifestPath = path.join(packagePath, "publisher.json");
 
       try {
@@ -577,12 +586,12 @@ export class Project {
 
       if (packageStatus?.status === PackageStatus.LOADING) {
          logger.error("Package loading. Can't unload.", {
-            projectName: this.projectName,
+            environmentName: this.environmentName,
             packageName,
          });
          throw new Error(
             "Package loading. Can't unload. " +
-               this.projectName +
+               this.environmentName +
                " " +
                packageName,
          );
@@ -593,14 +602,18 @@ export class Project {
       await _package.getMalloyConfig().releaseConnections();
 
       try {
-         await fs.promises.rm(path.join(this.projectPath, packageName), {
+         await fs.promises.rm(path.join(this.environmentPath, packageName), {
             recursive: true,
             force: true,
          });
       } catch (err) {
          logger.error(
             "Error removing package directory while unloading package",
-            { error: err, projectName: this.projectName, packageName },
+            {
+               error: err,
+               environmentName: this.environmentName,
+               packageName,
+            },
          );
       }
 
@@ -610,7 +623,7 @@ export class Project {
    }
 
    public updateConnections(
-      malloyConfig: ProjectMalloyConfig,
+      malloyConfig: EnvironmentMalloyConfig,
       _apiConnections?: ApiConnection[],
       afterPreviousRelease?: () => Promise<void>,
    ): void {
@@ -620,7 +633,7 @@ export class Project {
 
       if (previousMalloyConfig !== malloyConfig) {
          this.retireConnectionGeneration(
-            `project ${this.projectName}`,
+            `environment ${this.environmentName}`,
             async () => {
                await previousMalloyConfig.releaseConnections();
                await afterPreviousRelease?.();
@@ -642,18 +655,18 @@ export class Project {
 
       if (index !== -1) {
          logger.info(
-            `Removed connection ${connectionName} from project ${this.projectName}`,
+            `Removed connection ${connectionName} from environment ${this.environmentName}`,
          );
       } else {
          logger.warn(
-            `Connection ${connectionName} not found in project ${this.projectName}`,
+            `Connection ${connectionName} not found in environment ${this.environmentName}`,
          );
       }
    }
 
    public async closeAllConnections(): Promise<void> {
       // Release the package-scoped MalloyConfigs (each holds the package's own
-      // sandbox `duckdb` connection) before tearing down the project config
+      // sandbox `duckdb` connection) before tearing down the environment config
       // they wrap. Without this, hard unload leaks per-package DuckDB handles.
       const packageReleases = await Promise.allSettled(
          Array.from(this.packages.values(), (pkg) =>
@@ -663,7 +676,7 @@ export class Project {
       for (const result of packageReleases) {
          if (result.status === "rejected") {
             logger.error(
-               `Error closing package connections for project ${this.projectName}`,
+               `Error closing package connections for environment ${this.environmentName}`,
                { error: result.reason },
             );
          }
@@ -675,7 +688,7 @@ export class Project {
          await this.malloyConfig.releaseConnections();
       } catch (error) {
          logger.error(
-            `Error closing connections for project ${this.projectName}`,
+            `Error closing connections for environment ${this.environmentName}`,
             { error },
          );
       }
@@ -683,10 +696,12 @@ export class Project {
 
       this.apiConnections = [];
 
-      logger.info(`Closed all connections for project ${this.projectName}`);
+      logger.info(
+         `Closed all connections for environment ${this.environmentName}`,
+      );
    }
 
-   public async serialize(): Promise<ApiProject> {
+   public async serialize(): Promise<ApiEnvironment> {
       return {
          ...this.metadata,
          connections: this.listApiConnections(),
@@ -696,17 +711,17 @@ export class Project {
 
    public async deleteDuckDBConnection(connectionName: string): Promise<void> {
       const duckdbPath = path.join(
-         this.projectPath,
+         this.environmentPath,
          `${connectionName}.duckdb`,
       );
       try {
          await fs.promises.rm(duckdbPath, { force: true });
          logger.info(
-            `Removed DuckDB connection file ${connectionName} from project ${this.projectName}`,
+            `Removed DuckDB connection file ${connectionName} from environment ${this.environmentName}`,
          );
       } catch (error) {
          logger.error(
-            `Failed to remove DuckDB connection file ${connectionName} from project ${this.projectName}`,
+            `Failed to remove DuckDB connection file ${connectionName} from environment ${this.environmentName}`,
             { error },
          );
       }
@@ -715,9 +730,9 @@ export class Project {
    public async deleteDuckLakeConnection(
       connectionName: string,
    ): Promise<void> {
-      await deleteDuckLakeConnectionFile(connectionName, this.projectPath);
+      await deleteDuckLakeConnectionFile(connectionName, this.environmentPath);
       logger.info(
-         `Removed DuckLake connection ${connectionName} from project ${this.projectName}`,
+         `Removed DuckLake connection ${connectionName} from environment ${this.environmentName}`,
       );
    }
 }

package/src/service/{project_compile.spec.ts → environment_compile.spec.ts}

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import fs from "fs";
 import path from "path";
-import { extractPreamble, extractPreambleFromSource } from "./project";
+import { extractPreamble, extractPreambleFromSource } from "./environment";
 
 describe("extractPreambleFromSource", () => {
    it("should extract pragmas and imports before a source definition", () => {