418 lines
13 KiB
TypeScript
418 lines
13 KiB
TypeScript
import { Client as MinioClient } from 'minio';
|
|
import { StorageService, FileMetadata, UploadResult } from './StorageService';
|
|
|
|
export class MinioStorageService implements StorageService {
|
|
private client: MinioClient;
|
|
private bucketName: string;
|
|
private publicUrl: string;
|
|
|
|
constructor(
|
|
endpoint: string,
|
|
accessKey: string,
|
|
secretKey: string,
|
|
useSSL: boolean = false,
|
|
bucketName: string = 'banatie',
|
|
publicUrl?: string,
|
|
) {
|
|
// Parse endpoint to separate hostname and port
|
|
const cleanEndpoint = endpoint.replace(/^https?:\/\//, '');
|
|
const [hostname, portStr] = cleanEndpoint.split(':');
|
|
const port = portStr ? parseInt(portStr, 10) : useSSL ? 443 : 9000;
|
|
|
|
if (!hostname) {
|
|
throw new Error(`Invalid MinIO endpoint: ${endpoint}`);
|
|
}
|
|
|
|
this.client = new MinioClient({
|
|
endPoint: hostname,
|
|
port,
|
|
useSSL,
|
|
accessKey,
|
|
secretKey,
|
|
});
|
|
this.bucketName = bucketName;
|
|
this.publicUrl = publicUrl || `${useSSL ? 'https' : 'http'}://${endpoint}`;
|
|
}
|
|
|
|
private getFilePath(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): string {
|
|
// Simplified path without date folder for now
|
|
return `${orgId}/${projectId}/${category}/${filename}`;
|
|
}
|
|
|
|
private generateUniqueFilename(originalFilename: string): string {
|
|
// Sanitize filename first
|
|
const sanitized = this.sanitizeFilename(originalFilename);
|
|
|
|
const timestamp = Date.now();
|
|
const random = Math.random().toString(36).substring(2, 8);
|
|
const ext = sanitized.includes('.') ? sanitized.substring(sanitized.lastIndexOf('.')) : '';
|
|
const name = sanitized.includes('.')
|
|
? sanitized.substring(0, sanitized.lastIndexOf('.'))
|
|
: sanitized;
|
|
|
|
return `${name}-${timestamp}-${random}${ext}`;
|
|
}
|
|
|
|
private sanitizeFilename(filename: string): string {
|
|
// Remove dangerous characters and path traversal attempts
|
|
return filename
|
|
.replace(/[<>:"/\\|?*\x00-\x1f]/g, '') // Remove dangerous chars
|
|
.replace(/\.\./g, '') // Remove path traversal
|
|
.replace(/^\.+/, '') // Remove leading dots
|
|
.trim()
|
|
.substring(0, 255); // Limit length
|
|
}
|
|
|
|
private validateFilePath(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: string,
|
|
filename: string,
|
|
): void {
|
|
// Validate orgId
|
|
if (!orgId || !/^[a-zA-Z0-9_-]+$/.test(orgId) || orgId.length > 50) {
|
|
throw new Error(
|
|
'Invalid organization ID: must be alphanumeric with dashes/underscores, max 50 chars',
|
|
);
|
|
}
|
|
|
|
// Validate projectId
|
|
if (!projectId || !/^[a-zA-Z0-9_-]+$/.test(projectId) || projectId.length > 50) {
|
|
throw new Error(
|
|
'Invalid project ID: must be alphanumeric with dashes/underscores, max 50 chars',
|
|
);
|
|
}
|
|
|
|
// Validate category
|
|
if (!['uploads', 'generated', 'references'].includes(category)) {
|
|
throw new Error('Invalid category: must be uploads, generated, or references');
|
|
}
|
|
|
|
// Validate filename
|
|
if (!filename || filename.length === 0 || filename.length > 255) {
|
|
throw new Error('Invalid filename: must be 1-255 characters');
|
|
}
|
|
|
|
// Check for path traversal and dangerous patterns
|
|
if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
|
|
throw new Error('Invalid characters in filename: path traversal not allowed');
|
|
}
|
|
|
|
// Prevent null bytes and control characters
|
|
if (/[\x00-\x1f]/.test(filename)) {
|
|
throw new Error('Invalid filename: control characters not allowed');
|
|
}
|
|
}
|
|
|
|
async createBucket(): Promise<void> {
|
|
const exists = await this.client.bucketExists(this.bucketName);
|
|
if (!exists) {
|
|
await this.client.makeBucket(this.bucketName, 'us-east-1');
|
|
console.log(`Created bucket: ${this.bucketName}`);
|
|
}
|
|
|
|
// Note: With SNMD and presigned URLs, we don't need bucket policies
|
|
console.log(`Bucket ${this.bucketName} ready for presigned URL access`);
|
|
}
|
|
|
|
async bucketExists(): Promise<boolean> {
|
|
return await this.client.bucketExists(this.bucketName);
|
|
}
|
|
|
|
async uploadFile(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
buffer: Buffer,
|
|
contentType: string,
|
|
): Promise<UploadResult> {
|
|
// Validate inputs first
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
|
|
if (!buffer || buffer.length === 0) {
|
|
throw new Error('Buffer cannot be empty');
|
|
}
|
|
|
|
if (!contentType || contentType.trim().length === 0) {
|
|
throw new Error('Content type is required');
|
|
}
|
|
|
|
// Ensure bucket exists
|
|
await this.createBucket();
|
|
|
|
// Generate unique filename to avoid conflicts
|
|
const uniqueFilename = this.generateUniqueFilename(filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, uniqueFilename);
|
|
|
|
const metadata = {
|
|
'Content-Type': contentType,
|
|
'X-Amz-Meta-Original-Name': filename,
|
|
'X-Amz-Meta-Category': category,
|
|
'X-Amz-Meta-Project': projectId,
|
|
'X-Amz-Meta-Organization': orgId,
|
|
'X-Amz-Meta-Upload-Time': new Date().toISOString(),
|
|
};
|
|
|
|
console.log(`Uploading file to: ${this.bucketName}/${filePath}`);
|
|
|
|
const result = await this.client.putObject(
|
|
this.bucketName,
|
|
filePath,
|
|
buffer,
|
|
buffer.length,
|
|
metadata,
|
|
);
|
|
|
|
const url = this.getPublicUrl(orgId, projectId, category, uniqueFilename);
|
|
|
|
console.log(`Generated API URL: ${url}`);
|
|
|
|
return {
|
|
success: true,
|
|
filename: uniqueFilename,
|
|
path: filePath,
|
|
url,
|
|
size: buffer.length,
|
|
contentType,
|
|
};
|
|
}
|
|
|
|
async downloadFile(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): Promise<Buffer> {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
|
|
const stream = await this.client.getObject(this.bucketName, filePath);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const chunks: Buffer[] = [];
|
|
stream.on('data', (chunk) => chunks.push(chunk));
|
|
stream.on('end', () => resolve(Buffer.concat(chunks)));
|
|
stream.on('error', reject);
|
|
});
|
|
}
|
|
|
|
async streamFile(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): Promise<import('stream').Readable> {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
|
|
// Return the stream directly without buffering - memory efficient!
|
|
return await this.client.getObject(this.bucketName, filePath);
|
|
}
|
|
|
|
async deleteFile(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): Promise<void> {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
await this.client.removeObject(this.bucketName, filePath);
|
|
}
|
|
|
|
getPublicUrl(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): string {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
// Production-ready: Return API URL for presigned URL access
|
|
const apiBaseUrl = process.env['API_BASE_URL'] || 'http://localhost:3000';
|
|
return `${apiBaseUrl}/api/images/${orgId}/${projectId}/${category}/${filename}`;
|
|
}
|
|
|
|
async getPresignedUploadUrl(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
expirySeconds: number,
|
|
contentType: string,
|
|
): Promise<string> {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
|
|
if (!contentType || contentType.trim().length === 0) {
|
|
throw new Error('Content type is required for presigned upload URL');
|
|
}
|
|
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
return await this.client.presignedPutObject(this.bucketName, filePath, expirySeconds);
|
|
}
|
|
|
|
async getPresignedDownloadUrl(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
expirySeconds: number = 86400, // 24 hours default
|
|
): Promise<string> {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
const presignedUrl = await this.client.presignedGetObject(
|
|
this.bucketName,
|
|
filePath,
|
|
expirySeconds,
|
|
);
|
|
|
|
// Replace internal Docker hostname with public URL if configured
|
|
if (this.publicUrl) {
|
|
const clientEndpoint = this.client.host + (this.client.port ? `:${this.client.port}` : '');
|
|
const publicEndpoint = this.publicUrl.replace(/^https?:\/\//, '');
|
|
|
|
return presignedUrl.replace(`${this.client.protocol}//${clientEndpoint}`, this.publicUrl);
|
|
}
|
|
|
|
return presignedUrl;
|
|
}
|
|
|
|
async listProjectFiles(
|
|
orgId: string,
|
|
projectId: string,
|
|
category?: 'uploads' | 'generated' | 'references',
|
|
): Promise<FileMetadata[]> {
|
|
const prefix = category ? `${orgId}/${projectId}/${category}/` : `${orgId}/${projectId}/`;
|
|
|
|
const files: FileMetadata[] = [];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const stream = this.client.listObjects(this.bucketName, prefix, true);
|
|
|
|
stream.on('data', async (obj) => {
|
|
try {
|
|
if (!obj.name) return;
|
|
|
|
const metadata = await this.client.statObject(this.bucketName, obj.name);
|
|
|
|
const pathParts = obj.name.split('/');
|
|
const filename = pathParts[pathParts.length - 1];
|
|
const categoryFromPath = pathParts[2] as 'uploads' | 'generated' | 'references';
|
|
|
|
if (!filename || !categoryFromPath) {
|
|
return;
|
|
}
|
|
|
|
files.push({
|
|
key: `${this.bucketName}/${obj.name}`,
|
|
filename,
|
|
contentType: metadata.metaData?.['content-type'] || 'application/octet-stream',
|
|
size: obj.size || 0,
|
|
url: this.getPublicUrl(orgId, projectId, categoryFromPath, filename),
|
|
createdAt: obj.lastModified || new Date(),
|
|
});
|
|
} catch (error) {}
|
|
});
|
|
|
|
stream.on('end', () => resolve(files));
|
|
stream.on('error', reject);
|
|
});
|
|
}
|
|
|
|
parseKey(key: string): {
|
|
orgId: string;
|
|
projectId: string;
|
|
category: 'uploads' | 'generated' | 'references';
|
|
filename: string;
|
|
} | null {
|
|
try {
|
|
const match = key.match(
|
|
/^banatie\/([^/]+)\/([^/]+)\/(uploads|generated|references)\/[^/]+\/(.+)$/,
|
|
);
|
|
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
|
|
const [, orgId, projectId, category, filename] = match;
|
|
|
|
if (!orgId || !projectId || !category || !filename) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
orgId,
|
|
projectId,
|
|
category: category as 'uploads' | 'generated' | 'references',
|
|
filename,
|
|
};
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async fileExists(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
filename: string,
|
|
): Promise<boolean> {
|
|
try {
|
|
this.validateFilePath(orgId, projectId, category, filename);
|
|
const filePath = this.getFilePath(orgId, projectId, category, filename);
|
|
await this.client.statObject(this.bucketName, filePath);
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async listFiles(
|
|
orgId: string,
|
|
projectId: string,
|
|
category: 'uploads' | 'generated' | 'references',
|
|
prefix?: string,
|
|
): Promise<FileMetadata[]> {
|
|
this.validateFilePath(orgId, projectId, category, 'dummy.txt');
|
|
|
|
const basePath = `${orgId}/${projectId}/${category}/`;
|
|
const searchPrefix = prefix ? `${basePath}${prefix}` : basePath;
|
|
|
|
const files: FileMetadata[] = [];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const stream = this.client.listObjects(this.bucketName, searchPrefix, true);
|
|
|
|
stream.on('data', async (obj) => {
|
|
if (!obj.name || !obj.size) return;
|
|
|
|
try {
|
|
const pathParts = obj.name.split('/');
|
|
const filename = pathParts[pathParts.length - 1];
|
|
|
|
if (!filename) return;
|
|
|
|
const metadata = await this.client.statObject(this.bucketName, obj.name);
|
|
|
|
files.push({
|
|
filename,
|
|
size: obj.size,
|
|
contentType: metadata.metaData?.['content-type'] || 'application/octet-stream',
|
|
lastModified: obj.lastModified || new Date(),
|
|
etag: metadata.etag,
|
|
path: obj.name,
|
|
});
|
|
} catch (error) {}
|
|
});
|
|
|
|
stream.on('end', () => resolve(files));
|
|
stream.on('error', reject);
|
|
});
|
|
}
|
|
}
|