@kyro-cms/admin 0.1.6 → 0.1.8

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

@@ -0,0 +1,146 @@
+import type { APIRoute } from "astro";
+import { getMediaService, type MediaItem } from "../../../lib/MediaService";
+import { constructMediaUrl, getStorageConfig } from "@/lib/storage";
+
+export const GET: APIRoute = async ({ url }) => {
+  let mediaService: any = null;
+  try {
+    mediaService = await getMediaService();
+
+    const page = parseInt(url.searchParams.get("page") || "1");
+    const limit = parseInt(url.searchParams.get("limit") || "30");
+    const search = url.searchParams.get("search") || "";
+    const type = url.searchParams.get("type") || "";
+    const folder = url.searchParams.get("folder") || "";
+    const sortBy = url.searchParams.get("sortBy") || "createdAt";
+    const sortDir = (url.searchParams.get("sortDir") || "desc") as
+      | "asc"
+      | "desc";
+
+    const result = await mediaService.find({
+      page,
+      limit,
+      search: search || undefined,
+      type: type || undefined,
+      folder: folder || undefined,
+      sortBy,
+      sortDir,
+    });
+
+    // Get storage config to determine provider type
+    const storageConfig = await getStorageConfig();
+    const isLocalStorage = storageConfig.provider === "local";
+
+    // Compute URLs dynamically from storage settings
+    const isCloudStorage = !isLocalStorage;
+    const docs = await Promise.all(
+      result.docs.map(async (doc: MediaItem) => {
+        // For cloud storage, use the stored URL from DB directly
+        // For local storage, construct URL from baseUrl + filename
+        let mediaUrl: string;
+        if (isCloudStorage) {
+          // Cloudinary already stores full URL, use it directly from DB
+          mediaUrl = doc.url || (await constructMediaUrl(doc.filename, null));
+        } else {
+          mediaUrl = await constructMediaUrl(doc.filename, doc.folder);
+        }
+
+        // For local storage, use resize API. For cloud storage, use direct URL
+        let thumbnailUrl: string | undefined;
+        if (doc.mimeType?.startsWith("image/")) {
+          if (isLocalStorage) {
+            // Local storage: use resize API
+            thumbnailUrl = `/api/media/resize?url=${encodeURIComponent(mediaUrl)}&w=400&h=400`;
+          } else {
+            // Cloud storage: use the same URL
+            thumbnailUrl = mediaUrl;
+          }
+        }
+
+        return {
+          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,
+          folder: doc.folder,
+          alt: doc.alt,
+          caption: doc.caption,
+          createdAt: doc.createdAt,
+          updatedAt: doc.updatedAt,
+        };
+      }),
+    );
+
+    return new Response(
+      JSON.stringify({
+        docs,
+        totalDocs: result.totalDocs,
+        page: result.page,
+        limit: result.limit,
+        totalPages: result.totalPages,
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  } catch (error: any) {
+    console.error("[media API] Error:", error?.message || error);
+    return new Response(
+      JSON.stringify({
+        error: error?.message || "Failed to fetch media",
+        docs: [],
+        totalDocs: 0,
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+};
+
+export const PATCH: APIRoute = async ({ request }) => {
+  try {
+    const mediaService = await getMediaService();
+    const body = await request.json();
+    const { id, ...data } = body;
+
+    const updated = await mediaService.update(id, data);
+
+    return new Response(JSON.stringify(updated), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error: any) {
+    return new Response(
+      JSON.stringify({ error: error.message || "Failed to update media" }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+};
+
+export const DELETE: APIRoute = async ({ request }) => {
+  try {
+    const mediaService = await getMediaService();
+    const body = await request.json();
+    const { id } = body;
+
+    await mediaService.delete(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 || "Failed to delete media" }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+};

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

@@ -0,0 +1,267 @@
+import type { APIRoute } from "astro";
+import sharp from "sharp";
+import path from "path";
+import fs from "fs/promises";
+import fsSync from "fs";
+import https from "https";
+import { createHash } from "crypto";
+import { getStorageConfig } from "@/lib/storage";
+
+// Cache configuration
+const CACHE_BASE = path.join(process.cwd(), ".cache", "kyro-media", "resize");
+const MAX_CACHE_SIZE = 100 * 1024 * 1024; // 100MB
+const MAX_CACHE_AGE_HOURS = 24 * 7; // 7 days
+
+// Ensure cache directory exists
+async function ensureCacheDir() {
+  try {
+    await fs.mkdir(CACHE_BASE, { recursive: true });
+  } catch {}
+}
+
+// Generate cache key from URL and parameters
+function getCacheKey(
+  imageUrl: string,
+  width: number,
+  height: number,
+  quality: number,
+  format: string,
+): string {
+  const input = `${imageUrl}-${width}-${height}-${quality}-${format}`;
+  return createHash("md5").update(input).digest("hex") + `.${format}`;
+}
+
+// Get cache file path
+function getCachePath(key: string): string {
+  return path.join(CACHE_BASE, key);
+}
+
+// Clean up old cache files when exceeding max size
+async function cleanCache(): Promise<void> {
+  try {
+    const entries = await fs.readdir(CACHE_BASE, { withFileTypes: true });
+    const files = entries
+      .filter((e) => e.isFile())
+      .map((e) => ({
+        name: e.name,
+        path: path.join(CACHE_BASE, e.name),
+        mtime: fsSync.statSync(path.join(CACHE_BASE, e.name)).mtime,
+        size: fsSync.statSync(path.join(CACHE_BASE, e.name)).size,
+      }))
+      .sort((a, b) => a.mtime.getTime() - b.mtime.getTime()); // oldest first
+
+    let totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    const maxSize = MAX_CACHE_SIZE;
+
+    // Delete oldest files until under limit
+    for (const file of files) {
+      if (totalSize < maxSize) break;
+      await fs.unlink(file.path);
+      totalSize -= file.size;
+    }
+  } catch {}
+}
+
+// Check if cache is valid (auto-invalidation on source modification)
+async function isCacheValid(
+  cachePath: string,
+  sourcePath: string,
+): Promise<boolean> {
+  try {
+    const cacheStat = await fs.stat(cachePath);
+    const sourceStat = await fs.stat(sourcePath);
+
+    // Cache invalid if source is newer than cache
+    if (sourceStat.mtimeMs > cacheStat.mtimeMs) {
+      return false;
+    }
+
+    // Also check cache age
+    const cacheAgeHours = (Date.now() - cacheStat.mtimeMs) / (1000 * 60 * 60);
+    if (cacheAgeHours > MAX_CACHE_AGE_HOURS) {
+      return false;
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Get source file path for local files
+async function getSourcePath(
+  imageUrl: string,
+  uploadDir: string,
+  baseUrl: string,
+): Promise<string | null> {
+  try {
+    let relativePath = imageUrl;
+    if (baseUrl !== "/" && imageUrl.startsWith(baseUrl)) {
+      relativePath = imageUrl.slice(baseUrl.length);
+    } else if (baseUrl === "/") {
+      relativePath = imageUrl.slice(1);
+    }
+    return path.join(uploadDir, relativePath);
+  } catch {
+    return null;
+  }
+}
+
+// HTTP agent for remote files
+const httpsAgent = new https.Agent({
+  keepAlive: true,
+  timeout: 30000,
+});
+
+// Fetch with custom agent
+async function fetchWithAgent(url: string): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const options = {
+      hostname: parsed.hostname,
+      port: 443,
+      path: parsed.pathname + parsed.search,
+      method: "GET",
+      agent: httpsAgent,
+    };
+
+    const req = https.request(options, (res) => {
+      if (
+        res.statusCode &&
+        res.statusCode >= 300 &&
+        res.statusCode < 400 &&
+        res.headers.location
+      ) {
+        fetchWithAgent(res.headers.location).then(resolve).catch(reject);
+        return;
+      }
+      if (!res.statusCode || res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+      res.on("error", reject);
+    });
+
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+export const GET: APIRoute = async ({ url }) => {
+  const refresh = url.searchParams.get("refresh") === "true";
+  let imageUrl = url.searchParams.get("url");
+  const width = parseInt(url.searchParams.get("w") || "0");
+  const height = parseInt(url.searchParams.get("h") || "0");
+  const quality = parseInt(url.searchParams.get("q") || "80");
+  const format = url.searchParams.get("f") || "webp";
+
+  if (!imageUrl) return new Response("Missing URL", { status: 400 });
+
+  // Prevent double-slash URLs
+  if (!imageUrl.startsWith("http")) {
+    imageUrl = imageUrl.replace(/^\/+/, "/");
+  }
+
+  const { uploadDir, baseUrl } = await getStorageConfig();
+  const cacheKey = getCacheKey(imageUrl, width, height, quality, format);
+  const cachePath = getCachePath(cacheKey);
+
+  // Ensure cache directory exists
+  await ensureCacheDir();
+
+  try {
+    let input: Buffer | null = null;
+    let useCache = false;
+
+    // Check cache first (if not refreshing)
+    if (!refresh) {
+      try {
+        const sourcePath = await getSourcePath(imageUrl, uploadDir, baseUrl);
+
+        if (sourcePath && (await isCacheValid(cachePath, sourcePath))) {
+          // Use cache
+          input = await fs.readFile(cachePath);
+          useCache = true;
+          console.log("[resize] Cache hit:", cacheKey);
+        }
+      } catch {}
+    }
+
+    // If not using cache, fetch and process
+    if (input === null) {
+      // Fetch original
+      if (imageUrl.startsWith("/")) {
+        // Local file
+        let relativePath = imageUrl;
+        if (baseUrl !== "/" && imageUrl.startsWith(baseUrl)) {
+          relativePath = imageUrl.slice(baseUrl.length);
+        } else if (baseUrl === "/") {
+          relativePath = imageUrl.slice(1);
+        }
+
+        const localPath = path.join(uploadDir, relativePath);
+        input = await fs.readFile(localPath);
+      } else {
+        // Remote file (S3/R2)
+        input = await fetchWithAgent(imageUrl);
+      }
+
+      // Process
+      let pipeline = sharp(input);
+      if (width > 0 || height > 0) {
+        pipeline = pipeline.resize(width || undefined, height || undefined, {
+          fit: "cover",
+          withoutEnlargement: true,
+        });
+      }
+
+      if (format === "webp") pipeline = pipeline.webp({ quality });
+      else if (format === "avif") pipeline = pipeline.avif({ quality });
+      else if (format === "jpg" || format === "jpeg")
+        pipeline = pipeline.jpeg({ quality });
+
+      const output = await pipeline.toBuffer();
+
+      // Write to cache
+      await fs.writeFile(cachePath, output);
+      console.log("[resize] Cached:", cacheKey);
+
+      // Clean cache if needed
+      await cleanCache();
+
+      input = output;
+    }
+
+    if (!input) {
+      throw new Error("Failed to process image");
+    }
+
+    return new Response(input as any, {
+      headers: {
+        "Content-Type": `image/${format}`,
+        "Cache-Control": "public, max-age=86400", // 1 day browser cache
+      },
+    });
+  } catch (error) {
+    console.error("Resize error:", error);
+
+    // Redirect to original on error
+    if (imageUrl) {
+      if (imageUrl.startsWith("http")) return Response.redirect(imageUrl, 302);
+      try {
+        const origin = url.origin;
+        return Response.redirect(
+          `${origin}${imageUrl.startsWith("/") ? "" : "/"}${imageUrl}`,
+          302,
+        );
+      } catch {
+        return new Response("Error processing image", { status: 500 });
+      }
+    }
+    return new Response("Error processing image", { status: 500 });
+  }
+};

package/src/pages/api/search.ts

@@ -0,0 +1,82 @@
+import type { APIRoute } from "astro";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url }) => {
+  const query = url.searchParams.get("q") || "";
+  const limit = Math.min(parseInt(url.searchParams.get("limit") || "10"), 50);
+
+  if (!query || query.length < 2) {
+    return new Response(JSON.stringify({ results: [] }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  const regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  const results: Array<{
+    collection: string;
+    label: string;
+    id: string;
+    title: string;
+  }> = [];
+
+  const demoResults = [
+    {
+      collection: "posts",
+      label: "Posts",
+      id: "1",
+      title: "Welcome to Kyro CMS",
+    },
+    {
+      collection: "posts",
+      label: "Posts",
+      id: "2",
+      title: "Getting Started Guide",
+    },
+    {
+      collection: "posts",
+      label: "Posts",
+      id: "3",
+      title: "Advanced Features",
+    },
+    { collection: "pages", label: "Pages", id: "about", title: "About Us" },
+    { collection: "pages", label: "Pages", id: "contact", title: "Contact" },
+    {
+      collection: "products",
+      label: "Products",
+      id: "prod-1",
+      title: "Sample Product",
+    },
+    {
+      collection: "products",
+      label: "Products",
+      id: "prod-2",
+      title: "Premium Plan",
+    },
+    {
+      collection: "categories",
+      label: "Categories",
+      id: "cat-1",
+      title: "Technology",
+    },
+    {
+      collection: "categories",
+      label: "Categories",
+      id: "cat-2",
+      title: "Business",
+    },
+  ];
+
+  for (const doc of demoResults) {
+    if (regex.test(doc.title)) {
+      results.push(doc);
+      if (results.length >= limit) break;
+    }
+  }
+
+  return new Response(JSON.stringify({ results: results.slice(0, limit) }), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};

package/src/pages/api/slug-availability.ts

@@ -0,0 +1,70 @@
+import type { APIRoute } from "astro";
+import { dataStore } from "@/lib/dataStore";
+import { collections } from "@/lib/config";
+
+dataStore.initialize(collections);
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const body = await request.json();
+    const { collection, slug } = body;
+
+    if (!collection || !slug) {
+      return new Response(
+        JSON.stringify({ error: "Collection and slug are required" }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+
+    if (!collections[collection]) {
+      return new Response(JSON.stringify({ error: "Invalid collection" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Check if slug exists in collection
+    const existing = await dataStore.findOne(collection, { slug });
+
+    if (existing) {
+      // Generate a unique suggestion
+      const baseSlug = slug.replace(/-[a-z0-9]+$/i, "");
+      const suggested = `${baseSlug}-${Math.random().toString(36).slice(2, 6)}`;
+
+      return new Response(
+        JSON.stringify({
+          available: false,
+          slug,
+          suggested,
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+
+    return new Response(
+      JSON.stringify({
+        available: true,
+        slug,
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  } catch (error) {
+    console.error("Slug availability check error:", error);
+    return new Response(
+      JSON.stringify({ error: "Failed to check slug availability" }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+};

package/src/pages/api/storage-config.ts

@@ -0,0 +1,20 @@
+import type { APIRoute } from "astro";
+import { getStorageConfig } from "@/lib/storage";
+
+export const GET: APIRoute = async () => {
+  try {
+    const config = await getStorageConfig();
+    return new Response(JSON.stringify(config), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        error: "Failed to get storage config",
+        details: String(error),
+      }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+};