How to Integrate Replit with Wasabi

1// check-wasabi-config.js — Verify Wasabi secrets and connection
2const required = ['WASABI_ACCESS_KEY_ID', 'WASABI_SECRET_ACCESS_KEY', 'WASABI_BUCKET', 'WASABI_REGION'];
3const missing = required.filter(k => !process.env[k]);
4if (missing.length) {
5  console.error('Missing Replit Secrets:', missing.join(', '));
6  console.error('Add them via the lock icon 🔒 in Replit sidebar.');
7  process.exit(1);
8}
9const endpoint = `https://s3.${process.env.WASABI_REGION}.wasabisys.com`;
10console.log('Wasabi secrets verified.');
11console.log('Region:', process.env.WASABI_REGION);
12console.log('Endpoint:', endpoint);
13console.log('Bucket:', process.env.WASABI_BUCKET);

1// Validate all required Wasabi secrets at startup
2const WASABI_CONFIG = {
3  accessKeyId: process.env.WASABI_ACCESS_KEY_ID,
4  secretAccessKey: process.env.WASABI_SECRET_ACCESS_KEY,
5  bucket: process.env.WASABI_BUCKET,
6  region: process.env.WASABI_REGION,
7  endpoint: `https://s3.${process.env.WASABI_REGION}.wasabisys.com`
8};
9
10const missingKeys = Object.entries(WASABI_CONFIG)
11  .filter(([, v]) => !v)
12  .map(([k]) => k);
13
14if (missingKeys.length > 0) {
15  throw new Error(`Missing Wasabi config: ${missingKeys.join(', ')}. Check Replit Secrets (lock icon 🔒).`);
16}
17
18console.log('Wasabi configured for region:', WASABI_CONFIG.region);
19console.log('Endpoint:', WASABI_CONFIG.endpoint);
20module.exports = WASABI_CONFIG;

1// wasabi.js — Wasabi S3-compatible storage via AWS SDK v3 (Node.js)
2const { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, ListObjectsV2Command } = require('@aws-sdk/client-s3');
3const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
4const express = require('express');
5
6const REGION = process.env.WASABI_REGION;
7const BUCKET = process.env.WASABI_BUCKET;
8
9const wasabi = new S3Client({
10  endpoint: `https://s3.${REGION}.wasabisys.com`,
11  region: REGION,
12  credentials: {
13    accessKeyId: process.env.WASABI_ACCESS_KEY_ID,
14    secretAccessKey: process.env.WASABI_SECRET_ACCESS_KEY
15  }
16});
17
18// Upload a file buffer to Wasabi
19async function uploadFile(key, buffer, contentType) {
20  await wasabi.send(new PutObjectCommand({
21    Bucket: BUCKET,
22    Key: key,
23    Body: buffer,
24    ContentType: contentType
25  }));
26  return `https://s3.${REGION}.wasabisys.com/${BUCKET}/${key}`;
27}
28
29// Generate a presigned URL for direct browser upload (PUT)
30async function getUploadUrl(key, contentType, expiresIn = 300) {
31  return getSignedUrl(wasabi, new PutObjectCommand({
32    Bucket: BUCKET, Key: key, ContentType: contentType
33  }), { expiresIn });
34}
35
36// Generate a presigned URL for private file download (GET)
37async function getDownloadUrl(key, expiresIn = 3600) {
38  return getSignedUrl(wasabi, new GetObjectCommand({ Bucket: BUCKET, Key: key }), { expiresIn });
39}
40
41const app = express();
42app.use(express.json());
43
44// POST /api/upload-url — get a presigned upload URL
45app.post('/api/upload-url', async (req, res) => {
46  const { filename, contentType } = req.body;
47  const allowed = ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf', 'video/mp4'];
48  if (!allowed.includes(contentType)) {
49    return res.status(400).json({ error: 'Content type not allowed' });
50  }
51  const safe = filename.replace(/[^a-zA-Z0-9._-]/g, '_');
52  const key = `uploads/${Date.now()}-${safe}`;
53  const uploadUrl = await getUploadUrl(key, contentType);
54  res.json({ uploadUrl, key, fileUrl: `https://s3.${REGION}.wasabisys.com/${BUCKET}/${key}` });
55});
56
57// GET /api/files — list files in the bucket
58app.get('/api/files', async (req, res) => {
59  const result = await wasabi.send(new ListObjectsV2Command({
60    Bucket: BUCKET,
61    MaxKeys: 100,
62    Prefix: req.query.prefix || ''
63  }));
64  res.json({
65    files: (result.Contents || []).map(f => ({
66      key: f.Key, size: f.Size, lastModified: f.LastModified
67    }))
68  });
69});
70
71// DELETE /api/files/:key — delete a file
72app.delete('/api/files/:key', async (req, res) => {
73  await wasabi.send(new DeleteObjectCommand({ Bucket: BUCKET, Key: req.params.key }));
74  res.json({ deleted: req.params.key });
75});
76
77app.listen(3000, '0.0.0.0', () => console.log('Wasabi server running on port 3000'));

