@malloy-publisher/server 0.0.195 → 0.0.197-dev

package/src/controller/watch-mode.controller.ts

@@ -3,7 +3,7 @@ import { RequestHandler } from "express";
 import path from "path";
 import { components } from "../api";
 import { logger } from "../logger";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 
 type StartWatchReq = components["schemas"]["StartWatchRequest"];
 type WatchStatusRes = components["schemas"]["WatchStatus"];
@@ -11,19 +11,19 @@ type Handler<Req = object, Res = void> = RequestHandler<object, Res, Req>;
 
 export class WatchModeController {
    watchingPath: string | null;
-   watchingProjectName: string | null;
+   watchingEnvironmentName: string | null;
    watcher: FSWatcher;
 
-   constructor(private projectStore: ProjectStore) {
+   constructor(private environmentStore: EnvironmentStore) {
       this.watchingPath = null;
-      this.watchingProjectName = null;
+      this.watchingEnvironmentName = null;
    }
 
    public getWatchStatus: Handler<void, WatchStatusRes> = async (_req, res) => {
       return res.json({
          enabled: !!this.watchingPath,
          watchingPath: this.watchingPath ?? "",
-         projectName: this.watchingProjectName ?? "",
+         environmentName: this.watchingEnvironmentName ?? "",
       });
    };
 
@@ -31,25 +31,31 @@ export class WatchModeController {
       req,
       res,
    ) => {
-      const projectManifest = await ProjectStore.reloadProjectManifest(
-         this.projectStore.serverRootPath,
-      );
-      this.watchingProjectName = req.body.projectName;
+      const watchName = req.body.environmentName ?? "";
+      const environmentManifest =
+         await EnvironmentStore.reloadEnvironmentManifest(
+            this.environmentStore.serverRootPath,
+         );
+      this.watchingEnvironmentName = watchName || null;
 
-      // Find the project in the new array structure
-      const project = projectManifest.projects.find(
-         (p) => p.name === req.body.projectName,
+      // Find the environment in the manifest
+      const environment = environmentManifest.environments.find(
+         (e) => e.name === watchName,
       );
-      if (!project || !project.packages || project.packages.length === 0) {
+      if (
+         !environment ||
+         !environment.packages ||
+         environment.packages.length === 0
+      ) {
          res.status(404).json({
-            error: `Project ${req.body.projectName} not found or has no packages`,
+            error: `Environment ${watchName} not found or has no packages`,
          });
          return;
       }
 
       this.watchingPath = path.join(
-         this.projectStore.serverRootPath,
-         req.body.projectName,
+         this.environmentStore.serverRootPath,
+         watchName,
       );
       this.watcher = chokidar.watch(this.watchingPath, {
          ignored: (path, stats) =>
@@ -58,33 +64,33 @@ export class WatchModeController {
             !path.endsWith(".md"),
          ignoreInitial: true,
       });
-      const reloadProject = async () => {
-         // Overwrite the project with it's existing metadata to trigger a re-read
-         const project = await this.projectStore.getProject(
-            req.body.projectName,
+      const reloadEnvironment = async () => {
+         // Overwrite the environment with its existing metadata to trigger a re-read
+         const environment = await this.environmentStore.getEnvironment(
+            watchName,
             true,
          );
-         await this.projectStore.addProject(project.metadata);
-         logger.info(`Reloaded ${req.body.projectName}`);
+         await this.environmentStore.addEnvironment(environment.metadata);
+         logger.info(`Reloaded environment ${watchName}`);
       };
 
       this.watcher.on("add", async (path) => {
          logger.info(
-            `Detected new file ${path}, reloading ${req.body.projectName}`,
+            `Detected new file ${path}, reloading environment ${watchName}`,
          );
-         await reloadProject();
+         await reloadEnvironment();
       });
       this.watcher.on("unlink", async (path) => {
          logger.info(
-            `Detected deletion of ${path}, reloading ${req.body.projectName}`,
+            `Detected deletion of ${path}, reloading environment ${watchName}`,
          );
-         await reloadProject();
+         await reloadEnvironment();
       });
       this.watcher.on("change", async (path) => {
          logger.info(
-            `Detected change on ${path}, reloading ${req.body.projectName}`,
+            `Detected change on ${path}, reloading environment ${watchName}`,
          );
-         await reloadProject();
+         await reloadEnvironment();
       });
       res.json();
    };
@@ -92,7 +98,7 @@ export class WatchModeController {
    public stopWatchMode: Handler = async (_req, res) => {
       this.watcher.close();
       this.watchingPath = null;
-      this.watchingProjectName = null;
+      this.watchingEnvironmentName = null;
       res.json();
    };
 }

package/src/errors.ts

@@ -6,7 +6,7 @@ export function internalErrorToHttpError(error: Error) {
       return httpError(400, error.message);
    } else if (error instanceof FrozenConfigError) {
       return httpError(403, error.message);
-   } else if (error instanceof ProjectNotFoundError) {
+   } else if (error instanceof EnvironmentNotFoundError) {
       return httpError(404, error.message);
    } else if (error instanceof PackageNotFoundError) {
       return httpError(404, error.message);
@@ -53,7 +53,7 @@ export class BadRequestError extends Error {
    }
 }
 
-export class ProjectNotFoundError extends Error {
+export class EnvironmentNotFoundError extends Error {
    constructor(message: string) {
       super(message);
    }

package/src/mcp/error_messages.ts

@@ -37,11 +37,11 @@ export function getNotFoundError(resourceUriOrContext: string): ErrorDetails {
    const baseMessage = `Resource not found: ${resourceUriOrContext}`;
    const suggestions: string[] = [
       `Verify the identifier or URI (${resourceUriOrContext}) is spelled correctly and exists. Check capitalization and path separators.`,
-      `If using a URI, ensure it follows the correct format (e.g., malloy://project/...) and includes the right path segments (e.g., /models/, /sources/, /queries/, /views/).`,
+      `If using a URI, ensure it follows the correct format (e.g., malloy://environment/...) and includes the right path segments (e.g., /models/, /sources/, /queries/, /views/).`,
    ];
 
    suggestions.push(
-      "Check if the resource exists and is correctly named in your Malloy project structure or the specific model file.",
+      "Check if the resource exists and is correctly named in your Malloy environment structure or the specific model file.",
    );
 
    return {

package/src/mcp/handler_utils.ts

@@ -1,12 +1,12 @@
 import { URL } from "url";
 import type { ResourceMetadata } from "@modelcontextprotocol/sdk/server/mcp";
 import type { ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
-import { ProjectStore } from "../service/project_store";
+import { EnvironmentStore } from "../service/environment_store";
 import {
    PackageNotFoundError,
    ModelNotFoundError,
    ModelCompilationError,
-   ProjectNotFoundError,
+   EnvironmentNotFoundError,
 } from "../errors";
 import {
    getNotFoundError,
@@ -48,7 +48,7 @@ export async function handleResourceGet<
 >(
    uri: URL,
    params: TParams,
-   resourceType: string, // e.g., 'project', 'package' for logging/errors
+   resourceType: string, // e.g., 'environment', 'package' for logging/errors
    getData: GetDataLogic<TParams, TDefinition>,
    resourceMetadata: ResourceMetadata | undefined,
 ): Promise<ReadResourceResult> {
@@ -122,19 +122,22 @@ export async function handleResourceGet<
  * @returns An object containing the Model instance or a pre-formatted ErrorDetails object.
  */
 export async function getModelForQuery(
-   projectStore: ProjectStore,
-   projectName: string,
+   environmentStore: EnvironmentStore,
+   environmentName: string,
    packageName: string,
    modelPath: string,
 ): Promise<{ model: Model } | { error: ErrorDetails }> {
    try {
-      const project = await projectStore.getProject(projectName, false);
-      const pkg = await project.getPackage(packageName, false);
+      const environment = await environmentStore.getEnvironment(
+         environmentName,
+         false,
+      );
+      const pkg = await environment.getPackage(packageName, false);
       const model = pkg.getModel(modelPath);
       if (!model || model.getModelType() === "notebook") {
          // Ensure it's actually a model
          const details = getNotFoundError(
-            `model '${modelPath}' in package '${packageName}' for project '${projectName}'`,
+            `model '${modelPath}' in package '${packageName}' for environment '${environmentName}'`,
          );
          return { error: details };
       }
@@ -144,20 +147,20 @@ export async function getModelForQuery(
    } catch (error) {
       // Handle errors during package/model access or initial compilation
       let errorDetails: ErrorDetails;
-      if (error instanceof ProjectNotFoundError) {
-         errorDetails = getNotFoundError(`project '${projectName}'`);
+      if (error instanceof EnvironmentNotFoundError) {
+         errorDetails = getNotFoundError(`environment '${environmentName}'`);
       } else if (error instanceof PackageNotFoundError) {
          errorDetails = getNotFoundError(
-            `package '${packageName}' in project '${projectName}'`,
+            `package '${packageName}' in environment '${environmentName}'`,
          );
       } else if (error instanceof ModelNotFoundError) {
          errorDetails = getNotFoundError(
-            `model '${modelPath}' in package '${packageName}' for project '${projectName}'`,
+            `model '${modelPath}' in package '${packageName}' for environment '${environmentName}'`,
          );
       } else if (error instanceof ModelCompilationError) {
          errorDetails = getMalloyErrorDetails(
             "executeQuery (load model)",
-            `${projectName}/${packageName}/${modelPath}`,
+            `${environmentName}/${packageName}/${modelPath}`,
             error,
          );
       } else {
@@ -165,7 +168,7 @@ export async function getModelForQuery(
          errorDetails = getInternalError("executeQuery (Setup)", error);
       }
       logger.error(
-         `[MCP Server Error] Error accessing package/model for query: ${projectName}/${packageName}/${modelPath}`,
+         `[MCP Server Error] Error accessing package/model for query: ${environmentName}/${packageName}/${modelPath}`,
          { error },
       );
       return { error: errorDetails };
@@ -176,13 +179,13 @@ export async function getModelForQuery(
  * Constructs a valid malloy:// URI string from its components.
  * Handles encoding of path segments.
  *
- * @param components An object containing the URI parts (project, package, model, etc.)
+ * @param components An object containing the URI parts (environment, package, model, etc.)
  * @param fragment Optional fragment identifier (e.g., #queryResult)
  * @returns A valid malloy:// URI string.
  */
 export function buildMalloyUri(
    components: {
-      project?: string;
+      environment?: string;
       package?: string;
       model?: string;
       resourceType?:
@@ -198,10 +201,10 @@ export function buildMalloyUri(
    },
    fragment?: string,
 ): string {
-   let path = "/project/";
+   let path = "/environment/";
 
-   if (components.project) {
-      path += encodeURIComponent(components.project);
+   if (components.environment) {
+      path += encodeURIComponent(components.environment);
    } else {
       // Default to 'home' if not provided, consistent with current behavior
       path += "home";
@@ -227,7 +230,7 @@ export function buildMalloyUri(
    }
 
    // The URL constructor seems to normalize malloy://path to malloy:///path
-   // which breaks the tests expecting malloy://project/...
+   // which breaks the tests expecting malloy://environment/...
    // We manually construct the string instead.
    let uriString = "malloy:/" + path; // Start with one slash after scheme
 

package/src/mcp/mcp_constants.ts

@@ -8,7 +8,7 @@ export const MCP_ERROR_MESSAGES = {
 
    // Application-level errors (runtime)
    PROJECT_NOT_FOUND: (projectName: string) =>
-      `Project '${projectName}' is not available or does not exist.`,
+      `Environment '${projectName}' is not available or does not exist.`,
    PACKAGE_NOT_FOUND: (packageName: string) =>
       `Package manifest for ${packageName} does not exist.`,
    MODEL_NOT_FOUND: (packageName: string, modelPath: string) =>

package/src/mcp/prompts/handlers.ts

@@ -6,7 +6,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { PROMPTS } from "./prompt_definitions";
 import { getCompiledModel } from "./utils";
-import { ProjectStore } from "../../service/project_store";
+import { EnvironmentStore } from "../../service/environment_store";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
@@ -31,7 +31,7 @@ export function makePromptHandler(id: string) {
    const templateFn = Handlebars.compile(def.template, { noEscape: true });
 
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-   return async (params: any, ps: ProjectStore) => {
+   return async (params: any, ps: EnvironmentStore) => {
       const data: Record<string, unknown> = { ...params };
 
       // Dynamically add model content / schema context if the args include URIs
@@ -79,6 +79,6 @@ export const promptHandlerMap = Object.fromEntries(
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    (
       params: any,
-      ps: ProjectStore,
+      ps: EnvironmentStore,
    ) => Promise<z.infer<typeof GetPromptResultSchema>>
 >;

package/src/mcp/prompts/prompt_service.ts

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { logger } from "../../logger";
-import { ProjectStore } from "../../service/project_store";
+import { EnvironmentStore } from "../../service/environment_store";
 import { promptHandlerMap } from "./handlers";
 import { MALLOY_PROMPTS } from "./prompt_definitions";
 
@@ -9,11 +9,11 @@ import { MALLOY_PROMPTS } from "./prompt_definitions";
  * Registers all defined Malloy prompts with the MCP server.
  *
  * @param mcpServer The McpServer instance.
- * @param projectStore The ProjectStore instance for handlers to access project data.
+ * @param environmentStore The EnvironmentStore instance for handlers to access environment data.
  */
 export function registerPromptCapability(
    mcpServer: McpServer,
-   projectStore: ProjectStore,
+   environmentStore: EnvironmentStore,
 ): void {
    logger.info("[MCP Init] Registering prompt capability...");
    const startTime = performance.now();
@@ -24,10 +24,10 @@ export function registerPromptCapability(
       const handler = promptHandlerMap[promptDefinition.id];
 
       if (handler && promptDefinition.argsSchema instanceof z.ZodObject) {
-         // Prepare a handler that injects the projectStore
+         // Prepare a handler that injects the environmentStore
          const preparedHandler = (
             args: z.infer<typeof promptDefinition.argsSchema>,
-         ) => handler(args, projectStore);
+         ) => handler(args, environmentStore);
 
          // Register using prompt ID, the Zod schema shape, and the prepared handler.
          mcpServer.prompt(

package/src/mcp/prompts/utils.ts

@@ -1,4 +1,4 @@
-import { ProjectStore } from "../../service/project_store";
+import { EnvironmentStore } from "../../service/environment_store";
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 
 // Type alias for compiled model pulled from OpenAPI-generated types.
@@ -7,20 +7,20 @@ import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 export type ApiCompiledModel = any;
 
 export interface ParsedMalloyUri {
-   projectName: string;
+   environmentName: string;
    packageName: string;
    modelPath: string;
 }
 
 /**
  * Parse a canonical Malloy model URI of the form:
- *   malloy://project/{project}/package/{package}/models/{modelPath}
+ *   malloy://environment/{environment}/package/{package}/models/{modelPath}
  *
  * Throws an McpError(InvalidParams) if the URI is malformed.
  */
 export function parseMalloyUri(uri: string): ParsedMalloyUri {
    const match = uri.match(
-      /^malloy:\/\/project\/([^/]+)\/package\/([^/]+)\/models\/(.+)$/,
+      /^malloy:\/\/environment\/([^/]+)\/package\/([^/]+)\/models\/(.+)$/,
    );
 
    if (!match) {
@@ -28,7 +28,7 @@ export function parseMalloyUri(uri: string): ParsedMalloyUri {
    }
 
    return {
-      projectName: match[1],
+      environmentName: match[1],
       packageName: match[2],
       modelPath: match[3],
    };
@@ -36,18 +36,18 @@ export function parseMalloyUri(uri: string): ParsedMalloyUri {
 
 /**
  * Retrieve the compiled model for the given Malloy URI, using the provided
- * ProjectStore. Results are memoised in `compiledModelCache`.
+ * EnvironmentStore. Results are memoised in `compiledModelCache`.
  */
 export async function getCompiledModel(
    uri: string,
-   projectStore: ProjectStore,
+   environmentStore: EnvironmentStore,
 ): Promise<ApiCompiledModel> {
-   const { projectName, packageName, modelPath } = parseMalloyUri(uri);
+   const { environmentName, packageName, modelPath } = parseMalloyUri(uri);
 
-   // Look up the model via the ProjectStore hierarchy.
-   const model = await projectStore
-      .getProject(projectName, false)
-      .then((p) => p.getPackage(packageName, false))
+   // Look up the model via the EnvironmentStore hierarchy.
+   const model = await environmentStore
+      .getEnvironment(environmentName, false)
+      .then((e) => e.getPackage(packageName, false))
       .then((pkg) => pkg.getModel(modelPath));
 
    if (!model || model.getModelType() === "notebook") {

package/src/mcp/resource_metadata.ts

@@ -8,7 +8,7 @@ type McpResourceType = "model" | "source" | "view" | "query" | "notebook";
 // Type assertion ensures compatibility with the SDK's ResourceMetadata,
 // which might include optional fields or an index signature.
 export const RESOURCE_METADATA: Record<
-   McpResourceType | "package" | "project",
+   McpResourceType | "package" | "environment",
    SdkResourceMetadata // Use the imported SDK type here
 > = {
    model: {
@@ -40,8 +40,8 @@ export const RESOURCE_METADATA: Record<
       description: "A folder grouping related Models and Notebooks.",
       usage: "Use `ListResources` on this Package's URI to discover the Models and Notebooks it contains. You can then use `GetResource` on those items' URIs to explore them further.",
    },
-   project: {
+   environment: {
       description: "The main workspace folder holding Packages, Models, etc.",
-      usage: "Use `ListResources` on this Project's URI to see the Packages inside and begin navigating your data assets.",
+      usage: "Use `ListResources` on this environment's URI to see the Packages inside and begin navigating your data assets.",
    },
 };

package/src/mcp/resources/environment_resource.ts

@@ -0,0 +1,187 @@
+import {
+   McpServer,
+   ResourceTemplate,
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ListResourcesResult } from "@modelcontextprotocol/sdk/types.js"; // Needed for list return type
+import { logger } from "../../logger";
+import { EnvironmentStore } from "../../service/environment_store";
+import { getInternalError, getNotFoundError } from "../error_messages"; // Needed for error handling in list AND get
+import { handleResourceGet, McpGetResourceError } from "../handler_utils";
+import { RESOURCE_METADATA } from "../resource_metadata";
+
+// Define an interface for the package object augmented with environment name
+interface PackageWithEnvironment {
+   name?: string;
+   // Add other relevant package properties if needed
+   environmentName: string;
+}
+
+/**
+ * Registers the Malloy environment resource type with the MCP server (URI scheme malloy://environment/...).
+ * Lists packages across environments and resolves environment metadata on read.
+ */
+export function registerEnvironmentResource(
+   mcpServer: McpServer,
+   environmentStore: EnvironmentStore,
+): void {
+   mcpServer.resource(
+      "environment",
+      new ResourceTemplate("malloy://environment/{environmentName}", {
+         /**
+          * Handles ListResources requests.
+          * If environmentName is specified, lists packages for that environment (only 'home' supported).
+          * If environmentName is not specified (general ListResources call), lists packages for the default 'home' environment.
+          */
+         list: async (/* extra: ListEnvironmentExtra - Deleted */): Promise<ListResourcesResult> => {
+            logger.info(
+               "[MCP LOG] Entering ListResources (environment) handler (listing ALL packages)...",
+            );
+            // Ignore parameters from 'extra' as URI path params aren't passed to list handlers.
+
+            try {
+               const allEnvironments =
+                  await environmentStore.listEnvironments();
+               logger.info(
+                  `[MCP LOG] Found ${allEnvironments.length} environments defined.`,
+               );
+
+               const packagePromises = allEnvironments.map(async (env) => {
+                  try {
+                     logger.info(
+                        `[MCP LOG] Getting environment '${env.name}' to list its packages...`,
+                     );
+                     const environmentInstance =
+                        await environmentStore.getEnvironment(env.name!, false);
+                     const packages = await environmentInstance.listPackages();
+                     logger.info(
+                        `[MCP LOG] Found ${packages.length} packages in environment '${env.name}'.`,
+                     );
+                     // Return packages along with their environment name for URI construction
+                     return packages.map((pkg) => ({
+                        ...pkg,
+                        environmentName: env.name,
+                     }));
+                  } catch (environmentError) {
+                     logger.error(
+                        `[MCP Server Error] Error getting/listing packages for environment ${env.name}:`,
+                        { error: environmentError },
+                     );
+                     return []; // Return empty array for this environment on error
+                  }
+               });
+
+               const results = await Promise.allSettled(packagePromises);
+               const allPackagesWithEnvironmentName = results
+                  .filter((result) => result.status === "fulfilled")
+                  .flatMap(
+                     (result) =>
+                        (
+                           result as PromiseFulfilledResult<
+                              PackageWithEnvironment[]
+                           >
+                        ).value,
+                  );
+
+               logger.info(
+                  `[MCP LOG] Total packages found across all environments: ${allPackagesWithEnvironmentName.length}`,
+               );
+
+               const packageMetadata = RESOURCE_METADATA.package;
+               const mappedResources = allPackagesWithEnvironmentName.map(
+                  (pkg) => {
+                     const name = pkg.name || "unknown";
+                     // Construct URI using the package's specific environmentName
+                     const uri = `malloy://environment/${pkg.environmentName}/package/${name}`;
+                     return {
+                        uri: uri,
+                        name: name,
+                        type: "package",
+                        description: packageMetadata?.description as
+                           | string
+                           | undefined,
+                        metadata: packageMetadata,
+                     };
+                  },
+               );
+
+               logger.info(
+                  `[MCP LOG] ListResources (environment): Returning ${mappedResources.length} package resources.`,
+               );
+               return {
+                  resources: mappedResources,
+               };
+            } catch (error) {
+               // Catch errors from environmentStore.listEnvironments() itself
+               logger.error(`[MCP Server Error] Error listing environments:`, {
+                  error,
+               });
+               const errorDetails = getInternalError(
+                  `ListResources (environment - initial list)`,
+                  error,
+               );
+               logger.error("MCP ListResources (environment) error:", {
+                  error: errorDetails.message,
+               });
+               logger.info(
+                  "[MCP LOG] ListResources (environment): Returning empty on error listing environments.",
+               );
+               return { resources: [] };
+            }
+         },
+      }),
+      /** Handles GetResource requests for Malloy environments */
+      (uri, params) =>
+         handleResourceGet(
+            uri,
+            params,
+            "environment",
+            async ({ environmentName }: { environmentName?: unknown }) => {
+               logger.info(
+                  `[MCP LOG] Entering GetResource (environment) handler for environmentName: ${environmentName}`,
+               );
+               // Validate environment name parameter
+               if (typeof environmentName !== "string") {
+                  logger.error(
+                     "[MCP LOG] GetResource (environment): Invalid environment name param.",
+                  );
+                  throw new Error("Invalid environment name parameter.");
+               }
+
+               try {
+                  logger.info(
+                     `[MCP LOG] GetResource: Getting environment '${environmentName}'...`,
+                  );
+                  // Get the environment instance, but we might not need its metadata directly
+                  await environmentStore.getEnvironment(environmentName, false);
+                  // Construct the definition object expected by the test
+                  const definition = { name: environmentName };
+                  logger.info(
+                     `[MCP LOG] GetResource (environment): Returning definition for '${environmentName}'.`,
+                  );
+                  // Return the explicit definition structure
+                  return definition;
+               } catch (error) {
+                  logger.error(
+                     `[MCP LOG] GetResource (environment): Error caught for '${environmentName}':`,
+                     { error },
+                  );
+                  // Catch expected errors from this specific resource logic
+                  if (error instanceof Error) {
+                     // Use getNotFoundError for the specific environment not found case
+                     // or a generic message for the invalid param case.
+                     const errorDetails = getNotFoundError(
+                        error.message.includes("not found")
+                           ? `Environment '${environmentName}'` // More specific context
+                           : `Invalid environment identifier provided for URI ${uri.href}`, // Generic but informative
+                     );
+                     // Re-throw structured error for handleResourceGet to catch
+                     throw new McpGetResourceError(errorDetails);
+                  }
+                  // Re-throw unexpected errors to be caught by handleResourceGet's generic handler
+                  throw error;
+               }
+            },
+            RESOURCE_METADATA.environment,
+         ),
+   );
+}