@mastra/deployer-cloudflare 0.1.8-alpha.9 → 0.1.8

package/eslint.config.js

@@ -1,6 +0,0 @@
-import { createConfig } from '@internal/lint/eslint';
-
-const config = await createConfig();
-
-/** @type {import("eslint").Linter.Config[]} */
-export default [...config];

package/global.d.ts

@@ -1 +0,0 @@
-declare module 'rollup-plugin-shim';

package/src/index.ts

@@ -1,147 +0,0 @@
-import { writeFileSync } from 'fs';
-import { join } from 'path';
-
-import { Deployer, createChildProcessLogger } from '@mastra/deployer';
-import { Cloudflare } from 'cloudflare';
-
-interface CFRoute {
-  pattern: string;
-  zone_name: string;
-  custom_domain?: boolean;
-}
-
-export class CloudflareDeployer extends Deployer {
-  private cloudflare: Cloudflare | undefined;
-  routes?: CFRoute[] = [];
-  workerNamespace?: string;
-  scope: string;
-  env?: Record<string, any>;
-  projectName?: string;
-
-  constructor({
-    scope,
-    env,
-    projectName = 'mastra',
-    routes,
-    workerNamespace,
-    auth,
-  }: {
-    env?: Record<string, any>;
-    scope: string;
-    projectName?: string;
-    routes?: CFRoute[];
-    workerNamespace?: string;
-    auth: {
-      apiToken: string;
-      apiEmail?: string;
-    };
-  }) {
-    super({ name: 'CLOUDFLARE' });
-
-    this.scope = scope;
-    this.projectName = projectName;
-    this.routes = routes;
-    this.workerNamespace = workerNamespace;
-
-    if (env) {
-      this.env = env;
-    }
-
-    this.cloudflare = new Cloudflare(auth);
-  }
-
-  async writeFiles(outputDirectory: string): Promise<void> {
-    const env = await this.loadEnvVars();
-
-    const envsAsObject = Object.assign({}, Object.fromEntries(env.entries()), this.env);
-
-    const cfWorkerName = this.projectName;
-
-    const wranglerConfig: Record<string, any> = {
-      name: cfWorkerName,
-      main: './output/index.mjs',
-      compatibility_date: '2024-12-02',
-      compatibility_flags: ['nodejs_compat'],
-      observability: {
-        logs: {
-          enabled: true,
-        },
-      },
-      vars: envsAsObject,
-    };
-
-    if (!this.workerNamespace && this.routes) {
-      wranglerConfig.routes = this.routes;
-    }
-
-    writeFileSync(join(outputDirectory, 'wrangler.json'), JSON.stringify(wranglerConfig));
-  }
-
-  private getEntry(): string {
-    return `
-export default {
-  fetch: async (request, env, context) => {
-    Object.keys(env).forEach(key => {
-      process.env[key] = env[key]
-    })
-
-    const { mastra } = await import('#mastra')
-    const { createHonoServer } = await import('#server')
-    const app = await createHonoServer(mastra)
-    return app.fetch(request, env, context);
-  }
-}
-`;
-  }
-  async prepare(outputDirectory: string): Promise<void> {
-    await super.prepare(outputDirectory);
-    await this.writeFiles(outputDirectory);
-  }
-
-  async bundle(entryFile: string, outputDirectory: string): Promise<void> {
-    return this._bundle(this.getEntry(), entryFile, outputDirectory);
-  }
-
-  async deploy(outputDirectory: string): Promise<void> {
-    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 tagWorker({
-    workerName,
-    namespace,
-    tags,
-    scope,
-  }: {
-    scope: string;
-    workerName: string;
-    namespace: string;
-    tags: string[];
-  }): Promise<void> {
-    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,
-    });
-  }
-}

package/src/secrets-manager/index.test.ts

