@kyro-cms/admin 0.3.2 → 0.3.4

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

@@ -1,609 +0,0 @@
-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" },
-    });
-  }
-};