nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-G2AA4QLC.mjs

@@ -0,0 +1,262 @@
+// src/storage/adapters/local-adapter.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/storage/adapters/base-adapter.ts
+var BaseStorageAdapter = class {
+  /**
+   * 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() {
+    const hasSignedUrls = "getSignedUrl" in this && typeof this.getSignedUrl === "function";
+    const hasClientUploads = "getPresignedUploadUrl" in this && typeof this.getPresignedUploadUrl === "function";
+    return {
+      type: this.getType(),
+      name: this.constructor.name,
+      supportsSignedUrls: hasSignedUrls,
+      supportsClientUploads: hasClientUploads
+    };
+  }
+  /**
+   * 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'
+   * ```
+   */
+  sanitizeFilename(filename) {
+    const basename = filename.split(/[/\\]/).pop() || filename;
+    return basename.replace(/[^a-zA-Z0-9._-]/g, "-");
+  }
+  /**
+   * 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'
+   * ```
+   */
+  generateKey(filename, folder) {
+    const sanitized = this.sanitizeFilename(filename);
+    const uuid = crypto.randomUUID();
+    const date = /* @__PURE__ */ new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const prefix = folder ? `${folder}/${year}/${month}` : `uploads/${year}/${month}`;
+    return `${prefix}/${uuid}-${sanitized}`;
+  }
+};
+
+// src/storage/adapters/local-adapter.ts
+var gitignoreUpdated = false;
+var LocalStorageAdapter = class extends BaseStorageAdapter {
+  basePath;
+  baseUrl;
+  constructor(config) {
+    super();
+    this.basePath = path.resolve(config.basePath);
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+  }
+  /**
+   * Upload file to local disk.
+   * Creates directories as needed and writes the file buffer.
+   */
+  async upload(buffer, options) {
+    const key = this.generateKey(options.filename, options.folder);
+    const fullPath = this.resolveAndValidate(key);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, buffer);
+    await this.ensureGitignore();
+    return {
+      url: this.getPublicUrl(key),
+      path: key
+    };
+  }
+  /**
+   * Delete file from local disk.
+   * Silently succeeds if the file doesn't exist.
+   */
+  async delete(filePath) {
+    let fullPath;
+    try {
+      fullPath = this.resolveAndValidate(filePath);
+    } catch {
+      return;
+    }
+    try {
+      await fs.unlink(fullPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Bulk delete files from local disk.
+   * Uses parallel unlinks with Promise.allSettled for best performance.
+   */
+  async bulkDelete(filePaths) {
+    const results = await Promise.allSettled(
+      filePaths.map(async (filePath) => {
+        await this.delete(filePath);
+        return filePath;
+      })
+    );
+    const successful = [];
+    const failed = [];
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled") {
+        successful.push(filePaths[index]);
+      } else {
+        failed.push({
+          filePath: filePaths[index],
+          error: result.reason?.message || "Unknown error"
+        });
+      }
+    });
+    return { successful, failed };
+  }
+  /**
+   * Check if file exists on local disk.
+   */
+  async exists(filePath) {
+    try {
+      const fullPath = this.resolveAndValidate(filePath);
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get public URL for a file.
+   * Returns baseUrl + relative path for Next.js static file serving.
+   */
+  getPublicUrl(filePath) {
+    const cleanPath = filePath.replace(/^\/+/, "");
+    return `${this.baseUrl}/${cleanPath}`;
+  }
+  /**
+   * Get storage type identifier.
+   */
+  getType() {
+    return "local";
+  }
+  /**
+   * Read file contents from local disk.
+   * Returns the file buffer, or null if file not found.
+   */
+  async read(filePath) {
+    try {
+      const fullPath = this.resolveAndValidate(filePath);
+      return await fs.readFile(fullPath);
+    } catch {
+      return null;
+    }
+  }
+  // ============================================================
+  // Private Helpers
+  // ============================================================
+  /**
+   * Resolve a relative file path to an absolute path within basePath.
+   * Throws if the resolved path would escape basePath (path traversal attack).
+   */
+  resolveAndValidate(filePath) {
+    const sanitized = filePath.replace(/^[/\\]+/, "").replace(/\.\.[/\\]/g, "");
+    const fullPath = path.resolve(this.basePath, sanitized);
+    if (!fullPath.startsWith(this.basePath)) {
+      throw new Error(
+        `Path traversal detected: ${filePath} resolves outside of storage directory`
+      );
+    }
+    return fullPath;
+  }
+  /**
+   * Auto-add the uploads directory to .gitignore on first upload.
+   * Prevents accidentally committing uploaded files to git.
+   */
+  async ensureGitignore() {
+    if (gitignoreUpdated) return;
+    gitignoreUpdated = true;
+    try {
+      const projectRoot = path.resolve(this.basePath, "..", "..");
+      const gitignorePath = path.join(projectRoot, ".gitignore");
+      let content = "";
+      try {
+        content = await fs.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      const uploadsDirRelative = path.relative(projectRoot, this.basePath);
+      const ignorePattern = uploadsDirRelative + "/";
+      if (!content.includes(ignorePattern)) {
+        const newEntry = `
+# Nextly local uploads (auto-added)
+${ignorePattern}
+`;
+        await fs.writeFile(gitignorePath, content + newEntry, "utf-8");
+      }
+    } catch {
+    }
+  }
+};
+
+// src/storage/adapters/local-plugin.ts
+function localStorage(config) {
+  if (config.enabled === false) {
+    return {
+      name: "local-storage",
+      type: "local",
+      collections: {},
+      adapter: null
+    };
+  }
+  const adapter = new LocalStorageAdapter({
+    basePath: config.basePath ?? "./public/uploads",
+    baseUrl: config.baseUrl ?? "/uploads"
+  });
+  return {
+    name: "local-storage",
+    type: "local",
+    collections: config.collections,
+    adapter
+    // Local storage doesn't support presigned URLs or signed downloads
+  };
+}
+
+export {
+  BaseStorageAdapter,
+  LocalStorageAdapter,
+  localStorage
+};