Backblaze B2 Cloud Storage

1# B2 bucket and key reference
2BUCKET_NAME=my-bubble-private-files
3BUCKET_ID=e73ede9969c64287527b  # from Backblaze console bucket details
4KEY_ID=your_application_keyID_here
5APPLICATION_KEY=your_applicationKey_here
6
7# HTTP Basic Auth for b2_authorize_account:
8# Authorization: Basic base64(keyID:applicationKey)
9# This is handled inside your proxy function, not in Bubble directly

1// Cloudflare Worker — Backblaze B2 Native API Proxy
2// Environment vars: B2_KEY_ID, B2_APPLICATION_KEY, B2_BUCKET_NAME, B2_BUCKET_ID
3
4let cachedAuth = null;
5
6async function authorizeAccount(env) {
7  if (cachedAuth && Date.now() < cachedAuth.expiresAt) {
8    return cachedAuth;
9  }
10
11  const credentials = btoa(`${env.B2_KEY_ID}:${env.B2_APPLICATION_KEY}`);
12  const res = await fetch('https://api.backblazeb2.com/b2api/v2/b2_authorize_account', {
13    headers: { 'Authorization': `Basic ${credentials}` },
14  });
15
16  if (!res.ok) throw new Error(`B2 auth failed: ${res.status}`);
17
18  const data = await res.json();
19  cachedAuth = {
20    apiUrl: data.apiUrl,
21    authorizationToken: data.authorizationToken,
22    downloadUrl: data.downloadUrl,
23    expiresAt: Date.now() + 23 * 60 * 60 * 1000, // 23 hours
24  };
25  return cachedAuth;
26}
27
28export default {
29  async fetch(request, env) {
30    const url = new URL(request.url);
31    const auth = await authorizeAccount(env);
32
33    // POST /getUploadUrl
34    if (url.pathname === '/getUploadUrl' && request.method === 'POST') {
35      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
36        method: 'POST',
37        headers: {
38          'Authorization': auth.authorizationToken,
39          'Content-Type': 'application/json',
40        },
41        body: JSON.stringify({ bucketId: env.B2_BUCKET_ID }),
42      });
43      const data = await res.json();
44      return new Response(JSON.stringify({
45        uploadUrl: data.uploadUrl,
46        uploadAuthorizationToken: data.authorizationToken,
47      }), { headers: { 'Content-Type': 'application/json' } });
48    }
49
50    // POST /getDownloadAuth
51    if (url.pathname === '/getDownloadAuth' && request.method === 'POST') {
52      const { fileName, validDurationInSeconds } = await request.json();
53      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_download_authorization`, {
54        method: 'POST',
55        headers: {
56          'Authorization': auth.authorizationToken,
57          'Content-Type': 'application/json',
58        },
59        body: JSON.stringify({
60          bucketId: env.B2_BUCKET_ID,
61          fileNamePrefix: fileName,
62          validDurationInSeconds: validDurationInSeconds || 3600,
63        }),
64      });
65      const data = await res.json();
66      // Construct the full download URL
67      const downloadUrl = `${auth.downloadUrl}/file/${env.B2_BUCKET_NAME}/${encodeURIComponent(fileName)}?Authorization=${data.authorizationToken}`;
68      return new Response(JSON.stringify({ downloadUrl }), {
69        headers: { 'Content-Type': 'application/json' },
70      });
71    }
72
73    // GET /listFiles
74    if (url.pathname === '/listFiles' && request.method === 'GET') {
75      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
76        method: 'POST',
77        headers: {
78          'Authorization': auth.authorizationToken,
79          'Content-Type': 'application/json',
80        },
81        body: JSON.stringify({ bucketId: env.B2_BUCKET_ID, maxFileCount: 100 }),
82      });
83      const data = await res.json();
84      const files = data.files.map(f => ({
85        name: f.fileName,
86        size: f.contentLength,  // NOTE: native B2 uses contentLength, not size
87        uploadedAt: new Date(f.uploadTimestamp).toISOString(),
88        fileId: f.fileId,
89      }));
90      return new Response(JSON.stringify({ files }), {
91        headers: { 'Content-Type': 'application/json' },
92      });
93    }
94
95    return new Response('Not found', { status: 404 });
96  },
97};

1{
2  "api_name": "B2 Native Proxy",
3  "shared_headers": {
4    "X-Proxy-Token": "<your_secret | Private: checked>"
5  },
6  "calls": [
7    {
8      "name": "Get Upload URL",
9      "method": "POST",
10      "url": "https://your-proxy.workers.dev/getUploadUrl",
11      "body": {},
12      "response_fields": ["uploadUrl", "uploadAuthorizationToken"]
13    },
14    {
15      "name": "Get Download Auth",
16      "method": "POST",
17      "url": "https://your-proxy.workers.dev/getDownloadAuth",
18      "body": {
19        "fileName": "<dynamic>",
20        "validDurationInSeconds": 3600
21      },
22      "response_fields": ["downloadUrl"]
23    },
24    {
25      "name": "List Files",
26      "method": "GET",
27      "url": "https://your-proxy.workers.dev/listFiles",
28      "response_fields": ["files (list)"]
29    }
30  ]
31}

1// Bubble 'Run JavaScript' (Toolbox plugin) — B2 native upload
2// Inputs: uploadUrl, uploadAuthToken, contentType
3// The file comes from a Bubble FileUploader element
4
5(async function() {
6  const uploadUrl = properties.uploadUrl;
7  const uploadAuthToken = properties.uploadAuthToken;
8  const contentType = properties.contentType || 'application/octet-stream';
9
10  const fileInput = document.querySelector('#fileUploader input[type="file"]');
11  const file = fileInput ? fileInput.files[0] : null;
12
13  if (!file) {
14    bubble_fn_result({ success: false, error: 'No file selected' });
15    return;
16  }
17
18  // B2 native upload requires URL-encoded filename in header
19  const encodedFileName = encodeURIComponent(file.name);
20
21  try {
22    const response = await fetch(uploadUrl, {
23      method: 'POST',  // B2 native upload uses POST, not PUT
24      headers: {
25        'Authorization': uploadAuthToken,  // upload-specific token, NOT Bearer
26        'X-Bz-File-Name': encodedFileName,  // MUST be URL-encoded
27        'Content-Type': contentType,
28        'Content-Length': file.size.toString(),
29      },
30      body: file,
31    });
32
33    if (response.ok) {
34      const result = await response.json();
35      bubble_fn_result({ success: true, fileName: result.fileName, fileId: result.fileId });
36    } else {
37      const errText = await response.text();
38      bubble_fn_result({ success: false, error: errText });
39    }
40  } catch (err) {
41    bubble_fn_result({ success: false, error: err.message });
42  }
43})();

1// Bubble workflow — generate a timed download URL on button click
2// Step 1: Call API → B2 Native Proxy → Get Download Auth
3//   fileName: Current user's file record's 'b2_file_name' field
4//   validDurationInSeconds: 3600
5// Step 2: Open external website (new tab)
6//   URL: Result of step 1's 'downloadUrl'
7
8// The proxy constructs:
9// {downloadUrl}/file/{bucketName}/{encodedFileName}?Authorization={token}
10// Example:
11// https://f004.backblazeb2.com/file/my-bucket/My%20File.pdf?Authorization=4_0022...
12
13// Privacy rules reminder:
14// Data → Privacy → 'UserFile' type:
15// - 'b2_file_name' field: condition = Current User = This UserFile's owner
16// Without this, any logged-in user could call the download auth with another user's filename

1// Enhanced proxy with retry-on-401 pattern and KV storage
2export default {
3  async fetch(request, env, ctx) {
4    // Try to get cached token from KV store
5    let auth = null;
6    const cached = await env.B2_CACHE.get('auth', 'json');
7    if (cached && Date.now() < cached.expiresAt) {
8      auth = cached;
9    } else {
10      auth = await fetchNewAuth(env);
11      // Store in KV with 23-hour TTL
12      ctx.waitUntil(
13        env.B2_CACHE.put('auth', JSON.stringify(auth), { expirationTtl: 82800 })
14      );
15    }
16
17    // Attempt the actual B2 call
18    const result = await handleRequest(request, env, auth);
19
20    // If 401, re-auth and retry once
21    if (result.status === 401) {
22      auth = await fetchNewAuth(env);
23      ctx.waitUntil(
24        env.B2_CACHE.put('auth', JSON.stringify(auth), { expirationTtl: 82800 })
25      );
26      return handleRequest(request, env, auth);
27    }
28
29    return result;
30  },
31};
32
33async function fetchNewAuth(env) {
34  const credentials = btoa(`${env.B2_KEY_ID}:${env.B2_APPLICATION_KEY}`);
35  const res = await fetch('https://api.backblazeb2.com/b2api/v2/b2_authorize_account', {
36    headers: { 'Authorization': `Basic ${credentials}` },
37  });
38  const data = await res.json();
39  return {
40    apiUrl: data.apiUrl,
41    authorizationToken: data.authorizationToken,
42    downloadUrl: data.downloadUrl,
43    expiresAt: Date.now() + 23 * 60 * 60 * 1000,
44  };
45}