import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const result = await uploader.upload(fileBuffer, 'image.jpg')
console.log(`✅ Uploaded: ${result.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const hasil = await uploader.upload(fileBuffer, 'gambar.jpg')
console.log(`✅ Terupload: ${hasil.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const result = await uploader.upload(fileBuffer, 'image.jpg')
console.log(`✅ アップロード完了: ${result.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const resultado = await uploader.upload(fileBuffer, 'imagem.jpg')
console.log(`✅ Enviado: ${resultado.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const результат = await uploader.upload(fileBuffer, 'изображение.jpg')
console.log(`✅ Загружено: ${результат.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const 结果 = await uploader.upload(fileBuffer, '图片.jpg')
console.log(`✅ 已上传: ${结果.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const resultado = await uploader.upload(fileBuffer, 'imagen.jpg')
console.log(`✅ Subido: ${resultado.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const résultat = await uploader.upload(fileBuffer, 'image.jpg')
console.log(`✅ Téléchargé: ${résultat.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const ergebnis = await uploader.upload(fileBuffer, 'bild.jpg')
console.log(`✅ Hochgeladen: ${ergebnis.result.url}`)

import CloudKuUploader from 'cloudku-uploader'

const uploader = new CloudKuUploader()
const 결과 = await uploader.upload(fileBuffer, '이미지.jpg')
console.log(`✅ 업로드됨: ${결과.result.url}`)

import CloudKuUploader from 'cloudku-uploader'
import { readFileSync } from 'fs'

const uploader = new CloudKuUploader()

async function uploadImage() {
  try {
    const imageBuffer = readFileSync('./photo.jpg')
    const result = await uploader.upload(imageBuffer, 'photo.jpg')
    
    if (result.status === 'success') {
      console.log('🎉 Success!')
      console.log('📎 URL:', result.result.url)
      console.log('📊 Size:', result.result.size)
      console.log('📄 Type:', result.result.type)
    }
  } catch (error) {
    console.error('❌ Upload failed:', error.message)
  }
}

uploadImage()

import CloudKuUploader from 'cloudku-uploader'
import { readFileSync, readdirSync } from 'fs'
import { join } from 'path'

const uploader = new CloudKuUploader()

async function batchUpload(folderPath) {
  const files = readdirSync(folderPath)
  const results = []
  
  for (const filename of files) {
    try {
      const buffer = readFileSync(join(folderPath, filename))
      console.log(`📤 Uploading: ${filename}`)
      
      const result = await uploader.upload(buffer, filename)
      
      if (result.status === 'success') {
        results.push({
          filename: result.result.filename,
          url: result.result.url,
          size: result.result.size,
          originalName: filename
        })
        console.log(`✅ ${filename} uploaded successfully`)
      }
    } catch (error) {
      console.error(`❌ Failed to upload ${filename}:`, error.message)
    }
  }
  
  return results
}

// Usage
const uploadedFiles = await batchUpload('./uploads')
console.table(uploadedFiles)

import express from 'express'
import multer from 'multer'
import CloudKuUploader from 'cloudku-uploader'
import cors from 'cors'
import helmet from 'helmet'
import rateLimit from 'express-rate-limit'

const app = express()
const upload = multer({ 
  limits: { 
    fileSize: 100 * 1024 * 1024, // 100MB
    files: 10 // Max 10 files
  }
})
const uploader = new CloudKuUploader()

// Security middleware
app.use(helmet())
app.use(cors({
  origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
  credentials: true
}))

// Rate limiting
const uploadLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 uploads per windowMs
  message: { error: 'Too many uploads, please try again later.' }
})

app.use('/upload', uploadLimiter)

// Single file upload
app.post('/upload', upload.single('file'), async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ 
        success: false, 
        error: 'No file provided' 
      })
    }

    const result = await uploader.upload(req.file.buffer, req.file.originalname)
    
    if (result.status === 'success') {
      res.json({ 
        success: true, 
        data: {
          url: result.result.url,
          filename: result.result.filename,
          size: result.result.size,
          type: result.result.type,
          uploadedAt: new Date().toISOString()
        }
      })
    } else {
      throw new Error(result.message)
    }
  } catch (error) {
    console.error('Upload error:', error)
    res.status(500).json({ 
      success: false, 
      error: 'Upload failed',
      message: error.message 
    })
  }
})

// Multiple files upload
app.post('/upload-batch', upload.array('files', 10), async (req, res) => {
  try {
    if (!req.files || req.files.length === 0) {
      return res.status(400).json({ 
        success: false, 
        error: 'No files provided' 
      })
    }

    const uploadPromises = req.files.map(file => 
      uploader.upload(file.buffer, file.originalname)
    )
    
    const results = await Promise.allSettled(uploadPromises)
    const successful = results
      .filter(result => result.status === 'fulfilled' && result.value.status === 'success')
      .map(result => ({
        url: result.value.result.url,
        filename: result.value.result.filename,
        size: result.value.result.size,
        type: result.value.result.type
      }))

    const failed = results.filter(result => 
      result.status === 'rejected' || 
      (result.status === 'fulfilled' && result.value.status === 'error')
    ).length

    res.json({ 
      success: true, 
      data: {
        uploaded: successful,
        total: req.files.length,
        successful: successful.length,
        failed: failed,
        uploadedAt: new Date().toISOString()
      }
    })
  } catch (error) {
    console.error('Batch upload error:', error)
    res.status(500).json({ 
      success: false, 
      error: 'Batch upload failed',
      message: error.message 
    })
  }
})

// Health check
app.get('/health', (req, res) => {
  res.json({ 
    status: 'healthy', 
    timestamp: new Date().toISOString(),
    service: 'CloudKu Upload Service'
  })
})

const PORT = process.env.PORT || 3000
app.listen(PORT, () => {
  console.log('🚀 CloudKu Upload Server running on port', PORT)
  console.log('📋 Endpoints available:')
  console.log('  POST /upload - Single file upload')
  console.log('  POST /upload-batch - Multiple files upload')
  console.log('  GET /health - Health check')
})

export default app

import CloudKuUploader from 'cloudku-uploader'

class RobustUploader {
  constructor(options = {}) {
    this.uploader = new CloudKuUploader()
    this.maxRetries = options.maxRetries || 3
    this.retryDelay = options.retryDelay || 1000
    this.backoffMultiplier = options.backoffMultiplier || 2
  }

  async uploadWithRetry(fileBuffer, fileName, options = {}) {
    const { 
      maxRetries = this.maxRetries,
      onProgress = () => {},
      onRetry = () => {}
    } = options

    let lastError
    
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        onProgress({ attempt, maxRetries, status: 'uploading' })
        
        const result = await this.uploader.upload(fileBuffer, fileName)
        
        if (result.status === 'success') {
          onProgress({ attempt, maxRetries, status: 'success', result })
          return result
        }
        
        throw new Error(result.message || 'Upload failed')
      } catch (error) {
        lastError = error
        
        if (attempt < maxRetries) {
          const delay = this.retryDelay * Math.pow(this.backoffMultiplier, attempt - 1)
          
          onRetry({ 
            attempt, 
            maxRetries, 
            error: error.message, 
            retryIn: delay 
          })
          
          await this.delay(delay)
        }
      }
    }
    
    throw new Error(`Upload failed after ${maxRetries} attempts: ${lastError.message}`)
  }

  async delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
  }

  // Upload with progress tracking
  async uploadWithProgress(fileBuffer, fileName) {
    return this.uploadWithRetry(fileBuffer, fileName, {
      onProgress: ({ attempt, maxRetries, status, result }) => {
        switch (status) {
          case 'uploading':
            console.log(`📤 Attempt ${attempt}/${maxRetries}: Uploading ${fileName}...`)
            break
          case 'success':
            console.log(`✅ Upload successful: ${result.result.url}`)
            break
        }
      },
      onRetry: ({ attempt, maxRetries, error, retryIn }) => {
        console.log(`⚠️  Attempt ${attempt}/${maxRetries} failed: ${error}`)
        console.log(`🔄 Retrying in ${retryIn}ms...`)
      }
    })
  }
}

// Usage
const robustUploader = new RobustUploader({
  maxRetries: 5,
  retryDelay: 1000,
  backoffMultiplier: 2
})

try {
  const result = await robustUploader.uploadWithProgress(fileBuffer, 'important-file.jpg')
  console.log('🎉 Final result:', result)
} catch (error) {
  console.error('💥 Upload completely failed:', error.message)
}

{
  'x-content-type-options': 'nosniff',
  'x-frame-options': 'DENY', 
  'x-xss-protection': '0',
  'referrer-policy': 'strict-origin-when-cross-origin',
  'content-security-policy': 'default-src \'self\''
}