@mastra/deployer-cloudflare 0.0.0-storage-20250225005900 → 0.0.0-support-d1-client-20250701191943

package/{LICENSE → LICENSE.md}

@@ -1,4 +1,6 @@
-Elastic License 2.0 (ELv2)
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
 
 **Acceptance**
 By using the software, you agree to all of the terms and conditions below.

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,85 @@
+import type { analyzeBundle } from '@mastra/deployer/analyze';
+import { Deployer } from '@mastra/deployer';
+import { InputOptions } from 'rollup';
+
+declare interface CFRoute {
+    pattern: string;
+    zone_name: string;
+    custom_domain?: boolean;
+}
+
+export declare class CloudflareDeployer extends Deployer {
+    private cloudflare;
+    routes?: CFRoute[];
+    workerNamespace?: string;
+    scope: string;
+    env?: Record<string, any>;
+    projectName?: string;
+    d1Databases?: D1DatabaseBinding[];
+    kvNamespaces?: KVNamespaceBinding[];
+    constructor({ scope, env, projectName, routes, workerNamespace, auth, d1Databases, kvNamespaces, }: {
+        env?: Record<string, any>;
+        scope: string;
+        projectName?: string;
+        routes?: CFRoute[];
+        workerNamespace?: string;
+        auth: {
+            apiToken: string;
+            apiEmail?: string;
+        };
+        d1Databases?: D1DatabaseBinding[];
+        kvNamespaces?: KVNamespaceBinding[];
+    });
+    writeFiles(outputDirectory: string): Promise<void>;
+    private getEntry;
+    prepare(outputDirectory: string): Promise<void>;
+    getBundlerOptions(serverFile: string, mastraEntryFile: string, analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>, toolsPaths: string[]): Promise<InputOptions>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+    deploy(): Promise<void>;
+    tagWorker({ workerName, namespace, tags, scope, }: {
+        scope: string;
+        workerName: string;
+        namespace: string;
+        tags: string[];
+    }): Promise<void>;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+}
+
+export declare class CloudflareSecretsManager {
+    accountId: string;
+    apiToken: string;
+    baseUrl: string;
+    constructor({ accountId, apiToken }: {
+        accountId: string;
+        apiToken: string;
+    });
+    createSecret({ workerId, secretName, secretValue, }: {
+        workerId: string;
+        secretName: string;
+        secretValue: string;
+    }): Promise<any>;
+    createProjectSecrets({ workerId, customerId, envVars, }: {
+        workerId: string;
+        customerId: string;
+        envVars: Record<string, string>;
+    }): Promise<any>;
+    deleteSecret({ workerId, secretName }: {
+        workerId: string;
+        secretName: string;
+    }): Promise<any>;
+    listSecrets(workerId: string): Promise<any>;
+}
+
+declare interface D1DatabaseBinding {
+    binding: string;
+    database_name: string;
+    database_id: string;
+    preview_database_id?: string;
+}
+
+declare interface KVNamespaceBinding {
+    binding: string;
+    id: string;
+}
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,4 +1,6 @@
+import type { analyzeBundle } from '@mastra/deployer/analyze';
 import { Deployer } from '@mastra/deployer';
