@nextlyhq/storage-uploadthing 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,475 @@
+/**
+ * Media Storage Types
+ *
+ * Defines interfaces and types for the unified media storage system.
+ * Supports cloud storage adapters via plugins.
+ *
+ * Storage Backends:
+ * - AWS S3 / Cloudflare R2 / MinIO (via @nextlyhq/storage-s3)
+ * - Vercel Blob (via @nextlyhq/storage-vercel-blob)
+ */
+interface UploadOptions {
+    /** Original filename from user */
+    filename: string;
+    /** MIME type (e.g., 'image/png', 'video/mp4') */
+    mimeType: string;
+    /** Optional content type override */
+    contentType?: string;
+    /** Optional folder/prefix for organizing uploads */
+    folder?: string;
+    /** Collection slug this upload belongs to (for collection-specific storage) */
+    collection?: string;
+    /** Optional Content-Disposition header value (e.g., 'attachment' for SVG security) */
+    contentDisposition?: "inline" | "attachment";
+}
+interface UploadResult {
+    /** Public URL to access the file */
+    url: string;
+    /** Storage path/key (for deletion and metadata retrieval) */
+    path: string;
+}
+/**
+ * Extended file metadata returned by getMetadata()
+ *
+ * Contains comprehensive information about an uploaded file,
+ * including dimensions for images and creation timestamps.
+ */
+interface FileMetadata {
+    /** Unique identifier (typically the storage path/key) */
+    id: string;
+    /** Storage filename (may differ from original) */
+    filename: string;
+    /** Original filename as uploaded by user */
+    originalFilename: string;
+    /** MIME type (e.g., 'image/jpeg', 'application/pdf') */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+    /** Public URL to access the file */
+    url: string;
+    /** Thumbnail URL for images (if generated) */
+    thumbnailUrl?: string;
+    /** Image width in pixels (for images only) */
+    width?: number;
+    /** Image height in pixels (for images only) */
+    height?: number;
+    /** ISO timestamp when file was uploaded */
+    createdAt: string;
+    /** ISO timestamp when file was last modified */
+    updatedAt?: string;
+}
+/**
+ * Storage type identifier.
+ * - "s3": AWS S3 or S3-compatible services (R2, MinIO, DigitalOcean Spaces)
+ * - "vercel-blob": Vercel Blob Storage
+ * - "local": Local disk storage (default for development)
+ * - "uploadthing": Uploadthing cloud storage
+ */
+type StorageType = "s3" | "vercel-blob" | "local" | "uploadthing";
+/**
+ * Information about a storage adapter's capabilities.
+ * Returned by adapter.getInfo() method.
+ */
+interface StorageAdapterInfo {
+    /** Storage type identifier */
+    type: StorageType;
+    /** Human-readable adapter name */
+    name: string;
+    /** Whether this adapter supports signed URLs for private access */
+    supportsSignedUrls: boolean;
+    /** Whether this adapter supports client-side (direct) uploads */
+    supportsClientUploads: boolean;
+}
+/**
+ * Per-collection storage configuration.
+ * Allows customizing storage behavior for specific upload collections.
+ */
+interface CollectionStorageConfig {
+    /** Prefix/folder for this collection's uploads */
+    prefix?: string;
+    /** Enable client-side uploads (for serverless platforms with body size limits) */
+    clientUploads?: boolean;
+    /** Generate signed URLs for downloads (for private buckets) */
+    signedDownloads?: boolean;
+    /** Signed URL expiry time in seconds (default: 3600) */
+    signedUrlExpiresIn?: number;
+}
+/**
+ * Collection storage map - maps collection slugs to their config.
+ * Used in storage plugin configuration.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   media: true,  // Use default config
+ *   'private-docs': {
+ *     prefix: 'private/',
+ *     signedDownloads: true,
+ *     signedUrlExpiresIn: 900
+ *   }
+ * }
+ * ```
+ */
+type CollectionStorageMap = Record<string, boolean | CollectionStorageConfig>;
+/**
+ * Base configuration for storage plugins.
+ * Extended by specific adapter configs (S3StorageConfig, etc.)
+ */
+interface StoragePluginConfig {
+    /** Enable/disable the plugin (default: true) */
+    enabled?: boolean;
+    /** Collections to apply this storage adapter to */
+    collections: CollectionStorageMap;
+}
+/**
+ * Storage plugin returned by adapter plugin functions.
+ * These are processed during Nextly initialization.
+ *
+ * @example
+ * ```typescript
+ * // From @nextlyhq/storage-s3
+ * const plugin = s3Storage({
+ *   bucket: 'my-bucket',
+ *   region: 'us-east-1',
+ *   collections: { media: true }
+ * });
+ * // plugin implements StoragePlugin
+ * ```
+ */
+interface StoragePlugin {
+    /** Plugin name for identification */
+    name: string;
+    /** Storage type */
+    type: StorageType;
+    /** Collections this plugin handles */
+    collections: CollectionStorageMap;
+    /** The storage adapter instance */
+    adapter: IStorageAdapter;
+    /**
+     * Handler for generating client-side upload URLs.
+     * Called when clientUploads is enabled for a collection.
+     */
+    getClientUploadUrl?: (filename: string, mimeType: string, collection: string) => Promise<ClientUploadData>;
+    /**
+     * Handler for generating signed download URLs.
+     * Called when signedDownloads is enabled for a collection.
+     */
+    getSignedDownloadUrl?: (path: string, expiresIn?: number) => Promise<string>;
+}
+/**
+ * Data returned for client-side (direct) uploads.
+ * Contains pre-signed URL and headers for direct-to-storage uploads.
+ *
+ * @example
+ * ```typescript
+ * // Usage in frontend
+ * const uploadData = await fetch('/api/nextly/storage/upload-url', {
+ *   method: 'POST',
+ *   body: JSON.stringify({ filename: 'photo.jpg', mimeType: 'image/jpeg', collection: 'media' })
+ * }).then(r => r.json());
+ *
+ * // Direct upload to storage
+ * await fetch(uploadData.uploadUrl, {
+ *   method: uploadData.method,
+ *   headers: uploadData.headers,
+ *   body: file
+ * });
+ * ```
+ */
+interface ClientUploadData {
+    /** Pre-signed URL for direct upload */
+    uploadUrl: string;
+    /** Storage path/key that will be used */
+    path: string;
+    /** HTTP method to use (usually PUT for S3, POST for some services) */
+    method: "PUT" | "POST";
+    /** Headers to include in upload request */
+    headers?: Record<string, string>;
+    /** Form fields for multipart uploads (some services require this) */
+    fields?: Record<string, string>;
+    /** URL expiry timestamp */
+    expiresAt: Date;
+}
+/**
+ * Base storage adapter interface.
+ * All storage adapters must implement this interface.
+ *
+ * Core methods (required):
+ * - upload: Store file buffer
+ * - delete: Remove file from storage
+ * - exists: Check if file exists
+ * - getPublicUrl: Get public URL for file access
+ * - getType: Get storage type identifier
+ *
+ * Optional methods:
+ * - getInfo: Get adapter capabilities (recommended)
+ * - getMetadata: Retrieve file metadata
+ * - getSignedUrl: Generate temporary signed URLs for private access
+ * - getPresignedUploadUrl: Generate pre-signed URL for client uploads
+ */
+interface BulkDeleteResult {
+    successful: string[];
+    failed: Array<{
+        filePath: string;
+        error: string;
+    }>;
+}
+interface IStorageAdapter {
+    /** Upload file buffer to storage */
+    upload(buffer: Buffer, options: UploadOptions): Promise<UploadResult>;
+    /** Delete file from storage */
+    delete(filePath: string): Promise<void>;
+    /** Bulk delete files from storage. Optional — adapters that support batch operations should implement this. */
+    bulkDelete?(filePaths: string[]): Promise<BulkDeleteResult>;
+    /** Check if file exists in storage */
+    exists(filePath: string): Promise<boolean>;
+    /** Get public URL for file */
+    getPublicUrl(filePath: string): string;
+    /** Get storage type identifier */
+    getType(): string;
+    /** Read file contents from storage (optional - not all adapters support this) */
+    read?(filePath: string): Promise<Buffer | null>;
+    /** Get adapter info including capabilities (optional but recommended) */
+    getInfo?(): StorageAdapterInfo;
+    /** Get file metadata (optional - not all adapters support this) */
+    getMetadata?(filePath: string): Promise<FileMetadata | null>;
+    /** Generate signed URL for temporary private access (optional) */
+    getSignedUrl?(filePath: string, expiresIn?: number): Promise<string>;
+    /** Generate pre-signed upload URL for client-side uploads (optional) */
+    getPresignedUploadUrl?(key: string, mimeType: string, expiresIn?: number): Promise<ClientUploadData>;
+}
+
+/**
+ * Base Storage Adapter
+ *
+ * BaseStorageAdapter abstract class with common functionality for storage
+ * adapters. Concrete adapters extend this class to inherit auto-detected
+ * capabilities, sanitizeFilename(), generateKey(), etc.
+ *
+ * For the IStorageAdapter interface itself, import from ../types directly.
+ */
+
+/**
+ * Abstract base class for storage adapters.
+ *
+ * Provides common functionality and helper methods that all storage adapters
+ * can use. Concrete adapters should extend this class to inherit:
+ * - Default getInfo() implementation with auto-detected capabilities
+ * - sanitizeFilename() helper for secure filename handling
+ * - generateKey() helper for unique storage key generation
+ *
+ * @example
+ * ```typescript
+ * class MyStorageAdapter extends BaseStorageAdapter {
+ *   async upload(buffer: Buffer, options: UploadOptions): Promise<UploadResult> {
+ *     const key = this.generateKey(options.filename, options.folder);
+ *     const sanitized = this.sanitizeFilename(options.filename);
+ *     // ... upload logic
+ *   }
+ *
+ *   async delete(filePath: string): Promise<void> { ... }
+ *   async exists(filePath: string): Promise<boolean> { ... }
+ *   getPublicUrl(filePath: string): string { ... }
+ *   getType(): string { return 'my-storage'; }
+ * }
+ * ```
+ */
+declare abstract class BaseStorageAdapter implements IStorageAdapter {
+    /**
+     * Upload file buffer to storage.
+     * Must be implemented by concrete adapters.
+     */
+    abstract upload(buffer: Buffer, options: UploadOptions): Promise<UploadResult>;
+    /**
+     * Delete file from storage.
+     * Must be implemented by concrete adapters.
+     */
+    abstract delete(filePath: string): Promise<void>;
+    /**
+     * Check if file exists in storage.
+     * Must be implemented by concrete adapters.
+     */
+    abstract exists(filePath: string): Promise<boolean>;
+    /**
+     * Get public URL for file.
+     * Must be implemented by concrete adapters.
+     */
+    abstract getPublicUrl(filePath: string): string;
+    /**
+     * Get storage type identifier.
+     * Must be implemented by concrete adapters.
+     */
+    abstract getType(): string;
+    /**
+     * Get adapter info including capabilities.
+     *
+     * Default implementation that auto-detects capabilities by checking
+     * if getSignedUrl and getPresignedUploadUrl methods are implemented.
+     * Override in subclasses for more accurate capability reporting.
+     *
+     * @returns Adapter info with type, name, and capability flags
+     */
+    getInfo(): StorageAdapterInfo;
+    /**
+     * Sanitize filename to prevent directory traversal and storage issues.
+     *
+     * Security measures:
+     * - Remove path separators (/, \)
+     * - Keep only basename (no directories)
+     * - Replace problematic characters with hyphens
+     * - Preserve alphanumeric, dots, underscores, hyphens
+     *
+     * @param filename - Original filename to sanitize
+     * @returns Sanitized filename safe for storage
+     *
+     * @example
+     * ```typescript
+     * this.sanitizeFilename('../../../etc/passwd')  // 'passwd'
+     * this.sanitizeFilename('my file (1).jpg')      // 'my-file--1-.jpg'
+     * this.sanitizeFilename('photo.jpg')            // 'photo.jpg'
+     * ```
+     */
+    protected sanitizeFilename(filename: string): string;
+    /**
+     * Generate a unique storage key with date-based prefix.
+     *
+     * Creates keys in format: {folder}/{year}/{month}/{uuid}-{sanitized-filename}
+     * This provides:
+     * - Unique keys via UUID to prevent collisions
+     * - Date-based organization for easier management
+     * - Readable filenames for debugging
+     *
+     * @param filename - Original filename (will be sanitized)
+     * @param folder - Optional folder/prefix for organizing uploads
+     * @returns Generated storage key
+     *
+     * @example
+     * ```typescript
+     * this.generateKey('photo.jpg')
+     * // 'uploads/2026/01/abc-123-...-photo.jpg'
+     *
+     * this.generateKey('doc.pdf', 'documents')
+     * // 'documents/2026/01/abc-123-...-doc.pdf'
+     * ```
+     */
+    protected generateKey(filename: string, folder?: string): string;
+}
+
+/**
+ * Uploadthing Storage Types
+ *
+ * Configuration for the @nextlyhq/storage-uploadthing package.
+ */
+
+/**
+ * Uploadthing storage adapter configuration.
+ *
+ * @example
+ * ```typescript
+ * uploadthingStorage({
+ *   token: process.env.UPLOADTHING_TOKEN,
+ *   collections: { media: true }
+ * })
+ * ```
+ */
+interface UploadthingStorageConfig extends StoragePluginConfig {
+    /** Enable/disable this storage plugin (default: true). */
+    enabled?: boolean;
+    /** Collections this plugin handles. */
+    collections: Record<string, boolean | CollectionStorageConfig>;
+    /**
+     * Uploadthing API token.
+     * If not provided, reads from UPLOADTHING_TOKEN env var.
+     */
+    token?: string;
+}
+
+/**
+ * Uploadthing Storage Plugin
+ *
+ * Factory function that creates a storage plugin for Uploadthing.
+ * Returns a StoragePlugin that can be registered with MediaStorage.
+ *
+ * @example
+ * ```typescript
+ * import { uploadthingStorage } from '@nextlyhq/storage-uploadthing'
+ * import { defineConfig } from 'nextly/config'
+ *
+ * export default defineConfig({
+ *   storage: [
+ *     uploadthingStorage({
+ *       token: process.env.UPLOADTHING_TOKEN,
+ *       collections: { media: true }
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+
+/**
+ * Create an Uploadthing storage plugin for Nextly.
+ *
+ * @param config - Uploadthing storage configuration
+ * @returns A StoragePlugin that MediaStorage can register
+ */
+declare function uploadthingStorage(config: UploadthingStorageConfig): StoragePlugin;
+
+/**
+ * Uploadthing Storage Adapter
+ *
+ * Implements the Nextly storage adapter interface using Uploadthing's UTApi
+ * for server-side file operations. Files are served via Uploadthing's CDN.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new UploadthingStorageAdapter({ token: process.env.UPLOADTHING_TOKEN });
+ * const result = await adapter.upload(buffer, {
+ *   filename: 'photo.jpg',
+ *   mimeType: 'image/jpeg',
+ * });
+ * // result.url = 'https://utfs.io/f/abc123-photo.jpg'
+ * ```
+ */
+
+declare class UploadthingStorageAdapter extends BaseStorageAdapter {
+    private readonly utapi;
+    constructor(config: {
+        token?: string;
+    });
+    /**
+     * Upload file to Uploadthing.
+     * Creates a File object from the buffer and uploads via UTApi.
+     */
+    upload(buffer: Buffer, options: UploadOptions): Promise<UploadResult>;
+    /**
+     * Delete file from Uploadthing by its file key.
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * Bulk delete files from Uploadthing.
+     * UTApi natively supports batch deletion.
+     */
+    bulkDelete(filePaths: string[]): Promise<BulkDeleteResult>;
+    /**
+     * Check if file exists on Uploadthing.
+     * Uses getFileUrls - if it returns data with URLs, the file exists.
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * Get public URL for a file.
+     * Uploadthing files are served from utfs.io CDN.
+     * The URL is stored at upload time, so this reconstructs it from the key.
+     */
+    getPublicUrl(filePath: string): string;
+    /**
+     * Get storage type identifier.
+     */
+    getType(): string;
+    /**
+     * Keep filename sanitization local so this adapter remains stable
+     * even if upstream base adapter type declarations drift.
+     */
+    protected sanitizeFilename(filename: string): string;
+}
+
+export { UploadthingStorageAdapter, type UploadthingStorageConfig, uploadthingStorage };

