@kyro-cms/admin 0.3.2 → 0.3.5

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

@@ -1,146 +0,0 @@
-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

@@ -1,267 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

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