+import { InputOptions } from 'rollup';
 
 declare interface CFRoute {
     pattern: string;
@@ -13,7 +15,9 @@ export declare class CloudflareDeployer extends Deployer {
     scope: string;
     env?: Record<string, any>;
     projectName?: string;
-    constructor({ scope, env, projectName, routes, workerNamespace, auth, }: {
+    d1Databases?: D1DatabaseBinding[];
+    kvNamespaces?: KVNamespaceBinding[];
+    constructor({ scope, env, projectName, routes, workerNamespace, auth, d1Databases, kvNamespaces, }: {
         env?: Record<string, any>;
         scope: string;
         projectName?: string;
@@ -23,18 +27,22 @@ export declare class CloudflareDeployer extends Deployer {
             apiToken: string;
             apiEmail?: string;
         };
+        d1Databases?: D1DatabaseBinding[];
+        kvNamespaces?: KVNamespaceBinding[];
     });
     writeFiles(outputDirectory: string): Promise<void>;
     private getEntry;
     prepare(outputDirectory: string): Promise<void>;
-    bundle(entryFile: string, outputDirectory: string): Promise<void>;
-    deploy(outputDirectory: string): Promise<void>;
+    getBundlerOptions(serverFile: string, mastraEntryFile: string, analyzedBundleInfo: Awaited<ReturnType<typeof analyzeBundle>>, toolsPaths: string[]): Promise<InputOptions>;
+    bundle(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
+    deploy(): Promise<void>;
     tagWorker({ workerName, namespace, tags, scope, }: {
         scope: string;
         workerName: string;
         namespace: string;
         tags: string[];
     }): Promise<void>;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: string[]): Promise<void>;
 }
 
 export declare class CloudflareSecretsManager {
@@ -62,4 +70,16 @@ export declare class CloudflareSecretsManager {
     listSecrets(workerId: string): Promise<any>;
 }
 
+declare interface D1DatabaseBinding {
+    binding: string;
+    database_name: string;
+    database_id: string;
+    preview_database_id?: string;
+}
+
+declare interface KVNamespaceBinding {
+    binding: string;
+    id: string;
+}
+
 export { }

package/dist/index.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var deployer = require('@mastra/deployer');
+var virtual = require('@rollup/plugin-virtual');
+var cloudflare = require('cloudflare');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var virtual__default = /*#__PURE__*/_interopDefault(virtual);
+
+// src/index.ts
+var CloudflareDeployer = class extends deployer.Deployer {
+  cloudflare;
+  routes = [];
+  workerNamespace;
+  scope;
+  env;
+  projectName;
+  d1Databases;
+  kvNamespaces;
+  constructor({
+    scope,
+    env,
+    projectName = "mastra",
+    routes,
+    workerNamespace,
+    auth,
+    d1Databases,
+    kvNamespaces
+  }) {
+    super({ name: "CLOUDFLARE" });
+    this.scope = scope;
+    this.projectName = projectName;
+    this.routes = routes;
+    this.workerNamespace = workerNamespace;
+    if (env) {
+      this.env = env;
+    }
+    if (d1Databases) this.d1Databases = d1Databases;
+    if (kvNamespaces) this.kvNamespaces = kvNamespaces;
+    this.cloudflare = new cloudflare.Cloudflare(auth);
+  }
+  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 promises.writeFile(path.join(outputDirectory, this.outputDir, "wrangler.json"), JSON.stringify(wranglerConfig));
+  }
+  getEntry() {
+    return `
+    import '#polyfills';
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
+
+    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(),
+          },
+        });
+      }
+    });
+
+    export default {
+      fetch: async (request, env, context) => {
+        const app = await createHonoServer(mastra)
+        return app.fetch(request, env, context);
+      }
+    }
+`;
+  }
+  async prepare(outputDirectory) {
+    await super.prepare(outputDirectory);
+    await this.writeFiles(outputDirectory);
+  }
+  async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths) {
+    const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths);
+    if (Array.isArray(inputOptions.plugins)) {
+      inputOptions.plugins = [
+        virtual__default.default({
+          "#polyfills": `
+process.versions = process.versions || {};
+process.versions.node = '${process.versions.node}';
+      `
+        }),
+        ...inputOptions.plugins
+      ];
+    }
+    return inputOptions;
+  }
+  async bundle(entryFile, outputDirectory, toolsPaths) {
+    return this._bundle(this.getEntry(), entryFile, outputDirectory, toolsPaths);
+  }
+  async deploy() {
+    this.logger?.info("Deploying to Cloudflare failed. Please use the Cloudflare dashboard to deploy.");
+  }
+  async tagWorker({
+    workerName,
+    namespace,
+    tags,
+    scope
+  }) {
+    if (!this.cloudflare) {
+      throw new Error("Cloudflare Deployer not initialized");
+    }
+    await this.cloudflare.workersForPlatforms.dispatch.namespaces.scripts.tags.update(namespace, workerName, {
+      account_id: scope,
+      body: tags
+    });
+  }
+  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);
+    }
+  }
+};
+
+exports.CloudflareDeployer = CloudflareDeployer;

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { CloudflareDeployer } from './_tsup-dts-rollup.cjs';

package/dist/index.js

