@kyro-cms/admin 0.1.5 → 0.1.7

package/src/pages/api/media/[id].ts

@@ -0,0 +1,309 @@
+import type { APIRoute } from "astro";
+import { getMediaService } from "../../../lib/MediaService";
+import { MediaService } from "@kyro-cms/core";
+import { getStorageConfig, constructMediaUrl } from "../../../lib/storage";
+import { getDatabaseConfig } from "../../../lib/db";
+import path from "path";
+
+export const GET: APIRoute = async ({ params }) => {
+  try {
+    const mediaService = await getMediaService();
+    const { id } = params;
+
+    if (!id) {
+      return new Response(JSON.stringify({ error: "No file ID provided" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const doc = await mediaService.findById(id);
+    if (!doc) {
+      return new Response(JSON.stringify({ error: "Media not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Compute URLs dynamically from current storage settings
+    const storageConfig = await getStorageConfig();
+    const isLocalStorage = storageConfig.provider === "local";
+    const isCloudStorage = !isLocalStorage;
+
+    // For cloud storage, use stored URL from DB; for local, construct from config
+    const mediaUrl = isCloudStorage
+      ? doc.url || (await constructMediaUrl(doc.filename, null))
+      : await constructMediaUrl(doc.filename, doc.folder);
+
+    // For local storage use resize API, for cloud use direct URL
+    let thumbnailUrl: string | undefined;
+    if (doc.mimeType?.startsWith("image/")) {
+      if (isLocalStorage) {
+        thumbnailUrl = `/api/media/resize?url=${encodeURIComponent(mediaUrl)}&w=400&h=400`;
+      } else {
+        thumbnailUrl = mediaUrl;
+      }
+    }
+
+    return new Response(
+      JSON.stringify({
+        id: doc.id,
+        title: doc.title || doc.filename,
+        filename: doc.filename,
+        originalName: doc.originalName,
+        url: mediaUrl,
+        thumbnailUrl,
+        type: doc.mimeType?.split("/")[0] || "other",
+        mimeType: doc.mimeType,
+        fileSize: doc.fileSize,
+        width: doc.width,
+        height: doc.height,
+        folder: doc.folder,
+        alt: doc.alt,
+        caption: doc.caption,
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  } catch (error) {
+    console.error("Get media error:", error);
+    return new Response(JSON.stringify({ error: "Failed to fetch media" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+};
+
+export const PATCH: APIRoute = async ({ params, request }) => {
+  try {
+    const mediaService = await getMediaService();
+    const { id } = params;
+
+    if (!id) {
+      return new Response(JSON.stringify({ error: "No file ID provided" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const body = await request.json();
+
+    // Fetch current record to compare
+    const current = await mediaService.findById(id);
+    if (!current) {
+      return new Response(JSON.stringify({ error: "Media not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    const updateData: any = {
+      alt: body.alt,
+      caption: body.caption,
+      title: body.title,
+    };
+
+    // If the title changed, rename the physical file and update url/filename
+    const newTitle: string | undefined = body.title;
+    if (
+      newTitle &&
+      newTitle !== current.title &&
+      newTitle !== current.filename
+    ) {
+      const storageConfig = await getStorageConfig();
+      const isLocalStorage = storageConfig.provider === "local";
+
+      // Preserve original extension, apply new name
+      const ext = path.extname(current.filename);
+      const sanitized = newTitle
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]/g, "_")
+        .replace(/_+/g, "_");
+      const newFilename = sanitized.endsWith(ext)
+        ? sanitized
+        : `${sanitized}${ext}`;
+
+      const folder = current.folder ? `${current.folder}/` : "";
+      const newKey = `${folder}${newFilename}`;
+
+      if (isLocalStorage) {
+        const uploadDir = storageConfig.uploadDir || "./public/uploads";
+        const baseUrl = storageConfig.baseUrl || "/uploads";
+        const folderPath = folder.replace("/", "");
+
+        const oldPhysical = path.join(uploadDir, folderPath, current.filename);
+        const newPhysical = path.join(uploadDir, folderPath, newFilename);
+
+        const fs = await import("fs/promises");
+        try {
+          await fs.rename(oldPhysical, newPhysical);
+        } catch (e: any) {
+          console.warn("[rename] Could not rename physical file:", e.message);
+        }
+
+        const normalizedBase = baseUrl.endsWith("/")
+          ? baseUrl.slice(0, -1)
+          : baseUrl;
+        updateData.url = `${normalizedBase}/${folder}${newFilename}`;
+      } else {
+        // Cloud storage - use MediaService rename
+        try {
+          const dbConfig = getDatabaseConfig();
+          let db: any = null;
+
+          if (dbConfig.type === "sqlite") {
+            const Database = (await import("better-sqlite3")).default;
+            db = new Database(dbConfig.contentDbPath || "./data/content.db");
+          } else if (dbConfig.type === "postgres") {
+            const { Pool } = await import("pg");
+            db = new Pool({ connectionString: dbConfig.connectionString });
+          } else if (dbConfig.type === "mysql") {
+            const mysql = await import("mysql2/promise");
+            db = await mysql.createPool({ uri: dbConfig.connectionString });
+          }
+
+          // Transform storageConfig to have 'type' field (for resolveProviderWithConfig)
+          const cloudStorageConfig = {
+            type: storageConfig.provider,
+            [storageConfig.provider]: storageConfig.config,
+          };
+
+          const coreMediaService = await MediaService.init(db, {
+            dialect: dbConfig.type as any,
+            storageConfig: cloudStorageConfig,
+          });
+
+          const renamed = await coreMediaService.rename(id, newKey);
+          if (renamed) {
+            updateData.url = renamed.url;
+            updateData.filename = renamed.filename;
+            if (renamed.thumbnailUrl) {
+              updateData.thumbnailUrl = renamed.thumbnailUrl;
+            }
+          }
+
+          if (db && dbConfig.type === "sqlite") db.close();
+        } catch (e: any) {
+          console.error(
+            "[rename] Cloud storage rename error:",
+            e.message,
+            e.stack,
+          );
+          // Continue anyway - still update DB metadata
+        }
+      }
+
+      if (!updateData.filename) {
+        updateData.filename = newFilename;
+      }
+      if (!updateData.url) {
+        const { baseUrl } = await getStorageConfig();
+        const normalizedBase = baseUrl.endsWith("/")
+          ? baseUrl.slice(0, -1)
+          : baseUrl;
+        updateData.url = `${normalizedBase}/${folder}${newFilename}`;
+      }
+    }
+
+    const updated = await mediaService.update(id, updateData);
+
+    return new Response(JSON.stringify({ success: true, media: updated }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Patch media error:", error);
+    return new Response(
+      JSON.stringify({ error: "Failed to update metadata" }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+};
+
+export const DELETE: APIRoute = async ({ params }) => {
+  try {
+    const mediaService = await getMediaService();
+    const { id } = params;
+
+    if (!id) {
+      return new Response(JSON.stringify({ error: "No file ID provided" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Get the media item first to delete from storage
+    const item = await mediaService.findById(id);
+    if (!item) {
+      return new Response(JSON.stringify({ error: "Media not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Delete from cloud storage if not local
+    const storageConfig = await getStorageConfig();
+    if (storageConfig.provider !== "local") {
+      try {
+        const dbConfig = getDatabaseConfig();
+        let db: any = null;
+
+        if (dbConfig.type === "sqlite") {
+          const Database = (await import("better-sqlite3")).default;
+          db = new Database(dbConfig.contentDbPath || "./data/content.db");
+        } else if (dbConfig.type === "postgres") {
+          const { Pool } = await import("pg");
+          db = new Pool({ connectionString: dbConfig.connectionString });
+        } else if (dbConfig.type === "mysql") {
+          const mysql = await import("mysql2/promise");
+          db = await mysql.createPool({ uri: dbConfig.connectionString });
+        }
+
+        // Transform storageConfig to have 'type' field
+        const cloudStorageConfig = {
+          type: storageConfig.provider,
+          [storageConfig.provider]: storageConfig.config,
+        };
+
+        const coreMediaService = await MediaService.init(db, {
+          dialect: dbConfig.type as any,
+          storageConfig: cloudStorageConfig,
+        });
+
+        // Delete the file from storage
+        await coreMediaService.deleteFile(item.url);
+        if (item.thumbnailUrl) {
+          try {
+            await coreMediaService.deleteFile(item.thumbnailUrl);
+          } catch {}
+        }
+
+        if (db && dbConfig.type === "sqlite") db.close();
+      } catch (e: any) {
+        console.error("[delete] Cloud storage delete error:", e.message);
+      }
+    }
+
+    // Delete from database
+    await mediaService.delete(id);
+
+    return new Response(JSON.stringify({ success: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    console.error("Delete media error:", error);
+    return new Response(JSON.stringify({ error: "Failed to delete file" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+};