@malloy-publisher/server 0.0.196-dev → 0.0.197-dev

package/src/controller/manifest.controller.ts

@@ -1,29 +1,38 @@
+import { EnvironmentStore } from "../service/environment_store";
 import { ManifestService } from "../service/manifest_service";
-import { ProjectStore } from "../service/project_store";
-import { resolveProjectId } from "../service/resolve_project";
+import { resolveEnvironmentId } from "../service/resolve_environment";
 
 export class ManifestController {
    constructor(
-      private projectStore: ProjectStore,
+      private environmentStore: EnvironmentStore,
       private manifestService: ManifestService,
    ) {}
 
-   async getManifest(projectName: string, packageName: string) {
-      const repository = this.projectStore.storageManager.getRepository();
-      const projectId = await resolveProjectId(repository, projectName);
+   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 project = await this.projectStore.getProject(projectName, false);
-      await project.getPackage(packageName, false);
-      return this.manifestService.getManifest(projectId, packageName);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      await environment.getPackage(packageName, false);
+      return this.manifestService.getManifest(environmentId, packageName);
    }
 
-   async reloadManifest(projectName: string, packageName: string) {
-      const repository = this.projectStore.storageManager.getRepository();
-      const projectId = await resolveProjectId(repository, projectName);
+   async reloadManifest(environmentName: string, packageName: string) {
+      const repository = this.environmentStore.storageManager.getRepository();
+      const environmentId = await resolveEnvironmentId(
+         repository,
+         environmentName,
+      );
       return this.manifestService.reloadManifest(
-         projectId,
+         environmentId,
          packageName,
-         projectName,
+         environmentName,
       );
    }
 }

package/src/controller/materialization.controller.ts

@@ -5,13 +5,13 @@ export class MaterializationController {
    constructor(private materializationService: MaterializationService) {}
 
    async createMaterialization(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       body: Record<string, unknown>,
    ) {
       const options = this.validateCreateBody(body);
       return this.materializationService.createMaterialization(
-         projectName,
+         environmentName,
          packageName,
          options,
       );
@@ -38,73 +38,73 @@ export class MaterializationController {
    }
 
    async startMaterialization(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       materializationId: string,
    ) {
       return this.materializationService.startMaterialization(
-         projectName,
+         environmentName,
          packageName,
          materializationId,
       );
    }
 
    async stopMaterialization(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       materializationId: string,
    ) {
       return this.materializationService.stopMaterialization(
-         projectName,
+         environmentName,
          packageName,
          materializationId,
       );
    }
 
    async listMaterializations(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       options?: { limit?: number; offset?: number },
    ) {
       return this.materializationService.listMaterializations(
-         projectName,
+         environmentName,
          packageName,
          options,
       );
    }
 
    async getMaterialization(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       materializationId: string,
    ) {
       return this.materializationService.getMaterialization(
-         projectName,
+         environmentName,
          packageName,
          materializationId,
       );
    }
 
    async deleteMaterialization(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       materializationId: string,
    ) {
       return this.materializationService.deleteMaterialization(
-         projectName,
+         environmentName,
          packageName,
          materializationId,
       );
    }
 
    async teardownPackage(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       body: Record<string, unknown>,
    ) {
       const options = this.validateTeardownBody(body);
       return this.materializationService.teardownPackage(
-         projectName,
+         environmentName,
          packageName,
          options,
       );

package/src/controller/model.controller.ts

@@ -1,6 +1,6 @@
 import { components } from "../api";
 import { ModelNotFoundError } from "../errors";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 import type { FilterParams } from "../service/filter";
 
 type ApiNotebook = components["schemas"]["Notebook"];
@@ -8,38 +8,47 @@ type ApiModel = components["schemas"]["Model"];
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
 type ApiRawNotebook = components["schemas"]["RawNotebook"];
 export class ModelController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
 
-   constructor(projectStore: ProjectStore) {
-      this.projectStore = projectStore;
+   constructor(environmentStore: EnvironmentStore) {
+      this.environmentStore = environmentStore;
    }
 
    public async listModels(
-      projectName: string,
+      environmentName: string,
       packageName: string,
    ): Promise<ApiModel[]> {
-      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.listModels();
    }
 
    public async listNotebooks(
-      projectName: string,
+      environmentName: string,
       packageName: string,
    ): Promise<ApiNotebook[]> {
-      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.listNotebooks();
    }
 
    public async getModel(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       modelPath: string,
    ): Promise<ApiCompiledModel> {
       try {
-         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);
          const model = p.getModel(modelPath);
          if (!model) {
             throw new ModelNotFoundError(`${modelPath} does not exist`);
@@ -55,18 +64,21 @@ export class ModelController {
          }
          // Wrap other errors with more context
          throw new Error(
-            `Failed to get model ${modelPath} from package ${packageName} in project ${projectName}: ${error}`,
+            `Failed to get model ${modelPath} from package ${packageName} in environment ${environmentName}: ${error}`,
          );
       }
    }
 
    public async getNotebook(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       notebookPath: string,
    ): Promise<ApiRawNotebook> {
-      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);
       const model = p.getModel(notebookPath);
       if (!model) {
          throw new ModelNotFoundError(`${notebookPath} does not exist`);
@@ -79,7 +91,7 @@ export class ModelController {
    }
 
    public async executeNotebookCell(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       notebookPath: string,
       cellIndex: number,
@@ -92,8 +104,11 @@ export class ModelController {
       result?: string;
       newSources?: string[];
    }> {
-      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);
       const model = p.getModel(notebookPath);
       if (!model) {
          throw new ModelNotFoundError(`${notebookPath} does not exist`);

package/src/controller/package.controller.ts

@@ -3,59 +3,78 @@ import { components } from "../api";
 import { PUBLISHER_DATA_DIR } from "../constants";
 import { BadRequestError, FrozenConfigError } from "../errors";
 import { logger } from "../logger";
+import { EnvironmentStore } from "../service/environment_store";
 import { ManifestService } from "../service/manifest_service";
-import { ProjectStore } from "../service/project_store";
 
 type ApiPackage = components["schemas"]["Package"];
 
 export class PackageController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
    private manifestService: ManifestService;
 
-   constructor(projectStore: ProjectStore, manifestService: ManifestService) {
-      this.projectStore = projectStore;
+   constructor(
+      environmentStore: EnvironmentStore,
+      manifestService: ManifestService,
+   ) {
+      this.environmentStore = environmentStore;
       this.manifestService = manifestService;
    }
 
-   public async listPackages(projectName: string): Promise<ApiPackage[]> {
-      const project = await this.projectStore.getProject(projectName, false);
-      return project.listPackages();
+   public async listPackages(environmentName: string): Promise<ApiPackage[]> {
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      return environment.listPackages();
    }
 
    public async getPackage(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       reload: boolean,
    ): Promise<ApiPackage> {
-      const project = await this.projectStore.getProject(projectName, false);
-      const _package = await project.getPackage(packageName, reload);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const _package = await environment.getPackage(packageName, reload);
       const packageLocation = _package.getPackageMetadata().location;
       if (reload && packageLocation) {
-         await this.downloadPackage(projectName, packageName, packageLocation);
+         await this.downloadPackage(
+            environmentName,
+            packageName,
+            packageLocation,
+         );
       }
       return _package.getPackageMetadata();
    }
 
    async addPackage(
-      projectName: string,
+      environmentName: string,
       body: ApiPackage,
       options?: { autoLoadManifest?: boolean },
    ) {
-      if (this.projectStore.publisherConfigIsFrozen) {
+      if (this.environmentStore.publisherConfigIsFrozen) {
          throw new FrozenConfigError();
       }
       if (!body.name) {
          throw new BadRequestError("Package name is required");
       }
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
       if (body.location) {
-         await this.downloadPackage(projectName, body.name, body.location);
+         await this.downloadPackage(environmentName, body.name, body.location);
       }
-      const result = await project.addPackage(body.name);
-      await this.projectStore.addPackageToDatabase(projectName, body.name);
+      const result = await environment.addPackage(body.name);
+      await this.environmentStore.addPackageToDatabase(
+         environmentName,
+         body.name,
+      );
 
       if (options?.autoLoadManifest === true) {
-         await this.tryLoadExistingManifest(projectName, body.name);
+         await this.tryLoadExistingManifest(environmentName, body.name);
       }
 
       return result;
@@ -67,47 +86,52 @@ export class PackageController {
     * persist references resolve to the materialized tables immediately.
     */
    private async tryLoadExistingManifest(
-      projectName: string,
+      environmentName: string,
       packageName: string,
    ): Promise<void> {
       try {
-         const repository = this.projectStore.storageManager.getRepository();
-         const dbProject = await repository.getProjectByName(projectName);
-         if (!dbProject) return;
+         const repository =
+            this.environmentStore.storageManager.getRepository();
+         const dbEnvironment =
+            await repository.getEnvironmentByName(environmentName);
+         if (!dbEnvironment) return;
 
          const manifest = await this.manifestService.getManifest(
-            dbProject.id,
+            dbEnvironment.id,
             packageName,
          );
          if (Object.keys(manifest.entries).length === 0) return;
 
          await this.manifestService.reloadManifest(
-            dbProject.id,
+            dbEnvironment.id,
             packageName,
-            projectName,
+            environmentName,
          );
          logger.info("Auto-loaded existing manifest for added package", {
-            projectName,
+            environmentName,
             packageName,
             entryCount: Object.keys(manifest.entries).length,
          });
       } catch (error) {
          logger.warn("Failed to auto-load manifest for package", {
-            projectName,
+            environmentName,
             packageName,
             error,
          });
       }
    }
 
-   public async deletePackage(projectName: string, packageName: string) {
-      if (this.projectStore.publisherConfigIsFrozen) {
+   public async deletePackage(environmentName: string, packageName: string) {
+      if (this.environmentStore.publisherConfigIsFrozen) {
          throw new FrozenConfigError();
       }
-      const project = await this.projectStore.getProject(projectName, false);
-      const result = await project.deletePackage(packageName);
-      await this.projectStore.deletePackageFromDatabase(
-         projectName,
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const result = await environment.deletePackage(packageName);
+      await this.environmentStore.deletePackageFromDatabase(
+         environmentName,
          packageName,
       );
 
@@ -115,32 +139,42 @@ export class PackageController {
    }
 
    public async updatePackage(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       body: ApiPackage,
    ) {
-      if (this.projectStore.publisherConfigIsFrozen) {
+      if (this.environmentStore.publisherConfigIsFrozen) {
          throw new FrozenConfigError();
       }
-      const project = await this.projectStore.getProject(projectName, false);
+      const environment = await this.environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
       if (body.location) {
-         await this.downloadPackage(projectName, packageName, body.location);
+         await this.downloadPackage(
+            environmentName,
+            packageName,
+            body.location,
+         );
       }
-      const result = await project.updatePackage(packageName, body);
-      await this.projectStore.addPackageToDatabase(projectName, packageName);
+      const result = await environment.updatePackage(packageName, body);
+      await this.environmentStore.addPackageToDatabase(
+         environmentName,
+         packageName,
+      );
 
       return result;
    }
 
    private async downloadPackage(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       packageLocation: string,
    ) {
       const absoluteTargetPath = path.join(
-         this.projectStore.serverRootPath,
+         this.environmentStore.serverRootPath,
          PUBLISHER_DATA_DIR,
-         projectName,
+         environmentName,
          packageName,
       );
       const isCompressedFile = packageLocation.endsWith(".zip");
@@ -148,21 +182,21 @@ export class PackageController {
          packageLocation.startsWith("https://") ||
          packageLocation.startsWith("git@")
       ) {
-         await this.projectStore.downloadGitHubDirectory(
+         await this.environmentStore.downloadGitHubDirectory(
             packageLocation,
             absoluteTargetPath,
          );
       } else if (packageLocation.startsWith("gs://")) {
-         await this.projectStore.downloadGcsDirectory(
+         await this.environmentStore.downloadGcsDirectory(
             packageLocation,
-            projectName,
+            environmentName,
             absoluteTargetPath,
             isCompressedFile,
          );
       } else if (packageLocation.startsWith("s3://")) {
-         await this.projectStore.downloadS3Directory(
+         await this.environmentStore.downloadS3Directory(
             packageLocation,
-            projectName,
+            environmentName,
             absoluteTargetPath,
             isCompressedFile,
          );
@@ -171,10 +205,10 @@ export class PackageController {
       if (packageLocation.startsWith("/")) {
          // Absolute paths from the publisher.config could be placed outside of /etc/publisher,
          // so we need to mount them on the right place.
-         await this.projectStore.mountLocalDirectory(
+         await this.environmentStore.mountLocalDirectory(
             packageLocation,
             absoluteTargetPath,
-            projectName,
+            environmentName,
             packageName,
          );
       }

package/src/controller/query.controller.ts

@@ -2,7 +2,7 @@ import { validateRenderTags } from "@malloydata/render-validator";
 import { components } from "../api";
 import { API_PREFIX } from "../constants";
 import { ModelNotFoundError } from "../errors";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 import type { FilterParams } from "../service/filter";
 
 type ApiQuery = components["schemas"]["QueryResult"];
@@ -16,14 +16,14 @@ function bigIntReplacer(_key: string, value: unknown): unknown {
 }
 
 export class QueryController {
-   private projectStore: ProjectStore;
+   private environmentStore: EnvironmentStore;
 
-   constructor(projectStore: ProjectStore) {
-      this.projectStore = projectStore;
+   constructor(environmentStore: EnvironmentStore) {
+      this.environmentStore = environmentStore;
    }
 
    public async getQuery(
-      projectName: string,
+      environmentName: string,
       packageName: string,
       modelPath: string,
       sourceName: string,
@@ -33,8 +33,11 @@ export class QueryController {
       filterParams?: FilterParams,
       bypassFilters?: boolean,
    ): Promise<ApiQuery> {
-      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);
       const model = p.getModel(modelPath);
 
       if (!model) {
@@ -52,7 +55,7 @@ export class QueryController {
             result: compactJson
                ? JSON.stringify(compactResult, bigIntReplacer)
                : JSON.stringify(result),
-            resource: `${API_PREFIX}/projects/${projectName}/packages/${packageName}/models/${modelPath}/query`,
+            resource: `${API_PREFIX}/environments/${environmentName}/packages/${packageName}/models/${modelPath}/query`,
             renderLogs: renderLogs.length > 0 ? renderLogs : undefined,
          } as ApiQuery;
       }