@kyro-cms/admin 0.3.1 → 0.3.4

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

@@ -1,26 +0,0 @@
-import type { APIRoute } from "astro";
-import { dataStore } from "../../../lib/dataStore";
-
-export const DELETE: APIRoute = async ({ params }) => {
-  try {
-    const { id } = params;
-    if (!id) {
-      return new Response(JSON.stringify({ error: "ID is required" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-
-    await dataStore.delete("_api_keys", id);
-
-    return new Response(JSON.stringify({ success: true }), {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    });
-  } catch (error: any) {
-    return new Response(JSON.stringify({ error: error.message }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-};

package/src/pages/api/keys/index.ts

@@ -1,75 +0,0 @@
-import type { APIRoute } from "astro";
-import { dataStore } from "../../../lib/dataStore";
-
-export const GET: APIRoute = async () => {
-  try {
-    const keys = await dataStore.find("_api_keys", { limit: 100, page: 1 });
-
-    const docs = keys.docs.map((k: any) => ({
-      id: k.id,
-      name: k.name,
-      key: k.key,
-      keyPrefix: k.key?.substring(0, 8) || "",
-      createdAt: k.createdAt,
-      lastUsedAt: k.lastUsedAt,
-    }));
-
-    return new Response(JSON.stringify(docs), {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    });
-  } catch (error: any) {
-    return new Response(JSON.stringify({ error: error.message }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-};
-
-export const POST: APIRoute = async ({ request }) => {
-  try {
-    const body = await request.json();
-    const { name } = body;
-
-    if (!name) {
-      return new Response(JSON.stringify({ error: "Name is required" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-
-    // Generate API key
-    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-    let suffix = "";
-    for (let i = 0; i < 28; i++) {
-      suffix += chars[Math.floor(Math.random() * chars.length)];
-    }
-    const key = `kyro_${suffix}`;
-
-    const now = new Date().toISOString();
-    const doc = await dataStore.create("_api_keys", {
-      name,
-      key,
-      keyPrefix: key.substring(0, 8),
-      createdAt: now,
-    });
-
-    return new Response(
-      JSON.stringify({
-        id: doc.id,
-        name: doc.name,
-        key: doc.key,
-        createdAt: doc.createdAt,
-      }),
-      {
-        status: 201,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  } catch (error: any) {
-    return new Response(JSON.stringify({ error: error.message }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-};

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

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