@opensaas/stack-storage 0.1.1

package/src/utils/image.ts

@@ -0,0 +1,111 @@
+import sharp from 'sharp'
+import type {
+  ImageTransformationConfig,
+  ImageTransformationResult,
+  StorageProvider,
+} from '../config/types.js'
+
+/**
+ * Gets image dimensions from a buffer
+ */
+export async function getImageDimensions(
+  buffer: Buffer | Uint8Array,
+): Promise<{ width: number; height: number }> {
+  const metadata = await sharp(buffer).metadata()
+  return {
+    width: metadata.width || 0,
+    height: metadata.height || 0,
+  }
+}
+
+/**
+ * Applies a single transformation to an image
+ */
+export async function transformImage(
+  buffer: Buffer | Uint8Array,
+  transformation: ImageTransformationConfig,
+): Promise<Buffer> {
+  let image = sharp(buffer)
+
+  // Apply resizing
+  if (transformation.width || transformation.height) {
+    image = image.resize({
+      width: transformation.width,
+      height: transformation.height,
+      fit: transformation.fit || 'cover',
+    })
+  }
+
+  // Apply format conversion
+  if (transformation.format) {
+    const options = {
+      quality: transformation.quality || 80,
+    }
+
+    switch (transformation.format) {
+      case 'jpeg':
+        image = image.jpeg(options)
+        break
+      case 'png':
+        image = image.png(options)
+        break
+      case 'webp':
+        image = image.webp(options)
+        break
+      case 'avif':
+        image = image.avif(options)
+        break
+    }
+  }
+
+  return await image.toBuffer()
+}
+
+/**
+ * Processes all transformations for an image
+ * Uploads the original and all transformed versions
+ */
+export async function processImageTransformations(
+  buffer: Buffer | Uint8Array,
+  originalFilename: string,
+  transformations: Record<string, ImageTransformationConfig>,
+  storageProvider: StorageProvider,
+  contentType: string,
+): Promise<Record<string, ImageTransformationResult>> {
+  const results: Record<string, ImageTransformationResult> = {}
+
+  for (const [name, config] of Object.entries(transformations)) {
+    // Transform the image
+    const transformedBuffer = await transformImage(buffer, config)
+
+    // Get dimensions of transformed image
+    const { width, height } = await getImageDimensions(transformedBuffer)
+
+    // Generate filename for transformation
+    const ext = config.format ? `.${config.format}` : ''
+    const transformedFilename = `${originalFilename}-${name}${ext}`
+
+    // Upload transformed image
+    const uploadResult = await storageProvider.upload(transformedBuffer, transformedFilename, {
+      contentType:
+        config.format === 'jpeg'
+          ? 'image/jpeg'
+          : config.format === 'png'
+            ? 'image/png'
+            : config.format === 'webp'
+              ? 'image/webp'
+              : config.format === 'avif'
+                ? 'image/avif'
+                : contentType,
+    })
+
+    results[name] = {
+      url: uploadResult.url,
+      width,
+      height,
+      size: uploadResult.size,
+    }
+  }
+
+  return results
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './image.js'
+export * from './upload.js'

package/src/utils/upload.ts

@@ -0,0 +1,122 @@
+import mime from 'mime-types'
+
+/**
+ * File validation options
+ */
+export interface FileValidationOptions {
+  /** Maximum file size in bytes */
+  maxFileSize?: number
+  /** Accepted MIME types (e.g., ['image/jpeg', 'image/png']) */
+  acceptedMimeTypes?: string[]
+  /** Accepted file extensions (e.g., ['.jpg', '.png']) */
+  acceptedExtensions?: string[]
+}
+
+/**
+ * File validation result
+ */
+export interface FileValidationResult {
+  valid: boolean
+  error?: string
+}
+
+/**
+ * Validates a file against the provided options
+ */
+export function validateFile(
+  file: { size: number; name: string; type: string },
+  options?: FileValidationOptions,
+): FileValidationResult {
+  if (!options) {
+    return { valid: true }
+  }
+
+  // Check file size
+  if (options.maxFileSize && file.size > options.maxFileSize) {
+    return {
+      valid: false,
+      error: `File size exceeds maximum allowed size of ${formatFileSize(options.maxFileSize)}`,
+    }
+  }
+
+  // Check MIME type
+  if (options.acceptedMimeTypes && options.acceptedMimeTypes.length > 0) {
+    const fileMimeType = file.type || mime.lookup(file.name) || ''
+    if (!options.acceptedMimeTypes.includes(fileMimeType)) {
+      return {
+        valid: false,
+        error: `File type '${fileMimeType}' is not allowed. Accepted types: ${options.acceptedMimeTypes.join(', ')}`,
+      }
+    }
+  }
+
+  // Check file extension
+  if (options.acceptedExtensions && options.acceptedExtensions.length > 0) {
+    const ext = file.name.substring(file.name.lastIndexOf('.')).toLowerCase()
+    if (!options.acceptedExtensions.includes(ext)) {
+      return {
+        valid: false,
+        error: `File extension '${ext}' is not allowed. Accepted extensions: ${options.acceptedExtensions.join(', ')}`,
+      }
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * Formats file size in human-readable format
+ */
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 Bytes'
+
+  const k = 1024
+  const sizes = ['Bytes', 'KB', 'MB', 'GB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+
+  return `${Math.round((bytes / Math.pow(k, i)) * 100) / 100} ${sizes[i]}`
+}
+
+/**
+ * Gets MIME type from filename
+ */
+export function getMimeType(filename: string): string {
+  return mime.lookup(filename) || 'application/octet-stream'
+}
+
+/**
+ * Extracts file metadata from a File or Blob
+ */
+export interface FileInfo {
+  name: string
+  size: number
+  type: string
+  lastModified?: number
+}
+
+/**
+ * Converts a File/Blob to Buffer for Node.js processing
+ */
+export async function fileToBuffer(file: Blob | File): Promise<Buffer> {
+  const arrayBuffer = await file.arrayBuffer()
+  return Buffer.from(arrayBuffer)
+}
+
+/**
+ * Parses FormData and extracts file information
+ * This is a utility for developers to use in their upload routes
+ */
+export async function parseFileFromFormData(
+  formData: FormData,
+  fieldName: string = 'file',
+): Promise<{ file: File; buffer: Buffer } | null> {
+  const file = formData.get(fieldName)
+
+  if (!file || !(file instanceof File)) {
+    return null
+  }
+
+  const buffer = await fileToBuffer(file)
+
+  return { file, buffer }
+}