@@ -1,9 +1,8 @@
-import { Deployer, createChildProcessLogger } from '@mastra/deployer';
-import '@mastra/deployer/build';
-import '@rollup/plugin-virtual';
-import { Cloudflare } from 'cloudflare';
-import { writeFileSync } from 'fs';
+import { writeFile } from 'fs/promises';
 import { join } from 'path';
+import { Deployer } from '@mastra/deployer';
+import virtual from '@rollup/plugin-virtual';
+import { Cloudflare } from 'cloudflare';
 
 // src/index.ts
 var CloudflareDeployer = class extends Deployer {
@@ -13,13 +12,17 @@ var CloudflareDeployer = class extends Deployer {
   scope;
   env;
   projectName;
+  d1Databases;
+  kvNamespaces;
   constructor({
     scope,
     env,
     projectName = "mastra",
     routes,
     workerNamespace,
-    auth
+    auth,
+    d1Databases,
+    kvNamespaces
   }) {
     super({ name: "CLOUDFLARE" });
     this.scope = scope;
@@ -29,6 +32,8 @@ var CloudflareDeployer = class extends Deployer {
     if (env) {
       this.env = env;
     }
+    if (d1Databases) this.d1Databases = d1Databases;
+    if (kvNamespaces) this.kvNamespaces = kvNamespaces;
     this.cloudflare = new Cloudflare(auth);
   }
   async writeFiles(outputDirectory) {
@@ -37,9 +42,9 @@ var CloudflareDeployer = class extends Deployer {
     const cfWorkerName = this.projectName;
     const wranglerConfig = {
       name: cfWorkerName,
-      main: "index.mjs",
-      compatibility_date: "2024-12-02",
-      compatibility_flags: ["nodejs_compat"],
+      main: "./index.mjs",
+      compatibility_date: "2025-04-01",
+      compatibility_flags: ["nodejs_compat", "nodejs_compat_populate_process_env"],
       observability: {
         logs: {
           enabled: true
@@ -50,47 +55,94 @@ var CloudflareDeployer = class extends Deployer {
     if (!this.workerNamespace && this.routes) {
       wranglerConfig.routes = this.routes;
     }
-    writeFileSync(join(outputDirectory, "wrangler.json"), JSON.stringify(wranglerConfig));
+    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 `
-export default {
-  fetch: async (request, env, context) => {
-    Object.keys(env).forEach(key => {
-      process.env[key] = env[key]
-    })
+    import '#polyfills';
+    import { mastra } from '#mastra';
+    import { createHonoServer } from '#server';
+    import { evaluate } from '@mastra/core/eval';
+    import { AvailableHooks, registerHook } from '@mastra/core/hooks';
+    import { TABLE_EVALS } from '@mastra/core/storage';
+    import { checkEvalStorageFields } from '@mastra/core/utils';
 
-    const { mastra } = await import('#mastra')
-    const { createHonoServer } = await import('#server')
-    const app = await createHonoServer(mastra)
-    return app.fetch(request, env, context);
-  }
-}
+    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(),
+          },
+        });
+      }
+    });
+
+    export default {
+      fetch: async (request, env, context) => {
+        const app = await createHonoServer(mastra)
+        return app.fetch(request, env, context);
+      }
+    }
 `;
   }
   async prepare(outputDirectory) {
     await super.prepare(outputDirectory);
     await this.writeFiles(outputDirectory);
   }
-  async bundle(entryFile, outputDirectory) {
-    return this._bundle(this.getEntry(), entryFile, outputDirectory);
+  async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths) {
+    const inputOptions = await super.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths);
+    if (Array.isArray(inputOptions.plugins)) {
+      inputOptions.plugins = [
+        virtual({
+          "#polyfills": `
+process.versions = process.versions || {};
+process.versions.node = '${process.versions.node}';
+      `
+        }),
+        ...inputOptions.plugins
+      ];
+    }
+    return inputOptions;
   }
-  async deploy(outputDirectory) {
-    const cmd = this.workerNamespace ? `npm exec -- wrangler deploy --dispatch-namespace ${this.workerNamespace}` : "npm exec -- wrangler deploy";
-    const cpLogger = createChildProcessLogger({
-      logger: this.logger,
-      root: outputDirectory
-    });
-    await cpLogger({
-      cmd,
-      args: [],
-      env: {
-        CLOUDFLARE_API_TOKEN: this.cloudflare.apiToken,
-        CLOUDFLARE_ACCOUNT_ID: this.scope,
-        ...this.env,
-        PATH: process.env.PATH
-      }
-    });
+  async bundle(entryFile, outputDirectory, toolsPaths) {
+    return this._bundle(this.getEntry(), entryFile, outputDirectory, toolsPaths);
+  }
+  async deploy() {
+    this.logger?.info("Deploying to Cloudflare failed. Please use the Cloudflare dashboard to deploy.");
   }
   async tagWorker({
     workerName,
@@ -106,6 +158,16 @@ export default {
       body: tags
     });
   }
+  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);
+    }
+  }
 };
 
 export { CloudflareDeployer };

package/{src/secrets-manager/index.ts → dist/secrets-manager/index.cjs}

@@ -1,110 +1,89 @@
-export class CloudflareSecretsManager {
-  accountId: string;
-  apiToken: string;
-  baseUrl: string;
-
-  constructor({ accountId, apiToken }: { accountId: string; apiToken: string }) {
+'use strict';
+
+// src/secrets-manager/index.ts
+var CloudflareSecretsManager = class {
+  accountId;
+  apiToken;
+  baseUrl;
+  constructor({ accountId, apiToken }) {
     this.accountId = accountId;
     this.apiToken = apiToken;
-    this.baseUrl = 'https://api.cloudflare.com/client/v4';
+    this.baseUrl = "https://api.cloudflare.com/client/v4";
   }
-
   async createSecret({
     workerId,
     secretName,
-    secretValue,
-  }: {
-    workerId: string;
-    secretName: string;
-    secretValue: string;
+    secretValue
   }) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets`;
-
     try {
       const response = await fetch(url, {
-        method: 'PUT',
+        method: "PUT",
         headers: {
           Authorization: `Bearer ${this.apiToken}`,
-          'Content-Type': 'application/json',
+          "Content-Type": "application/json"
         },
         body: JSON.stringify({
           name: secretName,
-          text: secretValue,
-        }),
+          text: secretValue
+        })
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to create secret:', error);
+      console.error("Failed to create secret:", error);
       throw error;
     }
   }
-
   async createProjectSecrets({
     workerId,
     customerId,
-    envVars,
-  }: {
-    workerId: string;
-    customerId: string;
-    envVars: Record<string, string>;
+    envVars
   }) {
     const secretName = `PROJECT_${customerId.toUpperCase()}`;
     const secretValue = JSON.stringify(envVars);
-
     return this.createSecret({ workerId, secretName, secretValue });
   }
-
-  async deleteSecret({ workerId, secretName }: { workerId: string; secretName: string }) {
+  async deleteSecret({ workerId, secretName }) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets/${secretName}`;
-
     try {
       const response = await fetch(url, {
-        method: 'DELETE',
+        method: "DELETE",
         headers: {
-          Authorization: `Bearer ${this.apiToken}`,
-        },
+          Authorization: `Bearer ${this.apiToken}`
+        }
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to delete secret:', error);
+      console.error("Failed to delete secret:", error);
       throw error;
     }
   }
-
-  async listSecrets(workerId: string) {
+  async listSecrets(workerId) {
     const url = `${this.baseUrl}/accounts/${this.accountId}/workers/scripts/${workerId}/secrets`;
-
     try {
       const response = await fetch(url, {
         headers: {
-          Authorization: `Bearer ${this.apiToken}`,
-        },
+          Authorization: `Bearer ${this.apiToken}`
+        }
       });
-
-      const data = (await response.json()) as { success: boolean; result: any; errors: any[] };
-
+      const data = await response.json();
       if (!data.success) {
         throw new Error(data.errors[0].message);
       }
-
       return data.result;
     } catch (error) {
-      console.error('Failed to list secrets:', error);
+      console.error("Failed to list secrets:", error);
       throw error;
     }
   }
-}
+};
+
+exports.CloudflareSecretsManager = CloudflareSecretsManager;

package/dist/secrets-manager/index.d.cts

@@ -0,0 +1 @@
+export { CloudflareSecretsManager } from '../_tsup-dts-rollup.cjs';