1# wasabi_storage.py — Wasabi via boto3 (Python on Replit)
2import os
3import time
4import boto3
5from botocore.config import Config
6from flask import Flask, request, jsonify
7
8REGION = os.environ['WASABI_REGION']
9BUCKET = os.environ['WASABI_BUCKET']
10ENDPOINT = f'https://s3.{REGION}.wasabisys.com'
11
12wasabi = boto3.client(
13    's3',
14    endpoint_url=ENDPOINT,
15    aws_access_key_id=os.environ['WASABI_ACCESS_KEY_ID'],
16    aws_secret_access_key=os.environ['WASABI_SECRET_ACCESS_KEY'],
17    region_name=REGION,
18    config=Config(signature_version='s3v4')
19)
20
21def upload_bytes(key: str, data: bytes, content_type: str) -> str:
22    """Upload bytes to Wasabi and return the direct object URL."""
23    wasabi.put_object(Bucket=BUCKET, Key=key, Body=data, ContentType=content_type)
24    return f'{ENDPOINT}/{BUCKET}/{key}'
25
26def get_upload_url(key: str, content_type: str, expires: int = 300) -> str:
27    """Generate a presigned PUT URL for direct browser uploads."""
28    return wasabi.generate_presigned_url(
29        'put_object',
30        Params={'Bucket': BUCKET, 'Key': key, 'ContentType': content_type},
31        ExpiresIn=expires
32    )
33
34def get_download_url(key: str, expires: int = 3600) -> str:
35    """Generate a presigned GET URL for private file access."""
36    return wasabi.generate_presigned_url(
37        'get_object',
38        Params={'Bucket': BUCKET, 'Key': key},
39        ExpiresIn=expires
40    )
41
42def list_files(prefix: str = '', max_keys: int = 100):
43    """List objects in the Wasabi bucket."""
44    resp = wasabi.list_objects_v2(Bucket=BUCKET, Prefix=prefix, MaxKeys=max_keys)
45    return [{'key': o['Key'], 'size': o['Size'], 'lastModified': str(o['LastModified'])}
46            for o in resp.get('Contents', [])]
47
48app = Flask(__name__)
49
50@app.route('/api/upload-url', methods=['POST'])
51def request_upload_url():
52    data = request.get_json()
53    content_type = data.get('contentType', '')
54    filename = data.get('filename', 'file')
55    allowed = {'image/jpeg', 'image/png', 'image/webp', 'application/pdf', 'video/mp4'}
56    if content_type not in allowed:
57        return jsonify({'error': 'Content type not allowed'}), 400
58    safe = ''.join(c if c.isalnum() or c in '._-' else '_' for c in filename)
59    key = f'uploads/{int(time.time())}-{safe}'
60    url = get_upload_url(key, content_type)
61    return jsonify({'uploadUrl': url, 'key': key})
62
63@app.route('/api/files')
64def list_endpoint():
65    prefix = request.args.get('prefix', '')
66    return jsonify({'files': list_files(prefix)})
67
68if __name__ == '__main__':
69    app.run(host='0.0.0.0', port=3000)