@kyro-cms/admin 0.3.1 → 0.3.4

package/src/components/StatusBadge.tsx

@@ -1,76 +0,0 @@
-import React, { type ReactNode } from "react";
-
-interface StatusBadgeProps {
-  status:
-    | "draft"
-    | "published"
-    | "scheduled"
-    | "archived"
-    | "active"
-    | "inactive"
-    | "pending"
-    | "completed"
-    | "cancelled";
-  children?: ReactNode;
-}
-
-export function StatusBadge({ status, children }: StatusBadgeProps) {
-  const statusConfig: Record<string, { class: string; defaultLabel?: string }> =
-    {
-      draft: { class: "bg-gray-100 text-gray-600", defaultLabel: "Draft" },
-      published: {
-        class: "bg-green-100 text-green-700",
-        defaultLabel: "Published",
-      },
-      scheduled: {
-        class: "bg-blue-100 text-blue-700",
-        defaultLabel: "Scheduled",
-      },
-      archived: {
-        class: "bg-yellow-100 text-yellow-700",
-        defaultLabel: "Archived",
-      },
-      active: { class: "bg-green-100 text-green-700", defaultLabel: "Active" },
-      inactive: {
-        class: "bg-gray-100 text-gray-600",
-        defaultLabel: "Inactive",
-      },
-      pending: {
-        class: "bg-yellow-100 text-yellow-700",
-        defaultLabel: "Pending",
-      },
-      completed: {
-        class: "bg-green-100 text-green-700",
-        defaultLabel: "Completed",
-      },
-      cancelled: {
-        class: "bg-red-100 text-red-700",
-        defaultLabel: "Cancelled",
-      },
-    };
-
-  const config = statusConfig[status] || { class: "bg-gray-100 text-gray-600" };
-
-  return (
-    <span
-      className={`inline-flex items-center px-2 py-0.5 rounded text-xs font-medium ${config.class}`}
-    >
-      {children || config.defaultLabel || status}
-    </span>
-  );
-}
-
-interface CountBadgeProps {
-  count: number;
-  max?: number;
-}
-
-export function CountBadge({ count, max = 99 }: CountBadgeProps) {
-  if (count === 0) return null;
-
-  return (
-    <span className="inline-flex items-center justify-center min-w-[20px] h-5 px-1.5 text-xs font-medium bg-gray-200 text-gray-700 rounded-full">
-      {count > max ? `${max}+` : count}
-    </span>
-  );
-}

package/src/lib/MediaService.ts