package/dist/index.mjs

@@ -0,0 +1,142 @@
+import { BaseStorageAdapter } from './chunk-CV4XIHXE.mjs';
+import './chunk-3GDQP6AS.mjs';
+import { UTApi } from 'uploadthing/server';
+
+var UploadthingStorageAdapter = class extends BaseStorageAdapter {
+  utapi;
+  constructor(config) {
+    super();
+    this.utapi = new UTApi({
+      ...config.token ? { token: config.token } : {}
+    });
+  }
+  /**
+   * Upload file to Uploadthing.
+   * Creates a File object from the buffer and uploads via UTApi.
+   */
+  async upload(buffer, options) {
+    const sanitized = this.sanitizeFilename(options.filename);
+    const file = new File([buffer], sanitized, {
+      type: options.mimeType
+    });
+    const results = await this.utapi.uploadFiles([file], {
+      contentDisposition: options.contentDisposition ?? "attachment"
+    });
+    const result = results[0];
+    if (!result?.data) {
+      const errorMsg = result?.error?.message ?? "Unknown error";
+      throw new Error(`Uploadthing upload failed: ${errorMsg}`);
+    }
+    return {
+      url: result.data.url,
+      // Use the file key as the storage path (needed for deletion)
+      path: result.data.key
+    };
+  }
+  /**
+   * Delete file from Uploadthing by its file key.
+   */
+  async delete(filePath) {
+    try {
+      await this.utapi.deleteFiles([filePath], { keyType: "fileKey" });
+    } catch {
+    }
+  }
+  /**
+   * Bulk delete files from Uploadthing.
+   * UTApi natively supports batch deletion.
+   */
+  async bulkDelete(filePaths) {
+    try {
+      await this.utapi.deleteFiles(filePaths, { keyType: "fileKey" });
+      return {
+        successful: filePaths,
+        failed: []
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Bulk delete failed";
+      return {
+        successful: [],
+        failed: filePaths.map((fp) => ({
+          filePath: fp,
+          error: message
+        }))
+      };
+    }
+  }
+  /**
+   * Check if file exists on Uploadthing.
+   * Uses getFileUrls - if it returns data with URLs, the file exists.
+   */
+  async exists(filePath) {
+    try {
+      const result = await this.utapi.getFileUrls([filePath], {
+        keyType: "fileKey"
+      });
+      const items = Array.from(result.data);
+      return items.length > 0 && !!items[0]?.url;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get public URL for a file.
+   * Uploadthing files are served from utfs.io CDN.
+   * The URL is stored at upload time, so this reconstructs it from the key.
+   */
+  getPublicUrl(filePath) {
+    return `https://utfs.io/f/${filePath}`;
+  }
+  /**
+   * Get storage type identifier.
+   */
+  getType() {
+    return "uploadthing";
+  }
+  /**
+   * Keep filename sanitization local so this adapter remains stable
+   * even if upstream base adapter type declarations drift.
+   */
+  sanitizeFilename(filename) {
+    const basename = filename.split(/[/\\]/).pop() || filename;
+    return basename.replace(/[^a-zA-Z0-9._-]/g, "-");
+  }
+};
+
+// src/plugin.ts
+function uploadthingStorage(config) {
+  if (config.enabled === false) {
+    return {
+      name: "uploadthing-storage",
+      type: "uploadthing",
+      collections: {},
+      adapter: null
+    };
+  }
+  const token = config.token ?? process.env.UPLOADTHING_TOKEN;
+  if (!token) {
+    console.warn(
+      "[Nextly] Uploadthing token not provided. Set UPLOADTHING_TOKEN env var or pass token in config."
+    );
+    return {
+      name: "uploadthing-storage",
+      type: "uploadthing",
+      collections: {},
+      adapter: null
+    };
+  }
+  const adapter = new UploadthingStorageAdapter({ token });
+  return {
+    name: "uploadthing-storage",
+    type: "uploadthing",
+    collections: config.collections,
+    adapter
+    // Uploadthing supports client-side uploads via its own pattern
+    // but we don't implement getClientUploadUrl here as it requires
+    // Uploadthing's specific route handler setup
+  };
+}
+
+export { UploadthingStorageAdapter, uploadthingStorage };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapter.ts","../src/plugin.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * Uploadthing Storage Adapter\n *\n * Implements the Nextly storage adapter interface using Uploadthing's UTApi\n * for server-side file operations. Files are served via Uploadthing's CDN.\n *\n * @example\n * ```typescript\n * const adapter = new UploadthingStorageAdapter({ token: process.env.UPLOADTHING_TOKEN });\n * const result = await adapter.upload(buffer, {\n *   filename: 'photo.jpg',\n *   mimeType: 'image/jpeg',\n * });\n * // result.url = 'https://utfs.io/f/abc123-photo.jpg'\n * ```\n */\n\nimport { BaseStorageAdapter } from \"nextly/storage\";\nimport type {\n  UploadOptions,\n  UploadResult,\n  BulkDeleteResult,\n} from \"nextly/storage\";\nimport { UTApi } from \"uploadthing/server\";\n\n// ============================================================\n// Adapter Implementation\n// ============================================================\n\nexport class UploadthingStorageAdapter extends BaseStorageAdapter {\n  private readonly utapi: UTApi;\n\n  constructor(config: { token?: string }) {\n    super();\n    // UTApi reads UPLOADTHING_TOKEN from env if not provided\n    this.utapi = new UTApi({\n      ...(config.token ? { token: config.token } : {}),\n    });\n  }\n\n  /**\n   * Upload file to Uploadthing.\n   * Creates a File object from the buffer and uploads via UTApi.\n   */\n  async upload(buffer: Buffer, options: UploadOptions): Promise<UploadResult> {\n    const sanitized = this.sanitizeFilename(options.filename);\n\n    // UTApi.uploadFiles expects File objects\n    // Cast buffer to BlobPart to satisfy TS 5.9 strict ArrayBuffer typing\n    const file = new File([buffer as unknown as BlobPart], sanitized, {\n      type: options.mimeType,\n    });\n\n    // uploadFiles returns UploadFileResult[] — one result per file.\n    // Default contentDisposition flipped from \"inline\" to \"attachment\".\n    // An \"inline\" disposition lets the browser render the file\n    // in-context (HTML, SVG, PDF with embedded JS) which can land as\n    // XSS or drive-by; \"attachment\" forces the download dialog so the\n    // user has to opt in to opening it. Adopters who genuinely want\n    // inline rendering can still pass `contentDisposition: \"inline\"`\n    // explicitly.\n    const results = await this.utapi.uploadFiles([file], {\n      contentDisposition: options.contentDisposition ?? \"attachment\",\n    });\n\n    // results is an array of { data: { key, url, ... } | null, error: ... | null }\n    const result = results[0] as {\n      data: { key: string; url: string } | null;\n      error: { message: string } | null;\n    };\n\n    if (!result?.data) {\n      const errorMsg = result?.error?.message ?? \"Unknown error\";\n      throw new Error(`Uploadthing upload failed: ${errorMsg}`);\n    }\n\n    return {\n      url: result.data.url,\n      // Use the file key as the storage path (needed for deletion)\n      path: result.data.key,\n    };\n  }\n\n  /**\n   * Delete file from Uploadthing by its file key.\n   */\n  async delete(filePath: string): Promise<void> {\n    try {\n      await this.utapi.deleteFiles([filePath], { keyType: \"fileKey\" });\n    } catch {\n      // Silently ignore deletion errors (file may already be gone)\n    }\n  }\n\n  /**\n   * Bulk delete files from Uploadthing.\n   * UTApi natively supports batch deletion.\n   */\n  async bulkDelete(filePaths: string[]): Promise<BulkDeleteResult> {\n    try {\n      await this.utapi.deleteFiles(filePaths, { keyType: \"fileKey\" });\n      return {\n        successful: filePaths,\n        failed: [],\n      };\n    } catch (error: unknown) {\n      // If bulk delete fails entirely, report all as failed\n      const message =\n        error instanceof Error ? error.message : \"Bulk delete failed\";\n      return {\n        successful: [],\n        failed: filePaths.map(fp => ({\n          filePath: fp,\n          error: message,\n        })),\n      };\n    }\n  }\n\n  /**\n   * Check if file exists on Uploadthing.\n   * Uses getFileUrls - if it returns data with URLs, the file exists.\n   */\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      const result = await this.utapi.getFileUrls([filePath], {\n        keyType: \"fileKey\",\n      });\n      // getFileUrls returns { data: readonly [{ url, key }] }\n      const items = Array.from(result.data);\n      return items.length > 0 && !!items[0]?.url;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Get public URL for a file.\n   * Uploadthing files are served from utfs.io CDN.\n   * The URL is stored at upload time, so this reconstructs it from the key.\n   */\n  getPublicUrl(filePath: string): string {\n    // Uploadthing URLs follow the pattern: https://utfs.io/f/{fileKey}\n    return `https://utfs.io/f/${filePath}`;\n  }\n\n  /**\n   * Get storage type identifier.\n   */\n  getType(): string {\n    return \"uploadthing\";\n  }\n\n  /**\n   * Keep filename sanitization local so this adapter remains stable\n   * even if upstream base adapter type declarations drift.\n   */\n  protected sanitizeFilename(filename: string): string {\n    const basename = filename.split(/[/\\\\]/).pop() || filename;\n    return basename.replace(/[^a-zA-Z0-9._-]/g, \"-\");\n  }\n}\n","/**\n * Uploadthing Storage Plugin\n *\n * Factory function that creates a storage plugin for Uploadthing.\n * Returns a StoragePlugin that can be registered with MediaStorage.\n *\n * @example\n * ```typescript\n * import { uploadthingStorage } from '@nextlyhq/storage-uploadthing'\n * import { defineConfig } from 'nextly/config'\n *\n * export default defineConfig({\n *   storage: [\n *     uploadthingStorage({\n *       token: process.env.UPLOADTHING_TOKEN,\n *       collections: { media: true }\n *     })\n *   ]\n * })\n * ```\n */\n\nimport type { StoragePlugin } from \"nextly/storage\";\n\nimport { UploadthingStorageAdapter } from \"./adapter\";\nimport type { UploadthingStorageConfig } from \"./types\";\n\n/**\n * Create an Uploadthing storage plugin for Nextly.\n *\n * @param config - Uploadthing storage configuration\n * @returns A StoragePlugin that MediaStorage can register\n */\nexport function uploadthingStorage(\n  config: UploadthingStorageConfig\n): StoragePlugin {\n  // Handle disabled plugin\n  if (config.enabled === false) {\n    return {\n      name: \"uploadthing-storage\",\n      type: \"uploadthing\",\n      collections: {},\n      adapter: null as unknown as StoragePlugin[\"adapter\"],\n    };\n  }\n\n  // Token from config or env\n  const token = config.token ?? process.env.UPLOADTHING_TOKEN;\n\n  if (!token) {\n    console.warn(\n      \"[Nextly] Uploadthing token not provided. Set UPLOADTHING_TOKEN env var or pass token in config.\"\n    );\n    return {\n      name: \"uploadthing-storage\",\n      type: \"uploadthing\",\n      collections: {},\n      adapter: null as unknown as StoragePlugin[\"adapter\"],\n    };\n  }\n\n  const adapter = new UploadthingStorageAdapter({ token });\n\n  return {\n    name: \"uploadthing-storage\",\n    type: \"uploadthing\",\n    collections: config.collections,\n    adapter,\n    // Uploadthing supports client-side uploads via its own pattern\n    // but we don't implement getClientUploadUrl here as it requires\n    // Uploadthing's specific route handler setup\n  };\n}\n"]}