@mastra/deployer 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/server/index.cjs

@@ -3,16 +3,16 @@
 var chunkVA2CSOKJ_cjs = require('../chunk-VA2CSOKJ.cjs');
 var promises = require('fs/promises');
 var https = require('https');
-var posix = require('path/posix');
+var path = require('path');
 var http = require('http');
 var http2 = require('http2');
 var stream$1 = require('stream');
 var crypto = require('crypto');
 var mime = require('hono/utils/mime');
 var fs = require('fs');
-var path = require('path');
 var html = require('hono/html');
 var tools = require('@mastra/core/tools');
+var error = require('@mastra/server/handlers/error');
 var serverAdapter = require('@mastra/server/server-adapter');
 var util = require('util');
 var buffer = require('buffer');
@@ -2868,6 +2868,209 @@ var stream = (c, cb, onError3) => {
   })();
   return c.newResponse(stream2.responseReadable);
 };
+var util2;
+(function(util22) {
+  util22.assertEqual = (_) => {
+  };
+  function assertIs(_arg) {
+  }
+  util22.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error();
+  }
+  util22.assertNever = assertNever;
+  util22.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util22.getValidEnumValues = (obj) => {
+    const validKeys = util22.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util22.objectValues(filtered);
+  };
+  util22.objectValues = (obj) => {
+    return util22.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util22.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  };
+  util22.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return void 0;
+  };
+  util22.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  }
+  util22.joinValues = joinValues;
+  util22.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+})(util2 || (util2 = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
+    return {
+      ...first,
+      ...second
+      // second overwrites first
+    };
+  };
+})(objectUtil || (objectUtil = {}));
+util2.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+util2.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]);
+var ZodError = class _ZodError extends Error {
+  get errors() {
+    return this.issues;
+  }
+  constructor(issues) {
+    super();
+    this.issues = [];
+    this.addIssue = (sub) => {
+      this.issues = [...this.issues, sub];
+    };
+    this.addIssues = (subs = []) => {
+      this.issues = [...this.issues, ...subs];
+    };
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
+    }
+    this.name = "ZodError";
+    this.issues = issues;
+  }
+  format(_mapper) {
+    const mapper = _mapper || function(issue) {
+      return issue.message;
+    };
+    const fieldErrors = { _errors: [] };
+    const processError = (error) => {
+      for (const issue of error.issues) {
+        if (issue.code === "invalid_union") {
+          issue.unionErrors.map(processError);
+        } else if (issue.code === "invalid_return_type") {
+          processError(issue.returnTypeError);
+        } else if (issue.code === "invalid_arguments") {
+          processError(issue.argumentsError);
+        } else if (issue.path.length === 0) {
+          fieldErrors._errors.push(mapper(issue));
+        } else {
+          let curr = fieldErrors;
+          let i = 0;
+          while (i < issue.path.length) {
+            const el = issue.path[i];
+            const terminal = i === issue.path.length - 1;
+            if (!terminal) {
+              curr[el] = curr[el] || { _errors: [] };
+            } else {
+              curr[el] = curr[el] || { _errors: [] };
+              curr[el]._errors.push(mapper(issue));
+            }
+            curr = curr[el];
+            i++;
+          }
+        }
+      }
+    };
+    processError(this);
+    return fieldErrors;
+  }
+  static assert(value) {
+    if (!(value instanceof _ZodError)) {
+      throw new Error(`Not a ZodError: ${value}`);
+    }
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, util2.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of this.issues) {
+      if (sub.path.length > 0) {
+        const firstEl = sub.path[0];
+        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+        fieldErrors[firstEl].push(mapper(sub));
+      } else {
+        formErrors.push(mapper(sub));
+      }
+    }
+    return { formErrors, fieldErrors };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+};
+ZodError.create = (issues) => {
+  const error = new ZodError(issues);
+  return error;
+};
 var authenticationMiddleware = async (c, next) => {
   const mastra = c.get("mastra");
   const authConfig = mastra.getServer()?.auth;
@@ -3061,13 +3264,48 @@ var MastraServer = class extends serverAdapter.MastraServer {
     const queryParams = request.query();
     let body;
     if (route.method === "POST" || route.method === "PUT" || route.method === "PATCH") {
-      try {
-        body = await request.json();
-      } catch {
+      const contentType = request.header("content-type") || "";
+      if (contentType.includes("multipart/form-data")) {
+        try {
+          const formData = await request.formData();
+          body = await this.parseFormData(formData);
+        } catch (error) {
+          console.error("Failed to parse multipart form data:", error);
+          if (error instanceof Error && error.message.toLowerCase().includes("size")) {
+            throw error;
+          }
+        }
+      } else {
+        try {
+          body = await request.json();
+        } catch (error) {
+          console.error("Failed to parse JSON body:", error);
+        }
       }
     }
     return { urlParams, queryParams, body };
   }
+  /**
+   * Parse FormData into a plain object, converting File objects to Buffers.
+   */
+  async parseFormData(formData) {
+    const result = {};
+    for (const [key, value] of formData.entries()) {
+      if (value instanceof File) {
+        const arrayBuffer = await value.arrayBuffer();
+        result[key] = Buffer.from(arrayBuffer);
+      } else if (typeof value === "string") {
+        try {
+          result[key] = JSON.parse(value);
+        } catch {
+          result[key] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
   async sendResponse(route, response, result) {
     if (route.responseType === "json") {
       return response.json(result, 200);
@@ -3137,12 +3375,15 @@ var MastraServer = class extends serverAdapter.MastraServer {
         if (params.queryParams) {
           try {
             params.queryParams = await this.parseQueryParams(route, params.queryParams);
-          } catch (error) {
-            console.error("Error parsing query params", error);
+          } catch (error$1) {
+            console.error("Error parsing query params", error$1);
+            if (error$1 instanceof ZodError) {
+              return c.json(error.formatZodError(error$1, "query parameters"), 400);
+            }
             return c.json(
               {
                 error: "Invalid query parameters",
-                details: error instanceof Error ? error.message : "Unknown error"
+                issues: [{ field: "unknown", message: error$1 instanceof Error ? error$1.message : "Unknown error" }]
               },
               400
             );
@@ -3151,12 +3392,15 @@ var MastraServer = class extends serverAdapter.MastraServer {
         if (params.body) {
           try {
             params.body = await this.parseBody(route, params.body);
-          } catch (error) {
-            console.error("Error parsing body:", error instanceof Error ? error.message : String(error));
+          } catch (error$1) {
+            console.error("Error parsing body:", error$1 instanceof Error ? error$1.message : String(error$1));
+            if (error$1 instanceof ZodError) {
+              return c.json(error.formatZodError(error$1, "request body"), 400);
+            }
             return c.json(
               {
                 error: "Invalid request body",
-                details: error instanceof Error ? error.message : "Unknown error"
+                issues: [{ field: "unknown", message: error$1 instanceof Error ? error$1.message : "Unknown error" }]
               },
               400
             );
@@ -3395,6 +3639,7 @@ var html2 = `
 `;
 
 // src/server/index.ts
+var getStudioPath = () => process.env.MASTRA_STUDIO_PATH || "./playground";
 function getToolExports(tools$1) {
   try {
     return tools$1.reduce((acc, toolModule) => {
@@ -3430,7 +3675,13 @@ async function createHonoServer(mastra, options = {
       customRouteAuthConfig.set(routeKey, requiresAuth);
     }
   }
-  app.onError((err, c) => errorHandler(err, c, options.isDev));
+  const customOnError = server?.onError;
+  app.onError((err, c) => {
+    if (customOnError) {
+      return customOnError(err, c);
+    }
+    return errorHandler(err, c, options.isDev);
+  });
   const bodyLimitOptions = {
     maxSize: server?.bodySizeLimit ?? 4.5 * 1024 * 1024,
     // 4.5 MB,
@@ -3571,10 +3822,11 @@ async function createHonoServer(mastra, options = {
         });
       }
     );
+    const studioPath = getStudioPath();
     app.use(
       `${studioBasePath}/assets/*`,
       serveStatic({
-        root: "./playground/assets",
+        root: path.join(studioPath, "assets"),
         rewriteRequestPath: (path) => {
           let rewritten = path;
           if (studioBasePath && rewritten.startsWith(studioBasePath)) {
@@ -3598,7 +3850,8 @@ async function createHonoServer(mastra, options = {
     }
     const isPlaygroundRoute = studioBasePath === "" || requestPath === studioBasePath || requestPath.startsWith(`${studioBasePath}/`);
     if (options?.playground && isPlaygroundRoute) {
-      let indexHtml = await promises.readFile(posix.join(process.cwd(), "./playground/index.html"), "utf-8");
+      const studioPath = getStudioPath();
+      let indexHtml = await promises.readFile(path.join(studioPath, "index.html"), "utf-8");
       const port = serverOptions?.port ?? (Number(process.env.PORT) || 4111);
       const hideCloudCta = process.env.MASTRA_HIDE_CLOUD_CTA === "true";
       const host = serverOptions?.host ?? "localhost";
@@ -3615,11 +3868,12 @@ async function createHonoServer(mastra, options = {
     return c.newResponse(html2, 200, { "Content-Type": "text/html" });
   });
   if (options?.playground) {
+    const studioPath = getStudioPath();
     const playgroundPath = studioBasePath ? `${studioBasePath}/*` : "*";
     app.use(
       playgroundPath,
       serveStatic({
-        root: "./playground",
+        root: studioPath,
         rewriteRequestPath: (path) => {
           if (studioBasePath && path.startsWith(studioBasePath)) {
             return path.slice(studioBasePath.length);