@@ -1,541 +0,0 @@
-import { getDatabaseAdapter, getDatabaseConfig, runMigrations } from "./db";
-
-interface MediaItem {
-  id: string;
-  filename: string;
-  title: string | null;
-  originalName: string;
-  mimeType: string;
-  fileSize: number;
-  width: number | null;
-  height: number | null;
-  url: string;
-  thumbnailUrl: string | null;
-  folder: string | null;
-  provider: string;
-  alt: string | null;
-  caption: string | null;
-  metadata: Record<string, unknown> | null;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-interface FindOptions {
-  page?: number;
-  limit?: number;
-  search?: string;
-  type?: string;
-  folder?: string;
-  sortBy?: string;
-  sortDir?: "asc" | "desc";
-}
-
-interface FindResult {
-  docs: MediaItem[];
-  totalDocs: number;
-  page: number;
-  limit: number;
-  totalPages: number;
-}
-
-class AdminMediaService {
-  private db: any = null;
-  private dbType: string = "sqlite";
-
-  async init(): Promise<void> {
-    await runMigrations();
-    const config = getDatabaseConfig();
-    this.dbType = config.type;
-    console.log("[MediaService] Initializing with dbType:", this.dbType);
-    console.log("[MediaService] Config:", config);
-
-    if (config.type === "postgres") {
-      const { Pool } = await import("pg");
-      this.db = new Pool({
-        connectionString:
-          config.connectionString ||
-          `postgresql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`,
-      });
-    } else if (config.type === "sqlite") {
-      const Database = (await import("better-sqlite3")).default;
-      this.db = new Database(config.contentDbPath || "./data/content.db");
-    } else if (config.type === "mysql") {
-      const mysql = await import("mysql2/promise");
-      const connString =
-        config.connectionString ||
-        `mysql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`;
-      this.db = await mysql.createPool({
-        uri: connString,
-      });
-    } else if (config.type === "mongodb") {
-      const { MongoClient } = await import("mongodb");
-      const connString =
-        config.connectionString || `mongodb://${config.host}:${config.port}`;
-      const client = new MongoClient(connString);
-      await client.connect();
-      this.db = client.db(config.database);
-    }
-  }
-
-  private mapRow(row: any): MediaItem {
-    return {
-      id: row.id,
-      filename: row.filename,
-      title: row.title,
-      originalName: row.original_name,
-      mimeType: row.mime_type,
-      fileSize: row.file_size,
-      width: row.width,
-      height: row.height,
-      url: row.url,
-      thumbnailUrl: row.thumbnail_url,
-      folder: row.folder,
-      provider: row.provider,
-      alt: row.alt,
-      caption: row.caption,
-      metadata: row.metadata,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-    };
-  }
-
-  async find(options: FindOptions = {}): Promise<FindResult> {
-    const page = options.page || 1;
-    const limit = options.limit || 30;
-    const offset = (page - 1) * limit;
-    let sortBy = options.sortBy || "created_at";
-    if (sortBy === "createdAt") sortBy = "created_at";
-    if (sortBy === "updatedAt") sortBy = "updated_at";
-    if (sortBy === "fileSize") sortBy = "file_size";
-    const sortDir = options.sortDir === "asc" ? "ASC" : "DESC";
-
-    console.log("[MediaService.find] dbType:", this.dbType, "sortBy:", sortBy);
-
-    if (this.dbType === "mongodb") {
-      return this.findMongoDB(options, page, limit, sortBy, sortDir);
-    }
-
-    try {
-      return await this.findSql(options, page, limit, offset, sortBy, sortDir);
-    } catch (err: any) {
-      console.error("[MediaService.find] Error:", err.message, err.stack);
-      throw err;
-    }
-  }
-
-  async findById(id: string): Promise<MediaItem | null> {
-    if (this.dbType === "mongodb") {
-      const collection = this.db.collection("media");
-      const doc = await collection.findOne({ _id: id });
-      return doc ? this.mapRow(doc) : null;
-    }
-    if (this.dbType === "sqlite") {
-      const stmt = this.db.prepare("SELECT * FROM media WHERE id = ?");
-      const row = stmt.get(id);
-      return row ? this.mapRow(row) : null;
-    }
-    if (this.dbType === "postgres") {
-      const result = await this.db.query("SELECT * FROM media WHERE id = $1", [id]);
-      return result.rows[0] ? this.mapRow(result.rows[0]) : null;
-    }
-    if (this.dbType === "mysql") {
-      const [rows] = await this.db.execute("SELECT * FROM media WHERE id = ?", [id]);
-      return (rows as any[])[0] ? this.mapRow((rows as any[])[0]) : null;
-    }
-    return null;
-  }
-
-  private async findSql(
-    options: FindOptions,
-    page: number,
-    limit: number,
-    offset: number,
-    sortBy: string,
-    sortDir: string,
-  ): Promise<FindResult> {
-    let whereClause = "1=1";
-    const params: any[] = [];
-    let paramIndex = 1;
-
-    const isPostgres = this.dbType === "postgres";
-    const getParam = () => (isPostgres ? `$${paramIndex++}` : "?");
-
-    if (options.search) {
-      const likeOp = this.dbType === "postgres" ? "ILIKE" : "LIKE";
-      if (isPostgres) {
-        whereClause += ` AND (filename ${likeOp} $${paramIndex} OR title ${likeOp} $${paramIndex})`;
-        params.push(`%${options.search}%`);
-        paramIndex++;
-      } else {
-        whereClause += ` AND (filename ${likeOp} ? OR title ${likeOp} ?)`;
-        params.push(`%${options.search}%`, `%${options.search}%`);
-      }
-    }
-
-    if (options.folder) {
-      if (isPostgres) {
-        whereClause += ` AND (folder = $${paramIndex} OR folder LIKE $${paramIndex + 1})`;
-        params.push(options.folder, `${options.folder}/%`);
-        paramIndex += 2;
-      } else {
-        whereClause += ` AND (folder = ? OR folder LIKE ?)`;
-        params.push(options.folder, `${options.folder}/%`);
-      }
-    }
-
-    if (options.type) {
-      const likeOp = this.dbType === "postgres" ? "ILIKE" : "LIKE";
-      whereClause += ` AND mime_type ${likeOp} ${getParam()}`;
-      params.push(`${options.type}%`);
-    }
-
-    let countQuery: string;
-    let dataQuery: string;
-    let countResult: any;
-    let dataResult: any;
-
-    if (this.dbType === "postgres") {
-      countQuery = `SELECT COUNT(*) as total FROM media WHERE ${whereClause}`;
-      dataQuery = `SELECT * FROM media WHERE ${whereClause} ORDER BY ${sortBy} ${sortDir} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
-      params.push(limit, offset);
-      countResult = await this.db.query(countQuery, params.slice(0, -2));
-      dataResult = await this.db.query(dataQuery, params);
-      const totalDocs = parseInt(countResult.rows[0]?.total || "0", 10);
-      const docs = dataResult.rows.map((row: any) => this.mapRow(row));
-      return {
-        docs,
-        totalDocs,
-        page,
-        limit,
-        totalPages: Math.ceil(totalDocs / limit),
-      };
-    } else if (this.dbType === "sqlite") {
-      countQuery = `SELECT COUNT(*) as total FROM media WHERE ${whereClause}`;
-      dataQuery = `SELECT * FROM media WHERE ${whereClause} ORDER BY ${sortBy} ${sortDir} LIMIT ? OFFSET ?`;
-      params.push(limit, offset);
-      console.log("[MediaService.find] SQLite data query:", dataQuery);
-      const countStmt = this.db.prepare(countQuery);
-      const dataStmt = this.db.prepare(dataQuery);
-      let countRow: any;
-      try {
-        countRow = countStmt.get(...params.slice(0, -2));
-      } catch (e: any) {
-        console.error("[MediaService.find] Count error:", e.message);
-        countRow = { total: 0 };
-      }
-      const totalDocs = countRow?.total || 0;
-      let rows: any[];
-      try {
-        rows = dataStmt.all(...params);
-      } catch (e: any) {
-        console.error("[MediaService.find] Data error:", e.message);
-        rows = [];
-      }
-      const docs = rows.map((row: any) => this.mapRow(row));
-      return {
-        docs,
-        totalDocs,
-        page,
-        limit,
-        totalPages: Math.ceil(totalDocs / limit),
-      };
-    } else if (this.dbType === "mysql") {
-      countQuery = `SELECT COUNT(*) as total FROM media WHERE ${whereClause}`;
-      dataQuery = `SELECT * FROM media WHERE ${whereClause} ORDER BY ${sortBy} ${sortDir} LIMIT ? OFFSET ?`;
-      params.push(limit, offset);
-      const [countRows] = await this.db.execute(
-        countQuery,
-        params.slice(0, -2),
-      );
-      const [dataRows] = await this.db.execute(dataQuery, params);
-      const totalDocs = countRows[0]?.total || 0;
-      const docs = dataRows.map((row: any) => this.mapRow(row));
-      return {
-        docs,
-        totalDocs,
-        page,
-        limit,
-        totalPages: Math.ceil(totalDocs / limit),
-      };
-    }
-
-    return { docs: [], totalDocs: 0, page, limit, totalPages: 0 };
-  }
-
-  private async findMongoDB(
-    options: FindOptions,
-    page: number,
-    limit: number,
-    sortBy: string,
-    sortDir: string,
-  ): Promise<FindResult> {
-    const collection = this.db.collection("media");
-    const filter: any = {};
-
-    if (options.search) {
-      filter.$or = [
-        { filename: { $regex: options.search, $options: "i" } },
-        { title: { $regex: options.search, $options: "i" } },
-      ];
-    }
-
-    if (options.folder) {
-      filter.folder = options.folder;
-    }
-
-    if (options.type) {
-      filter.mimeType = { $regex: `^${options.type}` };
-    }
-
-    const skip = (page - 1) * limit;
-    const sort: any = { [sortBy]: sortDir === "asc" ? 1 : -1 };
-
-    const [docs, totalDocs] = await Promise.all([
-      collection.find(filter).sort(sort).skip(skip).limit(limit).toArray(),
-      collection.countDocuments(filter),
-    ]);
-
-    const mappedDocs = docs.map((row: any) => ({
-      id: row._id?.toString() || row.id,
-      filename: row.filename,
-      title: row.title,
-      originalName: row.originalName || row.original_name,
-      mimeType: row.mimeType || row.mime_type,
-      fileSize: row.fileSize || row.file_size,
-      width: row.width,
-      height: row.height,
-      url: row.url,
-      thumbnailUrl: row.thumbnailUrl || row.thumbnail_url,
-      folder: row.folder,
-      provider: row.provider,
-      alt: row.alt,
-      caption: row.caption,
-      metadata: row.metadata,
-      createdAt: row.createdAt || row.created_at,
-      updatedAt: row.updatedAt || row.updated_at,
-    }));
-
-    return {
-      docs: mappedDocs,
-      totalDocs,
-      page,
-      limit,
-      totalPages: Math.ceil(totalDocs / limit),
-    };
-  }
-
-  async create(data: Partial<MediaItem>): Promise<MediaItem> {
-    const id = data.id || crypto.randomUUID();
-    const now = new Date();
-
-    if (this.dbType === "mongodb") {
-      const collection = this.db.collection("media");
-      const doc = {
-        _id: id,
-        filename: data.filename,
-        title: data.title,
-        original_name: data.originalName,
-        mime_type: data.mimeType,
-        file_size: data.fileSize,
-        width: data.width,
-        height: data.height,
-        url: data.url,
-        thumbnail_url: data.thumbnailUrl,
-        folder: data.folder,
-        provider: data.provider || "local",
-        alt: data.alt,
-        caption: data.caption,
-        metadata: data.metadata,
-        created_at: now,
-        updated_at: now,
-      };
-      await collection.insertOne(doc);
-      return this.mapRow(doc);
-    }
-
-    const sql =
-      this.dbType === "postgres"
-        ? `INSERT INTO media (id, filename, title, original_name, mime_type, file_size, width, height, url, thumbnail_url, folder, provider, alt, caption, metadata, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, NOW(), NOW()) RETURNING *`
-        : this.dbType === "sqlite"
-          ? `INSERT INTO media (id, filename, title, original_name, mime_type, file_size, width, height, url, thumbnail_url, folder, provider, alt, caption, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-          : `INSERT INTO media (id, filename, title, original_name, mime_type, file_size, width, height, url, thumbnail_url, folder, provider, alt, caption, metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), NOW())`;
-
-    const values = [
-      id,
-      data.filename,
-      data.title || null,
-      data.originalName,
-      data.mimeType,
-      data.fileSize,
-      data.width || null,
-      data.height || null,
-      data.url,
-      data.thumbnailUrl || null,
-      data.folder || null,
-      data.provider || "local",
-      data.alt || null,
-      data.caption || null,
-      data.metadata ? JSON.stringify(data.metadata) : null,
-    ];
-
-    let result: any;
-
-    if (this.dbType === "postgres") {
-      result = await this.db.query(sql, values);
-      return this.mapRow(result.rows[0]);
-    } else if (this.dbType === "sqlite") {
-      const stmt = this.db.prepare(sql);
-      stmt.run(...values);
-      const getStmt = this.db.prepare("SELECT * FROM media WHERE id = ?");
-      const row = getStmt.get(id);
-      return this.mapRow(row);
-    } else if (this.dbType === "mysql") {
-      await this.db.execute(sql, values);
-      const [rows] = await this.db.execute("SELECT * FROM media WHERE id = ?", [
-        id,
-      ]);
-      return this.mapRow(rows[0]);
-    }
-
-    throw new Error("Unsupported database type");
-  }
-
-  async update(
-    id: string,
-    data: Partial<MediaItem>,
-  ): Promise<MediaItem | null> {
-    if (this.dbType === "mongodb") {
-      const collection = this.db.collection("media");
-      const update: any = { $set: { updated_at: new Date() } };
-      if (data.title !== undefined) update.$set.title = data.title;
-      if (data.alt !== undefined) update.$set.alt = data.alt;
-      if (data.caption !== undefined) update.$set.caption = data.caption;
-      if (data.folder !== undefined) update.$set.folder = data.folder;
-      if (data.thumbnailUrl !== undefined)
-        update.$set.thumbnail_url = data.thumbnailUrl;
-
-      await collection.updateOne({ _id: id }, update);
-      const doc = await collection.findOne({ _id: id });
-      return doc ? this.mapRow(doc) : null;
-    }
-
-    const updates: string[] = [];
-    const params: any[] = [];
-    let paramIndex = 1;
-
-    const getParam = () =>
-      this.dbType === "postgres" ? `$${paramIndex++}` : "?";
-
-    if (data.title !== undefined) {
-      updates.push(`title = ${getParam()}`);
-      params.push(data.title);
-    }
-    if (data.filename !== undefined) {
-      updates.push(`filename = ${getParam()}`);
-      params.push(data.filename);
-    }
-    if (data.url !== undefined) {
-      updates.push(`url = ${getParam()}`);
-      params.push(data.url);
-    }
-    if (data.thumbnailUrl !== undefined) {
-      updates.push(`thumbnail_url = ${getParam()}`);
-      params.push(data.thumbnailUrl);
-    }
-    if (data.alt !== undefined) {
-      updates.push(`alt = ${getParam()}`);
-      params.push(data.alt);
-    }
-    if (data.caption !== undefined) {
-      updates.push(`caption = ${getParam()}`);
-      params.push(data.caption);
-    }
-    if (data.folder !== undefined) {
-      updates.push(`folder = ${getParam()}`);
-      params.push(data.folder);
-    }
-
-    if (updates.length === 0) return null;
-
-    if (this.dbType === "postgres") {
-      updates.push(`updated_at = NOW()`);
-      params.push(id);
-      const sql = `UPDATE media SET ${updates.join(", ")} WHERE id = $${paramIndex} RETURNING *`;
-      const result = await this.db.query(sql, params);
-      return result.rows[0] ? this.mapRow(result.rows[0]) : null;
-    } else if (this.dbType === "sqlite") {
-      updates.push(`updated_at = datetime('now')`);
-      params.push(id);
-      const sql = `UPDATE media SET ${updates.join(", ")} WHERE id = ?`;
-      const stmt = this.db.prepare(sql);
-      stmt.run(...params);
-      const getStmt = this.db.prepare("SELECT * FROM media WHERE id = ?");
-      const row = getStmt.get(id);
-      return row ? this.mapRow(row) : null;
-    } else if (this.dbType === "mysql") {
-      updates.push(`updated_at = NOW()`);
-      params.push(id);
-      const sql = `UPDATE media SET ${updates.join(", ")} WHERE id = ?`;
-      await this.db.execute(sql, params);
-      const [rows] = await this.db.execute("SELECT * FROM media WHERE id = ?", [
-        id,
-      ]);
-      return rows[0] ? this.mapRow(rows[0]) : null;
-    }
-
-    return null;
-  }
-
-  async delete(id: string): Promise<boolean> {
-    if (this.dbType === "mongodb") {
-      const collection = this.db.collection("media");
-      const result = await collection.deleteOne({ _id: id });
-      return result.deletedCount > 0;
-    }
-
-    if (this.dbType === "postgres") {
-      const result = await this.db.query(
-        "DELETE FROM media WHERE id = $1 RETURNING id",
-        [id],
-      );
-      return result.rows.length > 0;
-    } else if (this.dbType === "sqlite") {
-      const stmt = this.db.prepare("DELETE FROM media WHERE id = ?");
-      const result = stmt.run(id);
-      return result.changes > 0;
-    } else if (this.dbType === "mysql") {
-      const result = await this.db.execute("DELETE FROM media WHERE id = ?", [
-        id,
-      ]);
-      return (result.affectedRows || 0) > 0;
-    }
-
-    return false;
-  }
-
-  async close(): Promise<void> {
-    if (this.db) {
-      if (this.dbType === "postgres") {
-        await this.db.end();
-      } else if (this.dbType === "mysql") {
-        await this.db.end();
-      } else if (this.dbType === "mongodb") {
-        await this.db.client.close();
-      } else {
-        this.db.close();
-      }
-    }
-  }
-}
-
-let mediaServiceInstance: AdminMediaService | null = null;
-
-export async function getMediaService(): Promise<AdminMediaService> {
-  if (!mediaServiceInstance) {
-    mediaServiceInstance = new AdminMediaService();
-    await mediaServiceInstance.init();
-  }
-  return mediaServiceInstance;
-}
-
-export type { MediaItem, FindOptions, FindResult };