NeahNew/lib/s3.ts

import { S3Client, ListObjectsV2Command, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

// Simplified S3 configuration with consistent naming
export const S3_CONFIG = {
  endpoint: process.env.S3_ENDPOINT || 'https://dome-api.slm-lab.net/',
  region: process.env.S3_REGION || 'eu-east-1',
  bucket: process.env.S3_BUCKET || 'pages',
  accessKey: process.env.S3_ACCESS_KEY,
  secretKey: process.env.S3_SECRET_KEY,
}

// Initialize S3 client with standard configuration
const s3Config = {
  region: S3_CONFIG.region,
  endpoint: S3_CONFIG.endpoint,
  forcePathStyle: true, // Required for MinIO
};

// Add credentials if available
if (S3_CONFIG.accessKey && S3_CONFIG.secretKey) {
  Object.assign(s3Config, {
    credentials: {
      accessKeyId: S3_CONFIG.accessKey,
      secretAccessKey: S3_CONFIG.secretKey
    }
  });
}

// Create S3 client
export const s3Client = new S3Client(s3Config);

// Helper functions for S3 operations

// List objects in a "folder" for a specific user
export async function listUserObjects(userId: string, folder: string) {
  try {
    const prefix = `user-${userId}/${folder}/`;
    const command = new ListObjectsV2Command({
      Bucket: S3_CONFIG.bucket,
      Prefix: prefix,
      Delimiter: '/'
    });
    
    const response = await s3Client.send(command);
    
    // Transform S3 objects to match the expected format for the frontend
    // This ensures compatibility with existing NextCloud based components
    return response.Contents?.map(item => ({
      id: item.Key,
      title: item.Key?.split('/').pop()?.replace('.md', '') || '',
      lastModified: item.LastModified?.toISOString(),
      size: item.Size,
      type: 'file',
      mime: item.Key?.endsWith('.md') ? 'text/markdown' : 'application/octet-stream',
      etag: item.ETag
    })) || [];
  } catch (error) {
    console.error('Error listing objects:', error);
    throw error;
  }
}

// Get object content
export async function getObjectContent(key: string) {
  try {
    const command = new GetObjectCommand({
      Bucket: S3_CONFIG.bucket,
      Key: key
    });
    
    const response = await s3Client.send(command);
    
    // Convert the stream to string
    return await response.Body?.transformToString();
  } catch (error) {
    console.error('Error getting object content:', error);
    throw error;
  }
}

// Put object (create or update a file)
export async function putObject(key: string, content: string, contentType?: string) {
  try {
    const command = new PutObjectCommand({
      Bucket: S3_CONFIG.bucket,
      Key: key,
      Body: content,
      ContentType: contentType || (key.endsWith('.md') ? 'text/markdown' : 'text/plain')
    });
    
    const response = await s3Client.send(command);
    
    return {
      id: key,
      title: key.split('/').pop()?.replace('.md', '') || '',
      lastModified: new Date().toISOString(),
      size: content.length,
      type: 'file',
      mime: contentType || (key.endsWith('.md') ? 'text/markdown' : 'text/plain'),
      etag: response.ETag
    };
  } catch (error) {
    console.error('Error putting object:', error);
    throw error;
  }
}

// Delete object
export async function deleteObject(key: string) {
  try {
    const command = new DeleteObjectCommand({
      Bucket: S3_CONFIG.bucket,
      Key: key
    });
    
    await s3Client.send(command);
    return true;
  } catch (error) {
    console.error('Error deleting object:', error);
    throw error;
  }
}

// Create folder structure (In S3, folders are just prefix notations)
export async function createUserFolderStructure(userId: string) {
  try {
    console.log(`Creating folder structure for user: ${userId}`);
    
    // Define standard folders - use lowercase only for simplicity and consistency
    const folders = ['notes', 'diary', 'health', 'contacts'];
    
    // Create folders with placeholders
    const results = [];
    
    for (const folder of folders) {
      try {
        // Create the folder path (just a prefix in S3)
        const key = `user-${userId}/${folder}/`;
        console.log(`Creating folder: ${key}`);
        await putObject(key, '', 'application/x-directory');
        
        // Create a placeholder file to ensure the folder exists and is visible
        const placeholderKey = `user-${userId}/${folder}/.placeholder`;
        await putObject(placeholderKey, 'Folder placeholder', 'text/plain');
        
        results.push(folder);
      } catch (error) {
        console.error(`Error creating folder ${folder}:`, error);
      }
    }
    
    console.log(`Successfully created ${results.length} folders for user ${userId}: ${results.join(', ')}`);
    return true;
  } catch (error) {
    console.error('Error creating folder structure:', error);
    throw error;
  }
}

// Generate pre-signed URL for direct browser upload (optional feature)
export async function generatePresignedUrl(key: string, expiresIn = 3600) {
  try {
    const command = new PutObjectCommand({
      Bucket: S3_CONFIG.bucket,
      Key: key
    });
    
    return await getSignedUrl(s3Client, command, { expiresIn });
  } catch (error) {
    console.error('Error generating presigned URL:', error);
    throw error;
  }
}