@malloy-publisher/server 0.0.195 → 0.0.196

package/src/config.ts

@@ -18,7 +18,7 @@ export type Connection = {
    type: string;
 };
 
-export type Project = {
+export type Environment = {
    name: string;
    packages: Package[];
    connections?: Connection[];
@@ -26,10 +26,10 @@ export type Project = {
 
 export type PublisherConfig = {
    frozenConfig: boolean;
-   projects: Project[];
+   environments: Environment[];
 };
 
-export type ProcessedProject = {
+export type ProcessedEnvironment = {
    name: string;
    packages: Package[];
    connections: ApiConnection[];
@@ -37,7 +37,7 @@ export type ProcessedProject = {
 
 export type ProcessedPublisherConfig = {
    frozenConfig: boolean;
-   projects: ProcessedProject[];
+   environments: ProcessedEnvironment[];
 };
 
 function substituteEnvVars(value: string): string {
@@ -81,7 +81,7 @@ export const getPublisherConfig = (serverRoot: string): PublisherConfig => {
    if (!fs.existsSync(publisherConfigPath)) {
       return {
          frozenConfig: false,
-         projects: [],
+         environments: [],
       };
    }
 
@@ -101,39 +101,58 @@ export const getPublisherConfig = (serverRoot: string): PublisherConfig => {
       );
       return {
          frozenConfig: false,
-         projects: [],
+         environments: [],
       };
    }
 
    // Process environment variables in config values
    const processedConfig = processConfigValue(rawConfig);
 
+   // TODO: Remove this during projects cleanup
+   // Back-compat: the top-level key was renamed `projects` → `environments`.
+   // If a config still uses the old key, accept it once with a deprecation
+   // warning so existing on-disk configs don't silently parse as empty.
    if (
       processedConfig &&
       typeof processedConfig === "object" &&
-      "projects" in processedConfig &&
-      processedConfig.projects &&
-      typeof processedConfig.projects === "object" &&
-      !Array.isArray(processedConfig.projects)
+      !("environments" in processedConfig) &&
+      "projects" in processedConfig
+   ) {
+      logger.warn(
+         `${PUBLISHER_CONFIG_NAME} uses deprecated "projects" key; rename to "environments".`,
+      );
+      (processedConfig as Record<string, unknown>).environments = (
+         processedConfig as Record<string, unknown>
+      ).projects;
+   }
+
+   if (
+      processedConfig &&
+      typeof processedConfig === "object" &&
+      "environments" in processedConfig &&
+      processedConfig.environments &&
+      typeof processedConfig.environments === "object" &&
+      !Array.isArray(processedConfig.environments)
    ) {
       logger.error(
-         `Invalid ${PUBLISHER_CONFIG_NAME}: projects must be an array. Using default empty config.`,
+         `Invalid ${PUBLISHER_CONFIG_NAME}: the "environments" field must be a JSON array. Using default empty config.`,
       );
       return {
          frozenConfig: false,
-         projects: [],
+         environments: [],
       };
    }
 
-   // Ensure projects is an array
-   let projects: unknown[] = [];
+   // Ensure environments is an array
+   let environments: unknown[] = [];
    if (
       processedConfig &&
       typeof processedConfig === "object" &&
-      "projects" in processedConfig &&
-      Array.isArray((processedConfig as { projects: unknown }).projects)
+      "environments" in processedConfig &&
+      Array.isArray((processedConfig as { environments: unknown }).environments)
    ) {
-      projects = (processedConfig as { projects: unknown[] }).projects;
+      environments = (processedConfig as { environments: unknown[] })
+         .environments;
    }
 
    let frozenConfig = false;
@@ -149,7 +168,7 @@ export const getPublisherConfig = (serverRoot: string): PublisherConfig => {
 
    return {
       frozenConfig,
-      projects,
+      environments,
    } as PublisherConfig;
 };
 
@@ -168,20 +187,22 @@ export const isPublisherConfigFrozen = (serverRoot: string) => {
 
 export const getConnectionsFromPublisherConfig = (
    serverRoot: string,
-   projectName: string,
+   environmentName: string,
 ): Connection[] => {
    try {
       const publisherConfig = getPublisherConfig(serverRoot);
-      if (!Array.isArray(publisherConfig.projects)) {
+      if (!Array.isArray(publisherConfig.environments)) {
          return [];
       }
-      const project = publisherConfig.projects.find(
-         (p) => p && p.name === projectName,
+      const environment = publisherConfig.environments.find(
+         (e) => e && e.name === environmentName,
       );
-      return Array.isArray(project?.connections) ? project.connections : [];
+      return Array.isArray(environment?.connections)
+         ? environment.connections
+         : [];
    } catch (error) {
       logger.error(
-         `Error getting connections for project "${projectName}" from ${PUBLISHER_CONFIG_NAME}`,
+         `Error getting connections for environment "${environmentName}" from ${PUBLISHER_CONFIG_NAME}`,
          { error },
       );
       return [];
@@ -228,59 +249,59 @@ export const getProcessedPublisherConfig = (
 ): ProcessedPublisherConfig => {
    const rawConfig = getPublisherConfig(serverRoot);
 
-   // Ensure projects is an array
-   if (!Array.isArray(rawConfig.projects)) {
+   // Ensure environments is an array
+   if (!Array.isArray(rawConfig.environments)) {
       logger.warn(
-         `Invalid ${PUBLISHER_CONFIG_NAME}: projects must be an array. Using empty array.`,
+         `Invalid ${PUBLISHER_CONFIG_NAME}: the "environments" field must be a JSON array. Using empty array.`,
       );
       return {
          frozenConfig: rawConfig.frozenConfig ?? false,
-         projects: [],
+         environments: [],
       };
    }
 
-   // Filter and validate projects, skipping invalid ones
-   const validProjects: ProcessedProject[] = [];
-   for (const project of rawConfig.projects) {
-      if (!project || typeof project !== "object") {
+   // Filter and validate environments, skipping invalid ones
+   const validEnvironments: ProcessedEnvironment[] = [];
+   for (const environment of rawConfig.environments) {
+      if (!environment || typeof environment !== "object") {
          logger.warn(
-            `Invalid project in ${PUBLISHER_CONFIG_NAME}: project must be an object. Skipping.`,
+            `Invalid environment in ${PUBLISHER_CONFIG_NAME}: entry must be an object. Skipping.`,
          );
          continue;
       }
 
-      if (!project.name || typeof project.name !== "string") {
+      if (!environment.name || typeof environment.name !== "string") {
          logger.warn(
-            `Invalid project in ${PUBLISHER_CONFIG_NAME}: missing or invalid "name" field. Skipping project.`,
-            { project },
+            `Invalid environment in ${PUBLISHER_CONFIG_NAME}: missing or invalid "name" field. Skipping entry.`,
+            { environment },
          );
          continue;
       }
 
-      if (!Array.isArray(project.packages)) {
+      if (!Array.isArray(environment.packages)) {
          logger.warn(
-            `Invalid project "${project.name}" in ${PUBLISHER_CONFIG_NAME}: missing or invalid "packages" field (must be an array). Skipping project.`,
+            `Invalid environment "${environment.name}" in ${PUBLISHER_CONFIG_NAME}: missing or invalid "packages" field (must be an array). Skipping entry.`,
          );
          continue;
       }
 
       // Validate packages have required fields
-      const validPackages = project.packages.filter((pkg) => {
+      const validPackages = environment.packages.filter((pkg) => {
          if (!pkg || typeof pkg !== "object") {
             logger.warn(
-               `Invalid package in project "${project.name}": package must be an object. Skipping.`,
+               `Invalid package in environment "${environment.name}": package must be an object. Skipping.`,
             );
             return false;
          }
          if (!pkg.name || typeof pkg.name !== "string") {
             logger.warn(
-               `Invalid package in project "${project.name}": missing or invalid "name" field. Skipping.`,
+               `Invalid package in environment "${environment.name}": missing or invalid "name" field. Skipping.`,
             );
             return false;
          }
          if (!pkg.location || typeof pkg.location !== "string") {
             logger.warn(
-               `Invalid package "${pkg.name}" in project "${project.name}": missing or invalid "location" field. Skipping.`,
+               `Invalid package "${pkg.name}" in environment "${environment.name}": missing or invalid "location" field. Skipping.`,
             );
             return false;
          }
@@ -289,22 +310,22 @@ export const getProcessedPublisherConfig = (
 
       if (validPackages.length === 0) {
          logger.warn(
-            `Project "${project.name}" has no valid packages. Skipping project.`,
+            `Environment "${environment.name}" has no valid packages. Skipping entry.`,
          );
          continue;
       }
 
-      validProjects.push({
-         name: project.name,
+      validEnvironments.push({
+         name: environment.name,
          packages: validPackages,
          connections: convertConnectionsToApiConnections(
-            project.connections || [],
+            environment.connections || [],
          ),
       });
    }
 
    return {
       frozenConfig: rawConfig.frozenConfig ?? false,
-      projects: validProjects,
+      environments: validEnvironments,
    };
 };

package/src/controller/compile.controller.ts

@@ -1,22 +1,25 @@
 import type { LogMessage } from "@malloydata/malloy";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 
 export class CompileController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
 
-   constructor(projectStore: ProjectStore) {
-      this.projectStore = projectStore;
+   constructor(environmentStore: EnvironmentStore) {
+      this.environmentStore = environmentStore;
    }
 
    public async compile(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       modelName: string,
       source: string,
       includeSql: boolean = false,
    ): Promise<{ status: string; problems: LogMessage[]; sql?: string }> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const { problems, sql } = await project.compileSource(
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const { problems, sql } = await environment.compileSource(
          packageName,
          modelName,
          source,

package/src/controller/connection.controller.ts

@@ -10,8 +10,8 @@ import {
    getSchemasForConnection,
    listTablesForSchema,
 } from "../service/db_utils";
-import type { Project } from "../service/project";
-import { ProjectStore } from "../service/project_store";
+import type { Environment } from "../service/environment";
+import { EnvironmentStore } from "../service/environment_store";
 
 type ApiConnection = components["schemas"]["Connection"];
 type ApiConnectionStatus = components["schemas"]["ConnectionStatus"];
@@ -103,19 +103,19 @@ function validateAdminAuthoredConnection(
 }
 
 export class ConnectionController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
    private connectionService: ConnectionService;
-   constructor(projectStore: ProjectStore) {
-      this.projectStore = projectStore;
-      this.connectionService = new ConnectionService(projectStore);
+   constructor(environmentStore: EnvironmentStore) {
+      this.environmentStore = environmentStore;
+      this.connectionService = new ConnectionService(environmentStore);
    }
 
    /**
     * Gets the appropriate Malloy connection for a given connection name.
-    * For DuckDB connections, retrieves from package level; for others, from project level.
+    * For DuckDB connections, retrieves from package level; for others, from environment level.
     */
    private getApiConnectionForLookup(
-      project: Project,
+      environment: Environment,
       connectionName: string,
    ): ApiConnection {
       if (connectionName === "duckdb") {
@@ -125,35 +125,38 @@ export class ConnectionController {
             duckdbConnection: { attachedDatabases: [] },
          };
       }
-      return project.getApiConnection(connectionName);
+      return environment.getApiConnection(connectionName);
    }
 
    private async getMalloyConnection(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       packageName?: string,
    ): Promise<Connection> {
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
 
       // "duckdb" is the per-package sandbox; its rootDirectory is the
-      // package's directory. There is no project-level "duckdb" — the name is
+      // package's directory. There is no environment-level "duckdb" — the name is
       // reserved at config time. So the lookup is intrinsically per-package
       // and the caller must say which package to use.
       if (connectionName === "duckdb") {
-         const packages = await project.listPackages();
+         const packages = await environment.listPackages();
          if (packages.length === 0) {
-            // Fall through to project; this will surface the standard
+            // Fall through to environment; this will surface the standard
             // "connection not found" rather than silently inventing one.
-            return await project.getMalloyConnection(connectionName);
+            return await environment.getMalloyConnection(connectionName);
          }
          if (packageName) {
             const known = packages.some((p) => p.name === packageName);
             if (!known) {
                throw new BadRequestError(
-                  `Package "${packageName}" not found in project "${projectName}"`,
+                  `Package "${packageName}" not found in environment "${environmentName}"`,
                );
             }
-            const pkg = await project.getPackage(packageName);
+            const pkg = await environment.getPackage(packageName);
             return await pkg.getMalloyConnection(connectionName);
          }
          if (packages.length === 1) {
@@ -161,15 +164,15 @@ export class ConnectionController {
             if (!onlyPackage) {
                throw new ConnectionError("Package name is undefined");
             }
-            const pkg = await project.getPackage(onlyPackage);
+            const pkg = await environment.getPackage(onlyPackage);
             return await pkg.getMalloyConnection(connectionName);
          }
          throw new BadRequestError(
-            `Ambiguous "duckdb" connection lookup: project "${projectName}" has multiple packages. ` +
-               `Use /projects/${projectName}/packages/{packageName}/connections/duckdb/... to disambiguate.`,
+            `Ambiguous "duckdb" connection lookup: environment "${environmentName}" has multiple packages. ` +
+               `Use /environments/${environmentName}/packages/{packageName}/connections/duckdb/... to disambiguate.`,
          );
       } else {
-         return await project.getMalloyConnection(connectionName);
+         return await environment.getMalloyConnection(connectionName);
       }
    }
 
@@ -188,7 +191,7 @@ export class ConnectionController {
                fetchTableSchema: (
                   tableKey: string,
                   tablePath: string,
-               ) => Promise<TableSourceDef | undefined>;
+               ) => Promise<TableSourceDef | string | undefined>;
             }
          ).fetchTableSchema(tableKey, tablePath);
          if (!source) {
@@ -198,6 +201,7 @@ export class ConnectionController {
          if (typeof source === "string") {
             throw new ConnectionError(source);
          }
+
          return {
             source: JSON.stringify(source),
             resource: tablePath,
@@ -223,39 +227,50 @@ export class ConnectionController {
    }
 
    public async getConnection(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
    ): Promise<ApiConnection> {
-      if (!projectName || !connectionName) {
+      if (!environmentName || !connectionName) {
          throw new BadRequestError("Connection payload is required");
       }
       // Prefer the in-memory API connection (which was materialized by the
-      // project on load and carries `attributes`). The DB row stores the
+      // environment on load and carries `attributes`). The DB row stores the
       // raw config and FK columns, which aren't the ApiConnection shape.
-      const project = await this.projectStore.getProject(projectName, false);
-      return project.getApiConnection(connectionName);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      return environment.getApiConnection(connectionName);
    }
 
-   public async listConnections(projectName: string): Promise<ApiConnection[]> {
-      const project = await this.projectStore.getProject(projectName, false);
-      return project.listApiConnections();
+   public async listConnections(
+      environmentName: string,
+   ): Promise<ApiConnection[]> {
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      return environment.listApiConnections();
    }
 
    // Lists schemas (namespaces) available in a connection.
    // For "duckdb", the per-package sandbox, packageName disambiguates which
-   // package's DuckDB to browse in a multi-package project.
+   // package's DuckDB to browse in a multi-package environment.
    public async listSchemas(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       packageName?: string,
    ): Promise<ApiSchema[]> {
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
       const connection = this.getApiConnectionForLookup(
-         project,
+         environment,
          connectionName,
       );
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
@@ -266,19 +281,22 @@ export class ConnectionController {
    // Lists tables available in a schema. For postgres the schema is usually "public".
    // packageName disambiguates per-package "duckdb" lookups (see listSchemas).
    public async listTables(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       schemaName: string,
       tableNames?: string[],
       packageName?: string,
    ): Promise<ApiTable[]> {
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
       const connection = this.getApiConnectionForLookup(
-         project,
+         environment,
          connectionName,
       );
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
@@ -292,13 +310,13 @@ export class ConnectionController {
    }
 
    public async getConnectionSqlSource(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       sqlStatement: string,
       packageName?: string,
    ): Promise<ApiSqlSource> {
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
@@ -329,21 +347,24 @@ export class ConnectionController {
    }
 
    public async getTable(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       schemaName: string,
       tablePath: string,
       packageName?: string,
    ): Promise<ApiTable> {
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
       // Use getApiConnection to get the unwrapped ApiConnection config, consistent with listSchemas and listTables.
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
       const connection = this.getApiConnectionForLookup(
-         project,
+         environment,
          connectionName,
       );
 
@@ -415,14 +436,14 @@ export class ConnectionController {
    }
 
    public async getConnectionQueryData(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       sqlStatement: string,
       options: string,
       packageName?: string,
    ): Promise<ApiQueryData> {
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
@@ -449,13 +470,13 @@ export class ConnectionController {
    }
 
    public async getConnectionTemporaryTable(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       sqlStatement: string,
       packageName?: string,
    ): Promise<ApiTemporaryTable> {
       const malloyConnection = await this.getMalloyConnection(
-         projectName,
+         environmentName,
          connectionName,
          packageName,
       );
@@ -509,7 +530,7 @@ export class ConnectionController {
    }
 
    public async addConnection(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       connectionConfig: ApiConnection,
    ): Promise<{ message: string }> {
@@ -529,11 +550,11 @@ export class ConnectionController {
       validateAdminAuthoredConnection(connectionName, connectionConfig);
 
       logger.info(
-         `Creating connection "${connectionName}" in project "${projectName}"`,
+         `Creating connection "${connectionName}" in environment "${environmentName}"`,
       );
 
       await this.connectionService.addConnection(
-         projectName,
+         environmentName,
          connectionName,
          connectionConfig,
       );
@@ -544,7 +565,7 @@ export class ConnectionController {
    }
 
    public async updateConnection(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
       connection: Partial<ApiConnection>,
    ): Promise<{ message: string }> {
@@ -556,11 +577,11 @@ export class ConnectionController {
       validateAdminAuthoredConnection(connectionName, connection);
 
       logger.info(
-         `Updating connection "${connectionName}" in project "${projectName}"`,
+         `Updating connection "${connectionName}" in environment "${environmentName}"`,
       );
 
       await this.connectionService.updateConnection(
-         projectName,
+         environmentName,
          connectionName,
          connection,
       );
@@ -571,15 +592,15 @@ export class ConnectionController {
    }
 
    public async deleteConnection(
-      projectName: string,
+      environmentName: string,
       connectionName: string,
    ): Promise<{ message: string }> {
       logger.info(
-         `Deleting connection "${connectionName}" from project "${projectName}"`,
+         `Deleting connection "${connectionName}" from environment "${environmentName}"`,
       );
 
       await this.connectionService.deleteConnection(
-         projectName,
+         environmentName,
          connectionName,
       );
 

package/src/controller/database.controller.ts

@@ -1,21 +1,24 @@
 import { components } from "../api";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 
 type ApiDatabase = components["schemas"]["Database"];
 
 export class DatabaseController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
 
-   constructor(projectStore: ProjectStore) {
-      this.projectStore = projectStore;
+   constructor(environmentStore: EnvironmentStore) {
+      this.environmentStore = environmentStore;
    }
 
    public async listDatabases(
-      projectName: string,
+      environmentName: string,
       packageName: string,
    ): Promise<ApiDatabase[]> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const p = await project.getPackage(packageName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const p = await environment.getPackage(packageName, false);
       return p.listDatabases();
    }
 }