@@ -1,230 +0,0 @@
-// secrets-manager.test.ts
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-import { CloudflareSecretsManager } from './index.js';
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-describe('CloudflareSecretsManager', () => {
-  let secretsManager: CloudflareSecretsManager;
-  const mockAccountId = 'test-account-id';
-  const mockApiToken = 'test-api-token';
-  const mockWorkerId = 'test-worker';
-
-  beforeEach(() => {
-    secretsManager = new CloudflareSecretsManager({
-      accountId: mockAccountId,
-      apiToken: mockApiToken,
-    });
-    vi.resetAllMocks();
-  });
-
-  describe('createSecret', () => {
-    it('should successfully create a secret', async () => {
-      const mockResponse = {
-        success: true,
-        result: { name: 'TEST_SECRET_123', type: 'secret_text' },
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockResponse),
-        } as Response),
-      );
-
-      const result = await secretsManager.createSecret({
-        workerId: mockWorkerId,
-        secretName: 'TEST_SECRET_123',
-        secretValue: 'test-value',
-      });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `https://api.cloudflare.com/client/v4/accounts/${mockAccountId}/workers/scripts/${mockWorkerId}/secrets`,
-        {
-          method: 'PUT',
-          headers: {
-            Authorization: `Bearer ${mockApiToken}`,
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            name: 'TEST_SECRET_123',
-            text: 'test-value',
-          }),
-        },
-      );
-
-      expect(result).toEqual(mockResponse.result);
-    });
-
-    it('should handle API errors for invalid secret names', async () => {
-      const mockError = {
-        success: false,
-        errors: [{ message: 'Invalid secret name' }],
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockError),
-        } as Response),
-      );
-
-      await expect(
-        secretsManager.createSecret({
-          workerId: mockWorkerId,
-          secretName: 'invalid-name!', // Invalid secret name with special character
-          secretValue: 'test-value',
-        }),
-      ).rejects.toThrowError('Invalid secret name');
-    });
-
-    it('should handle network errors', async () => {
-      mockFetch.mockRejectedValueOnce(new Error('Network error'));
-
-      await expect(
-        secretsManager.createSecret({
-          workerId: mockWorkerId,
-          secretName: 'VALID_SECRET_NAME',
-          secretValue: 'test-value',
-        }),
-      ).rejects.toThrowError('Network error');
-    });
-  });
-
-  describe('createProjectSecrets', () => {
-    it('should create project-specific secrets', async () => {
-      const mockResponse = {
-        success: true,
-        result: { name: 'PROJECT_ABC123', type: 'secret_text' },
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockResponse),
-        } as Response),
-      );
-
-      const envVars = {
-        API_KEY: 'test_key',
-        DATABASE_URL: 'test_url',
-      };
-
-      const result = await secretsManager.createProjectSecrets({
-        workerId: mockWorkerId,
-        customerId: 'ABC123',
-        envVars,
-      });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          method: 'PUT',
-          body: JSON.stringify({
-            name: 'PROJECT_ABC123',
-            text: JSON.stringify(envVars),
-          }),
-        }),
-      );
-
-      expect(result).toEqual(mockResponse.result);
-    });
-  });
-
-  describe('deleteSecret', () => {
-    it('should successfully delete a secret', async () => {
-      const mockResponse = {
-        success: true,
-        result: { id: 'deleted-secret-id' },
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockResponse),
-        } as Response),
-      );
-
-      const result = await secretsManager.deleteSecret({
-        workerId: mockWorkerId,
-        secretName: 'TEST_SECRET_123',
-      });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `https://api.cloudflare.com/client/v4/accounts/${mockAccountId}/workers/scripts/${mockWorkerId}/secrets/TEST_SECRET_123`,
-        {
-          method: 'DELETE',
-          headers: {
-            Authorization: `Bearer ${mockApiToken}`,
-          },
-        },
-      );
-
-      expect(result).toEqual(mockResponse.result);
-    });
-
-    it('should handle deletion errors', async () => {
-      const mockError = {
-        success: false,
-        errors: [{ message: 'Secret not found' }],
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockError),
-        } as Response),
-      );
-
-      await expect(
-        secretsManager.deleteSecret({
-          workerId: mockWorkerId,
-          secretName: 'NONEXISTENT_SECRET',
-        }),
-      ).rejects.toThrowError('Secret not found');
-    });
-  });
-
-  describe('listSecrets', () => {
-    it('should successfully list all secrets', async () => {
-      const mockResponse = {
-        success: true,
-        result: [
-          { name: 'PROJECT_ABC123', type: 'secret_text' },
-          { name: 'PROJECT_DEF456', type: 'secret_text' },
-        ],
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockResponse),
-        } as Response),
-      );
-
-      const result = await secretsManager.listSecrets(mockWorkerId);
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        `https://api.cloudflare.com/client/v4/accounts/${mockAccountId}/workers/scripts/${mockWorkerId}/secrets`,
-        {
-          headers: {
-            Authorization: `Bearer ${mockApiToken}`,
-          },
-        },
-      );
-
-      expect(result).toEqual(mockResponse.result);
-    });
-
-    it('should handle listing errors', async () => {
-      const mockError = {
-        success: false,
-        errors: [{ message: 'Invalid worker ID' }],
-      };
-
-      mockFetch.mockReturnValueOnce(
-        Promise.resolve({
-          json: () => Promise.resolve(mockError),
-        } as Response),
-      );
-
-      await expect(secretsManager.listSecrets('invalid-worker')).rejects.toThrowError('Invalid worker ID');
-    });
-  });
-});

package/src/secrets-manager/index.ts

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

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["./global.d.ts", "src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});