@mastra/deployer-cloudflare 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/index.js

@@ -1,170 +1,272 @@
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { Deployer } from '@mastra/deployer';
-import virtual from '@rollup/plugin-virtual';
-import * as babel from '@babel/core';
-import { transformSync } from '@babel/core';
-
-// src/index.ts
-function mastraInstanceWrapper() {
-  const exportName = "mastra";
-  const className = "Mastra";
-  const t = babel.types;
-  return {
-    name: "wrap-mastra",
-    visitor: {
-      ExportNamedDeclaration(path) {
-        if (t.isVariableDeclaration(path.node?.declaration)) {
-          for (const declaration of path.node.declaration.declarations) {
-            if (t.isIdentifier(declaration?.id, { name: exportName }) && t.isNewExpression(declaration?.init) && t.isIdentifier(declaration.init.callee, { name: className })) {
-              declaration.init = t.arrowFunctionExpression([], declaration.init);
-              break;
-            }
-          }
-        }
-      }
-    }
-  };
+import { builtinModules } from "module";
+import { writeFile } from "fs/promises";
+import { join, relative } from "path";
+import { Deployer } from "@mastra/deployer";
+import virtual from "@rollup/plugin-virtual";
+import * as babel from "@babel/core";
+import { transformSync } from "@babel/core";
+//#region src/babel/mastra-instance-wrapper.ts
+/**
+* Babel plugin that transforms Mastra exports for Cloudflare Workers compatibility.
+*
+* This plugin:
+* 1. Identifies named exports of the 'mastra' variable
+* 2. Checks if the export is a new instance of the 'Mastra' class
+* 3. Wraps the Mastra instantiation in an arrow function to ensure proper initialization
+*    in the Cloudflare Workers environment
+*
+* The transformation ensures the Mastra instance is properly scoped and initialized
+* for each request in the Cloudflare Workers environment.
+*
+* @returns {PluginObject} A Babel plugin object with a visitor that performs the transformation
+*
+* @example
+* // Before transformation:
+* export const mastra = new Mastra();
+*
+* // After transformation:
+* export const mastra = () => new Mastra();
+*/
+function mastraInstanceWrapper$1() {
+	const exportName = "mastra";
+	const className = "Mastra";
+	const t = babel.types;
+	return {
+		name: "wrap-mastra",
+		visitor: { ExportNamedDeclaration(path) {
+			if (t.isVariableDeclaration(path.node?.declaration)) {
+				for (const declaration of path.node.declaration.declarations) if (t.isIdentifier(declaration?.id, { name: exportName }) && t.isNewExpression(declaration?.init) && t.isIdentifier(declaration.init.callee, { name: className })) {
+					declaration.init = t.arrowFunctionExpression([], declaration.init);
+					break;
+				}
+			}
+		} }
+	};
 }
-
-// src/plugins/mastra-instance-wrapper.ts
-function mastraInstanceWrapper2(mastraEntryFile) {
-  return {
-    name: "mastra-wrapper",
-    transform(code, id) {
-      if (id !== mastraEntryFile) {
-        return null;
-      }
-      const result = transformSync(code, {
-        filename: id,
-        babelrc: false,
-        configFile: false,
-        plugins: [mastraInstanceWrapper]
-      });
-      if (!result?.code) {
-        throw new Error("mastra-wrapper plugin did not return code, there is likely a bug in the plugin.");
-      }
-      return {
-        code: result.code,
-        map: result?.map
-      };
-    }
-  };
+//#endregion
+//#region src/plugins/mastra-instance-wrapper.ts
+function mastraInstanceWrapper(mastraEntryFile) {
+	return {
+		name: "mastra-wrapper",
+		transform(code, id) {
+			if (id !== mastraEntryFile) return null;
+			const result = transformSync(code, {
+				filename: id,
+				babelrc: false,
+				configFile: false,
+				plugins: [mastraInstanceWrapper$1]
+			});
+			if (!result?.code) throw new Error("mastra-wrapper plugin did not return code, there is likely a bug in the plugin.");
+			return {
+				code: result.code,
+				map: result?.map
+			};
+		}
+	};
+}
+//#endregion
+//#region src/babel/postgres-store-instance-checker.ts
+/**
+* Babel plugin that enforces singleton PostgresStore instances in Cloudflare Workers.
+*
+* This plugin:
+* 1. Scans for all `new PostgresStore()` instantiations
+* 2. Records their file locations
+* 3. Throws an error if multiple instances are found
+*
+* Cloudflare Workers should only create one PostgresStore instance to avoid connection
+* pool exhaustion and ensure proper resource management.
+*
+* @returns {PluginObject} A Babel plugin object that validates PostgresStore usage
+*
+* @example
+* // Throws error if multiple instances found:
+* const store1 = new PostgresStore();
+* const store2 = new PostgresStore(); // Error thrown here
+*/
+function postgresStoreInstanceChecker$1() {
+	const t = babel.types;
+	const instances = [];
+	return {
+		name: "postgresstore-instance-checker",
+		visitor: { NewExpression(path, state) {
+			if (t.isIdentifier(path.node.callee) && path.node.callee.name === "PostgresStore") {
+				const filename = state.file?.opts?.filename || "unknown file";
+				const location = path.node.loc ? `${filename}: line ${path.node.loc.start.line}, column ${path.node.loc.start.column}` : "unknown location";
+				instances.push({
+					path,
+					location
+				});
+			}
+		} },
+		post() {
+			if (instances.length > 1) {
+				const errorMessage = [
+					`Found ${instances.length} PostgresStore instantiations:`,
+					...instances.map((instance, i) => `  ${i + 1}. At ${instance.location}`),
+					"Only one PostgresStore instance should be created per Cloudflare Worker."
+				].join("\n");
+				throw instances[instances.length - 1]?.path.buildCodeFrameError(errorMessage);
+			}
+		}
+	};
 }
+//#endregion
+//#region src/plugins/postgres-store-instance-checker.ts
 function postgresStoreInstanceChecker() {
-  const t = babel.types;
-  const instances = [];
-  return {
-    name: "postgresstore-instance-checker",
-    visitor: {
-      NewExpression(path, state) {
-        if (t.isIdentifier(path.node.callee) && path.node.callee.name === "PostgresStore") {
-          const filename = state.file?.opts?.filename || "unknown file";
-          const location = path.node.loc ? `${filename}: line ${path.node.loc.start.line}, column ${path.node.loc.start.column}` : "unknown location";
-          instances.push({
-            path,
-            location
-          });
-        }
-      }
-    },
-    post() {
-      if (instances.length > 1) {
-        const errorMessage = [
-          `Found ${instances.length} PostgresStore instantiations:`,
-          ...instances.map((instance, i) => `  ${i + 1}. At ${instance.location}`),
-          "Only one PostgresStore instance should be created per Cloudflare Worker."
-        ].join("\n");
-        const lastInstance = instances[instances.length - 1];
-        throw lastInstance?.path.buildCodeFrameError(errorMessage);
-      }
-    }
-  };
+	return {
+		name: "postgres-store-instance-checker",
+		transform(code, id) {
+			const result = transformSync(code, {
+				filename: id,
+				babelrc: false,
+				configFile: false,
+				plugins: [postgresStoreInstanceChecker$1]
+			});
+			if (!result || typeof result.code !== "string") return null;
+			return {
+				code: result.code,
+				map: result.map ? result.map : null
+			};
+		}
+	};
 }
-
-// src/plugins/postgres-store-instance-checker.ts
-function postgresStoreInstanceChecker2() {
-  return {
-    name: "postgres-store-instance-checker",
-    transform(code, id) {
-      const result = transformSync(code, {
-        filename: id,
-        babelrc: false,
-        configFile: false,
-        plugins: [postgresStoreInstanceChecker]
-      });
-      if (!result || typeof result.code !== "string") {
-        return null;
-      }
-      return {
-        code: result.code,
-        map: result.map ?? null
-      };
-    }
-  };
+//#endregion
+//#region src/index.ts
+const nodeBuiltins = new Set(builtinModules);
+/**
+* Rollup plugin that marks bare Node.js builtin imports (e.g. `process`, `path`)
+* as external. Cloudflare Workers with `nodejs_compat` provides these at runtime,
+* so they must not be resolved to npm polyfill packages during bundling.
+*/
+function nodeBuiltinsExternal() {
+	return {
+		name: "node-builtins-external",
+		resolveId(id) {
+			if (nodeBuiltins.has(id)) return {
+				id,
+				external: true
+			};
+			return null;
+		}
+	};
 }
-
-// src/index.ts
 var CloudflareDeployer = class extends Deployer {
-  routes = [];
-  workerNamespace;
-  env;
-  projectName;
-  d1Databases;
-  kvNamespaces;
-  constructor({
-    env,
-    projectName = "mastra",
-    routes,
-    workerNamespace,
-    d1Databases,
-    kvNamespaces
-  }) {
-    super({ name: "CLOUDFLARE" });
-    this.projectName = projectName;
-    this.routes = routes;
-    this.workerNamespace = workerNamespace;
-    if (env) {
-      this.env = env;
-    }
-    if (d1Databases) this.d1Databases = d1Databases;
-    if (kvNamespaces) this.kvNamespaces = kvNamespaces;
-  }
-  async writeFiles(outputDirectory) {
-    const env = await this.loadEnvVars();
-    const envsAsObject = Object.assign({}, Object.fromEntries(env.entries()), this.env);
-    const cfWorkerName = this.projectName;
-    const wranglerConfig = {
-      name: cfWorkerName,
-      main: "./index.mjs",
-      compatibility_date: "2025-04-01",
-      compatibility_flags: ["nodejs_compat", "nodejs_compat_populate_process_env"],
-      observability: {
-        logs: {
-          enabled: true
-        }
-      },
-      vars: envsAsObject
-    };
-    if (!this.workerNamespace && this.routes) {
-      wranglerConfig.routes = this.routes;
-    }
-    if (this.d1Databases?.length) {
-      wranglerConfig.d1_databases = this.d1Databases;
-    }
-    if (this.kvNamespaces?.length) {
-      wranglerConfig.kv_namespaces = this.kvNamespaces;
-    }
-    await writeFile(join(outputDirectory, this.outputDir, "wrangler.json"), JSON.stringify(wranglerConfig));
-  }
-  getEntry() {
-    return `
+	userConfig;
+	constructor(userConfig) {
+		super({ name: "CLOUDFLARE" });
+		this.platform = "browser";
+		this.userConfig = { ...userConfig };
+		if (userConfig.workerNamespace) console.warn("[CloudflareDeployer]: `workerNamespace` is no longer used");
+		if (!userConfig.name && userConfig.projectName) {
+			this.userConfig.name = userConfig.projectName;
+			console.warn("[CloudflareDeployer]: `projectName` is deprecated, use `name` instead");
+		}
+		if (!userConfig.d1_databases && userConfig.d1Databases) {
+			this.userConfig.d1_databases = userConfig.d1Databases;
+			console.warn("[CloudflareDeployer]: `d1Databases` is deprecated, use `d1_databases` instead");
+		}
+		if (!userConfig.kv_namespaces && userConfig.kvNamespaces) {
+			this.userConfig.kv_namespaces = userConfig.kvNamespaces;
+			console.warn("[CloudflareDeployer]: `kvNamespaces` is deprecated, use `kv_namespaces` instead");
+		}
+	}
+	async writeFiles(outputDirectory) {
+		const { vars: userVars, alias: userAlias, projectName: _projectName, workerNamespace: _workerNamespace, d1Databases: _d1Databases, kvNamespaces: _kvNamespaces, ...userConfig } = this.userConfig;
+		const loadedEnvVars = await this.loadEnvVars();
+		const envsAsObject = Object.assign({}, userVars);
+		if (loadedEnvVars.size > 0) {
+			const envKeys = [...loadedEnvVars.keys()].join(", ");
+			this.logger.warn(`Environment variables from .env (${envKeys}) were not written to wrangler.jsonc.
+Upload them as Cloudflare Secrets instead:
+npx wrangler secret bulk .env`);
+		}
+		const typescriptStubPath = "typescript-stub.mjs";
+		await writeFile(join(outputDirectory, this.outputDir, typescriptStubPath), `// Stub for TypeScript - not available at runtime in Cloudflare Workers
+// The @mastra/agent-builder package will fall back to basic validation
+export default {};
+export const createSourceFile = () => null;
+export const createProgram = () => null;
+export const findConfigFile = () => null;
+export const readConfigFile = () => ({ error: new Error('TypeScript not available') });
+export const parseJsonConfigFileContent = () => ({ errors: [new Error('TypeScript not available')], fileNames: [], options: {} });
+export const flattenDiagnosticMessageText = (message) => typeof message === 'string' ? message : message?.messageText || '';
+export const ScriptTarget = { Latest: 99 };
+export const ModuleKind = { ESNext: 99 };
+export const JsxEmit = { ReactJSX: 4 };
+export const DiagnosticCategory = { Warning: 0, Error: 1, Suggestion: 2, Message: 3 };
+export const sys = {
+  fileExists: () => false,
+  readFile: () => undefined,
+};
+`);
+		const execaStubPath = "execa-stub.mjs";
+		await writeFile(join(outputDirectory, this.outputDir, execaStubPath), `// Stub for execa - not available at runtime in Cloudflare Workers
+export const execa = () => { throw new Error('execa is not available in Cloudflare Workers'); };
+export const execaNode = execa;
+export const execaSync = execa;
+export const execaCommand = execa;
+export const execaCommandSync = execa;
+export const $ = execa;
+`);
+		const readableStreamStubPath = "readable-stream-stub.mjs";
+		await writeFile(join(outputDirectory, this.outputDir, readableStreamStubPath), `// Redirect readable-stream to native node:stream (available via nodejs_compat)
+import stream from 'node:stream';
+export const { Readable, Writable, Duplex, Transform, PassThrough, Stream, pipeline, finished } = stream;
+export default stream;
+`);
+		const moduleStubPath = "module-stub.mjs";
+		await writeFile(join(outputDirectory, this.outputDir, moduleStubPath), `// Stub for module.createRequire in Cloudflare Workers
+export function createRequire() {
+  const req = specifier => {
+    throw new Error(\`require(\${specifier}) is not available in Cloudflare Workers\`);
+  };
+  req.resolve = specifier => specifier;
+  return req;
+}
+export default { createRequire };
+`);
+		const wranglerConfig = {
+			name: "mastra",
+			compatibility_date: "2025-04-01",
+			compatibility_flags: ["nodejs_compat", "nodejs_compat_populate_process_env"],
+			observability: { logs: { enabled: true } },
+			...userConfig,
+			main: "./index.mjs",
+			vars: envsAsObject,
+			alias: {
+				typescript: `./${typescriptStubPath}`,
+				execa: `./${execaStubPath}`,
+				"readable-stream": `./${readableStreamStubPath}`,
+				module: `./${moduleStubPath}`,
+				"node:module": `./${moduleStubPath}`,
+				...userAlias
+			}
+		};
+		await writeFile(join(outputDirectory, this.outputDir, "wrangler.json"), JSON.stringify(wranglerConfig, null, 2));
+		const projectRoot = join(outputDirectory, "../");
+		const jsoncFilePath = join(projectRoot, "wrangler.jsonc");
+		const mainFilePath = join(outputDirectory, this.outputDir, "index.mjs");
+		const tsStubFilePath = join(outputDirectory, this.outputDir, typescriptStubPath);
+		const moduleStubFilePath = join(outputDirectory, this.outputDir, moduleStubPath);
+		const wranglerJsoncConfig = {
+			placeholder: "PLACEHOLDER",
+			$schema: "./node_modules/wrangler/config-schema.json",
+			...wranglerConfig,
+			main: `./${relative(projectRoot, mainFilePath)}`,
+			alias: {
+				...wranglerConfig.alias,
+				typescript: `./${relative(projectRoot, tsStubFilePath)}`,
+				module: `./${relative(projectRoot, moduleStubFilePath)}`,
+				"node:module": `./${relative(projectRoot, moduleStubFilePath)}`
+			}
+		};
+		await writeFile(jsoncFilePath, JSON.stringify(wranglerJsoncConfig, null, 2).replace(/"placeholder": "PLACEHOLDER",/, "/* This file was auto-generated through Mastra. Edit the CloudflareDeployer() instance directly. */"));
+	}
+	getEntry() {
+		return `
     import '#polyfills';
-    import { evaluate } from '@mastra/core/eval';
-    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
-    import { TABLE_EVALS } from '@mastra/core/storage';
-    import { scoreTracesWorkflow } from '@mastra/core/scores/scoreTraces';
-    import { checkEvalStorageFields } from '@mastra/core/utils';
+    import { scoreTracesWorkflow } from '@mastra/core/evals/scoreTraces';
 
     export default {
       fetch: async (request, env, context) => {
@@ -177,98 +279,69 @@ var CloudflareDeployer = class extends Deployer {
           _mastra.__registerInternalWorkflow(scoreTracesWorkflow);
         }
 
-        registerHook(AvailableHooks.ON_GENERATION, ({ input, output, metric, runId, agentName, instructions }) => {
-          evaluate({
-            agentName,
-            input,
-            metric,
-            output,
-            runId,
-            globalRunId: runId,
-            instructions,
-          });
-        });
-
-        registerHook(AvailableHooks.ON_EVALUATION, async traceObject => {
-          const storage = _mastra.getStorage();
-          if (storage) {
-            // Check for required fields
-            const logger = _mastra?.getLogger();
-            const areFieldsValid = checkEvalStorageFields(traceObject, logger);
-            if (!areFieldsValid) return;
-
-            await storage.insert({
-              tableName: TABLE_EVALS,
-              record: {
-                input: traceObject.input,
-                output: traceObject.output,
-                result: JSON.stringify(traceObject.result || {}),
-                agent_name: traceObject.agentName,
-                metric_name: traceObject.metricName,
-                instructions: traceObject.instructions,
-                test_info: null,
-                global_run_id: traceObject.globalRunId,
-                run_id: traceObject.runId,
-                created_at: new Date().toISOString(),
-              },
-            });
-          }
-        });
-      
-        const app = await createHonoServer(_mastra, { tools: getToolExports(tools) });
+        const app = await createHonoServer(_mastra, { tools: getToolExports(tools), browserStream: false });
         return app.fetch(request, env, context);
       }
     }
 `;
+	}
+	async prepare(outputDirectory) {
+		await super.prepare(outputDirectory);
+		await this.writeFiles(outputDirectory);
+	}
+	async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, bundlerOptions) {
+		const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, {
+			...bundlerOptions,
+			enableEsmShim: false
+		});
+		const hasPostgresStore = await this.deps.checkDependencies(["@mastra/pg"]) === `ok`;
+		if (Array.isArray(inputOptions.plugins)) {
+			inputOptions.plugins = [
+				nodeBuiltinsExternal(),
+				virtual({ "#polyfills": `
+try {
+  if (!process.versions) {
+    Object.defineProperty(process, 'versions', { value: {}, configurable: true });
   }
-  async prepare(outputDirectory) {
-    await super.prepare(outputDirectory);
-    await this.writeFiles(outputDirectory);
-  }
-  async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, { enableSourcemap = false } = {}) {
-    const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, {
-      enableSourcemap,
-      enableEsmShim: false
-    });
-    const hasPostgresStore = await this.deps.checkDependencies(["@mastra/pg"]) === `ok`;
-    if (Array.isArray(inputOptions.plugins)) {
-      inputOptions.plugins = [
-        virtual({
-          "#polyfills": `
-process.versions = process.versions || {};
-process.versions.node = '${process.versions.node}';
-      `
-        }),
-        ...inputOptions.plugins,
-        mastraInstanceWrapper2(mastraEntryFile)
-      ];
-      if (hasPostgresStore) {
-        inputOptions.plugins.push(postgresStoreInstanceChecker2());
-      }
-    }
-    return inputOptions;
-  }
-  async bundle(entryFile, outputDirectory, { toolsPaths, projectRoot }) {
-    return this._bundle(this.getEntry(), entryFile, { outputDirectory, projectRoot, enableEsmShim: false }, toolsPaths);
-  }
-  async deploy() {
-    this.logger?.info("Deploying to Cloudflare failed. Please use the Cloudflare dashboard to deploy.");
-  }
-  async tagWorker() {
-    throw new Error("tagWorker method is no longer supported. Use the Cloudflare dashboard or API directly.");
-  }
-  async lint(entryFile, outputDirectory, toolsPaths) {
-    await super.lint(entryFile, outputDirectory, toolsPaths);
-    const hasLibsql = await this.deps.checkDependencies(["@mastra/libsql"]) === `ok`;
-    if (hasLibsql) {
-      this.logger.error(
-        "Cloudflare Deployer does not support @libsql/client (which may have been installed by @mastra/libsql) as a dependency. Please use Cloudflare D1 instead: @mastra/cloudflare-d1."
-      );
-      process.exit(1);
-    }
+  if (!process.versions.node) {
+    Object.defineProperty(process.versions, 'node', { value: '${process.versions.node}', configurable: true });
   }
+} catch {}
+      ` }),
+				...inputOptions.plugins,
+				mastraInstanceWrapper(mastraEntryFile)
+			];
+			if (hasPostgresStore) inputOptions.plugins.push(postgresStoreInstanceChecker());
+		}
+		return inputOptions;
+	}
+	async bundle(entryFile, outputDirectory, { toolsPaths, projectRoot }) {
+		return this._bundle(this.getEntry(), entryFile, {
+			outputDirectory,
+			projectRoot,
+			enableEsmShim: false
+		}, toolsPaths);
+	}
+	async deploy() {
+		this.logger?.info("Deploying to Cloudflare failed. Please use the Cloudflare dashboard to deploy.");
+	}
+	/**
+	* TODO: Remove this method in the next major version
+	*
+	* @deprecated
+	*/
+	async tagWorker() {
+		throw new Error("tagWorker method is no longer supported. Use the Cloudflare dashboard or API directly.");
+	}
+	async lint(entryFile, outputDirectory, toolsPaths) {
+		await super.lint(entryFile, outputDirectory, toolsPaths);
+		if (await this.deps.checkDependencies(["@mastra/libsql"]) === `ok`) {
+			this.logger.error("Cloudflare Deployer does not support @libsql/client (which may have been installed by @mastra/libsql) as a dependency. Please use Cloudflare D1 instead: @mastra/cloudflare-d1.");
+			process.exit(1);
+		}
+	}
 };
-
+//#endregion
 export { CloudflareDeployer };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map