@kyro-cms/admin 0.1.5 → 0.1.7

package/src/pages/api/media/folders.ts

@@ -0,0 +1,609 @@
+import type { APIRoute } from "astro";
+import fs from "fs/promises";
+import { getStorageConfig } from "@/lib/storage";
+import { S3Client, ListObjectsV2Command } from "@aws-sdk/client-s3";
+
+function isCloudProvider(provider: string): boolean {
+  return [
+    "aws",
+    "r2",
+    "gcs",
+    "digitalocean",
+    "backblaze",
+    "wasabi",
+    "cloudinary",
+  ].includes(provider);
+}
+
+function extractPublicDevUrlId(url?: string): string {
+  if (!url) return "";
+  if (url.startsWith("pub-")) return url;
+  const match = url.match(/pub-[a-zA-Z0-9]+/i);
+  return match ? match[0] : "";
+}
+
+async function getCloudFolders(
+  provider: string,
+  config: any,
+): Promise<string[]> {
+  const folders: string[] = [];
+
+  // Build S3-compatible client config
+  let s3Config: any = {
+    region: config.config.region || "auto",
+    credentials: {
+      accessKeyId: config.config.accessKeyId || "",
+      secretAccessKey: config.config.secretAccessKey || "",
+    },
+  };
+
+  // Set endpoint based on provider
+  if (provider === "r2") {
+    // Use R2 API endpoint, not public dev URL
+    s3Config.endpoint = `https://${config.config.accountId}.r2.cloudflarestorage.com`;
+    s3Config.region = "auto";
+    s3Config.forcePathStyle = true;
+  } else if (provider === "digitalocean") {
+    s3Config.endpoint = `https://${config.config.region || "nyc3"}.digitaloceanspaces.com`;
+  } else if (provider === "backblaze") {
+    s3Config.endpoint = "https://s3.backblazeb2.com";
+  } else if (provider === "wasabi") {
+    s3Config.endpoint = `https://s3.${config.config.region || "us-east-1"}.wasabisys.com`;
+  } else if (provider === "gcs") {
+    s3Config.endpoint = "https://storage.googleapis.com";
+  } else {
+    // AWS S3
+    s3Config.region = config.config.region || "us-east-1";
+    if (config.config.endpoint) {
+      s3Config.endpoint = config.config.endpoint;
+    }
+  }
+
+  const client = new S3Client(s3Config);
+
+  try {
+    const prefix = config.config.prefix || "";
+    const command = new ListObjectsV2Command({
+      Bucket: config.config.bucket,
+      Delimiter: "/",
+      Prefix: prefix ? `${prefix}/` : prefix,
+    });
+
+    const response = await client.send(command);
+
+    // Get common prefixes (folders)
+    if (response.CommonPrefixes) {
+      for (const cp of response.CommonPrefixes) {
+        if (cp.Prefix) {
+          // Remove the prefix from the path
+          let folderPath = cp.Prefix;
+          if (prefix && folderPath.startsWith(prefix + "/")) {
+            folderPath = folderPath.slice(prefix.length + 1);
+          }
+          // Remove trailing slash
+          folderPath = folderPath.replace(/\/$/, "");
+          if (folderPath) {
+            folders.push(folderPath);
+          }
+        }
+      }
+    }
+
+    // Also check for folders at root level (without prefix)
+    if (!prefix) {
+      const rootCommand = new ListObjectsV2Command({
+        Bucket: config.config.bucket,
+        Delimiter: "/",
+      });
+      const rootResponse = await client.send(rootCommand);
+
+      if (rootResponse.CommonPrefixes) {
+        for (const cp of rootResponse.CommonPrefixes) {
+          if (cp.Prefix && cp.Prefix !== prefix) {
+            const folderPath = cp.Prefix.replace(/\/$/, "");
+            if (folderPath && !folders.includes(folderPath)) {
+              folders.push(folderPath);
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[folders] Cloud API error:", error);
+    throw error;
+  }
+
+  return folders;
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const storageConfig = await getStorageConfig();
+    console.log(
+      "[createFolder] storageConfig:",
+      JSON.stringify({
+        provider: storageConfig.provider,
+        uploadDir: storageConfig.uploadDir,
+        baseUrl: storageConfig.baseUrl,
+        isCloud: isCloudProvider(storageConfig.provider),
+      }),
+    );
+    const { provider, config, uploadDir } = storageConfig;
+
+    const body = await request.json();
+    const { name, parentPath } = body;
+
+    if (!name) {
+      return new Response(JSON.stringify({ error: "Folder name required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const path = parentPath ? `${parentPath}/${name}` : name;
+
+    // For cloud storage, folders are based on object key prefixes
+    // We can "create" a folder by uploading an empty placeholder object
+    if (isCloudProvider(provider)) {
+      // Save folder to database
+      try {
+        const Database = (await import("better-sqlite3")).default;
+        const db = new Database("./data/content.db");
+
+        const folderParentPath = parentPath ? `/${parentPath}` : null;
+        const now = new Date().toISOString();
+
+        db.prepare(
+          `
+          INSERT OR IGNORE INTO media_folders (path, name, parent_path, created_at)
+          VALUES (?, ?, ?, ?)
+        `,
+        ).run(`/${path}`, name, folderParentPath, now);
+
+        console.log("[createFolder] Saved folder to DB:", path);
+        db.close();
+      } catch (e: any) {
+        console.warn(
+          "[createFolder] Could not save folder to database:",
+          e.message,
+        );
+      }
+
+      // Create folder in cloud storage
+      if (provider === "cloudinary") {
+        // Cloudinary folders are created automatically when uploading files
+        // The folder will exist once you upload your first file to it
+        console.log(
+          "[createFolder] Cloudinary: folder will be created on first upload",
+        );
+      } else {
+        // S3-compatible storage (R2, DO, etc.)
+        try {
+          const { S3Client, PutObjectCommand } =
+            await import("@aws-sdk/client-s3");
+
+          const s3Config: any = {
+            region: "auto",
+            credentials: {
+              accessKeyId: config.accessKeyId || "",
+              secretAccessKey: config.secretAccessKey || "",
+            },
+          };
+
+          // Set endpoint based on provider
+          if (provider === "r2") {
+            s3Config.endpoint = `https://${config.accountId}.r2.cloudflarestorage.com`;
+            s3Config.forcePathStyle = true;
+          } else if (provider === "digitalocean") {
+            s3Config.endpoint = `https://${config.region || "nyc3"}.digitaloceanspaces.com`;
+          } else if (provider === "backblaze") {
+            s3Config.endpoint = "https://s3.backblazeb2.com";
+          } else if (provider === "wasabi") {
+            s3Config.endpoint = `https://s3.${config.region || "us-east-1"}.wasabisys.com`;
+          }
+
+          const s3Client = new S3Client(s3Config);
+
+          const folderKey = config.prefix
+            ? `${config.prefix}/${path}/.folder`
+            : `${path}/.folder`;
+
+          await s3Client.send(
+            new PutObjectCommand({
+              Bucket: config.bucket,
+              Key: folderKey,
+              Body: Buffer.from(""),
+              ContentType: "application/x-directory",
+            }),
+          );
+
+          console.log("[createFolder] Created folder in cloud:", folderKey);
+        } catch (cloudError: any) {
+          console.warn(
+            "[createFolder] Could not create folder in cloud:",
+            cloudError.message,
+          );
+        }
+      }
+
+      return new Response(
+        JSON.stringify({
+          success: true,
+          folder: {
+            id: path,
+            name,
+            path: `/${path}`,
+            createdAt: new Date().toISOString(),
+          },
+          cloudStorage: true,
+        }),
+        {
+          status: 201,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+
+    // Local storage - create physical folder
+    const { join } = await import("path");
+    const folderPath = parentPath
+      ? join(uploadDir, parentPath, name)
+      : join(uploadDir, name);
+
+    await fs.mkdir(folderPath, { recursive: true });
+
+    const newFolder = {
+      id: name,
+      name,
+      path: parentPath ? `/${parentPath}/${name}` : `/${name}`,
+      createdAt: new Date().toISOString(),
+    };
+
+    return new Response(JSON.stringify({ success: true, folder: newFolder }), {
+      status: 201,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Create folder error:", error);
+    return new Response(JSON.stringify({ error: "Failed to create folder" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+};
+
+export const GET: APIRoute = async () => {
+  try {
+    const storageConfig = await getStorageConfig();
+    const { provider, config, uploadDir } = storageConfig;
+    const folders: string[] = [];
+
+    // Check if it's cloud storage
+    if (isCloudProvider(provider)) {
+      // First try to get folders from database
+      try {
+        const Database = (await import("better-sqlite3")).default;
+        const db = new Database("./data/content.db");
+        const dbFolders = db
+          .prepare("SELECT path FROM media_folders ORDER BY path")
+          .all() as { path: string }[];
+        db.close();
+
+        // For Cloudinary, folders are only tracked in DB (not real folders)
+        // For S3-compatible storage, try cloud API if DB is empty
+        if (provider === "cloudinary" || dbFolders.length > 0) {
+          return new Response(
+            JSON.stringify({
+              folders: dbFolders.map((f) => f.path.replace(/^\//, "")).sort(),
+              cloudStorage: true,
+              provider,
+            }),
+            {
+              status: 200,
+              headers: { "Content-Type": "application/json" },
+            },
+          );
+        }
+      } catch (e: any) {
+        console.warn("[getFolders] Could not read from DB:", e.message);
+      }
+
+      // For Cloudinary, no cloud API to call - just return empty
+      if (provider === "cloudinary") {
+        return new Response(
+          JSON.stringify({
+            folders: [],
+            cloudStorage: true,
+            provider,
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+      }
+
+      // For S3-compatible storage, try cloud API
+      try {
+        const cloudFolders = await getCloudFolders(provider, storageConfig);
+        return new Response(
+          JSON.stringify({
+            folders: cloudFolders.sort(),
+            cloudStorage: true,
+            provider,
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+      } catch (cloudError) {
+        console.error("Get cloud folders error:", cloudError);
+        return new Response(
+          JSON.stringify({
+            folders: [],
+            error: "Failed to fetch cloud storage folders",
+            cloudStorage: true,
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+      }
+    }
+
+    // Local storage - scan filesystem
+    const { join } = await import("path");
+
+    async function scanDir(dirPath: string, currentPrefix = "") {
+      try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".")) {
+            const folderPath = currentPrefix
+              ? `${currentPrefix}/${entry.name}`
+              : entry.name;
+            folders.push(folderPath);
+            await scanDir(join(dirPath, entry.name), folderPath);
+          }
+        }
+      } catch (err) {
+        // Directory doesn't exist or is empty
+      }
+    }
+
+    await fs.mkdir(uploadDir, { recursive: true });
+    await scanDir(uploadDir);
+
+    return new Response(JSON.stringify({ folders: folders.sort() }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Get folders error:", error);
+    return new Response(JSON.stringify({ folders: [] }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+};
+
+export const DELETE: APIRoute = async ({ request }) => {
+  try {
+    const storageConfig = await getStorageConfig();
+    const { provider, config, uploadDir } = storageConfig;
+    const url = new URL(request.url);
+    const folderPath = url.searchParams.get("path");
+
+    if (!folderPath) {
+      return new Response(JSON.stringify({ error: "Folder path required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // For cloud storage, we can't delete "folders" - they're just prefixes
+    // We need to delete all objects with that prefix
+    if (isCloudProvider(provider)) {
+      // Delete folder from database
+      try {
+        const Database = (await import("better-sqlite3")).default;
+        const db = new Database("./data/content.db");
+
+        // Delete from media_folders table
+        db.prepare(
+          "DELETE FROM media_folders WHERE path = ? OR path LIKE ?",
+        ).run(`/${folderPath}`, `/${folderPath}/%`);
+
+        // Delete from media table - this removes the database records so UI updates
+        db.prepare("DELETE FROM media WHERE folder = ? OR folder LIKE ?").run(
+          `/${folderPath}`,
+          `/${folderPath}/%`,
+        );
+
+        db.close();
+      } catch (e: any) {
+        console.warn("[deleteFolder] Could not delete from DB:", e.message);
+      }
+
+      // Delete folder from cloud storage
+      if (provider === "cloudinary") {
+        try {
+          const cloudName = config.cloudName;
+          const apiKey = config.apiKey;
+          const apiSecret = config.apiSecret;
+
+          console.log("[deleteFolder] Cloudinary config:", {
+            cloudName,
+            apiKey: !!apiKey,
+            apiSecret: !!apiSecret,
+          });
+
+          if (!cloudName || !apiKey || !apiSecret) {
+            console.warn("[deleteFolder] Missing Cloudinary config");
+          } else {
+            // Admin API uses Basic Authentication
+            const auth = Buffer.from(`${apiKey}:${apiSecret}`).toString(
+              "base64",
+            );
+
+            // First delete all resources in the folder (Cloudinary requires folder to be empty)
+            console.log(
+              "[deleteFolder] Deleting resources with prefix:",
+              folderPath,
+            );
+
+            const deleteResponse = await fetch(
+              `https://api.cloudinary.com/v1_1/${cloudName}/resources/image/upload?prefix=${encodeURIComponent(folderPath)}`,
+              {
+                method: "DELETE",
+                headers: {
+                  Authorization: `Basic ${auth}`,
+                },
+              },
+            );
+
+            const deleteResult = await deleteResponse.text();
+            console.log(
+              "[deleteFolder] Delete resources response:",
+              deleteResponse.status,
+              deleteResult,
+            );
+
+            // Now delete the empty folder
+            console.log("[deleteFolder] Deleting folder:", folderPath);
+
+            const folderResponse = await fetch(
+              `https://api.cloudinary.com/v1_1/${cloudName}/folders/${folderPath}`,
+              {
+                method: "DELETE",
+                headers: {
+                  Authorization: `Basic ${auth}`,
+                },
+              },
+            );
+
+            const folderResult = await folderResponse.text();
+            console.log(
+              "[deleteFolder] Delete folder response:",
+              folderResponse.status,
+              folderResult,
+            );
+
+            console.log(
+              "[deleteFolder] Deleted folder and contents from Cloudinary:",
+              folderPath,
+            );
+          }
+        } catch (cloudError: any) {
+          console.warn("[deleteFolder] Cloudinary error:", cloudError.message);
+        }
+      } else {
+        // S3-compatible storage (R2, DO, etc.)
+        try {
+          const { S3Client, ListObjectsV2Command, DeleteObjectCommand } =
+            await import("@aws-sdk/client-s3");
+
+          const s3Config: any = {
+            region: "auto",
+            credentials: {
+              accessKeyId: config.accessKeyId || "",
+              secretAccessKey: config.secretAccessKey || "",
+            },
+          };
+
+          if (provider === "r2") {
+            s3Config.endpoint = `https://${config.accountId}.r2.cloudflarestorage.com`;
+            s3Config.forcePathStyle = true;
+          } else if (provider === "digitalocean") {
+            s3Config.endpoint = `https://${config.region || "nyc3"}.digitaloceanspaces.com`;
+          }
+
+          const s3Client = new S3Client(s3Config);
+          const prefix = config.prefix ? `${config.prefix}/` : "";
+          const folderPrefix = `${prefix}${folderPath}/`;
+
+          // List and delete all objects with the prefix
+          let continuationToken: string | undefined;
+          do {
+            const listResponse = await s3Client.send(
+              new ListObjectsV2Command({
+                Bucket: config.bucket,
+                Prefix: folderPrefix,
+                ContinuationToken: continuationToken,
+              }),
+            );
+
+            if (listResponse.Contents) {
+              for (const obj of listResponse.Contents) {
+                if (obj.Key) {
+                  await s3Client.send(
+                    new DeleteObjectCommand({
+                      Bucket: config.bucket,
+                      Key: obj.Key,
+                    }),
+                  );
+                }
+              }
+            }
+            continuationToken = listResponse.NextContinuationToken;
+          } while (continuationToken);
+
+          console.log(
+            "[deleteFolder] Deleted folder from cloud:",
+            folderPrefix,
+          );
+        } catch (cloudError: any) {
+          console.warn(
+            "[deleteFolder] Could not delete from cloud:",
+            cloudError.message,
+          );
+        }
+      }
+
+      return new Response(JSON.stringify({ success: true }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Local storage - delete physical folder
+    const { join } = await import("path");
+    const fullPath = join(uploadDir, folderPath);
+    await fs.rm(fullPath, { recursive: true, force: true });
+
+    // Clean up database records
+    try {
+      const { getDatabaseConfig } = await import("@/lib/db");
+      const dbConfig = getDatabaseConfig();
+
+      if (dbConfig.type === "sqlite") {
+        const Database = (await import("better-sqlite3")).default;
+        const db = new Database(dbConfig.contentDbPath || "./data/content.db");
+        try {
+          db.prepare("DELETE FROM media WHERE folder = ? OR folder LIKE ?").run(
+            folderPath,
+            `${folderPath}/%`,
+          );
+        } finally {
+          db.close();
+        }
+      }
+    } catch (dbError) {
+      console.warn("[folders DELETE] Failed to clean DB records:", dbError);
+    }
+
+    return new Response(JSON.stringify({ success: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Delete folder error:", error);
+    return new Response(JSON.stringify({ error: "Failed to delete folder" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+};