@kyro-cms/admin 0.1.6 → 0.1.8

package/src/lib/MediaService.ts

@@ -0,0 +1,541 @@
+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 };

package/src/lib/api.ts

@@ -0,0 +1,163 @@
+export interface ApiResponse<T = any> {
+  docs?: T[];
+  doc?: T;
+  totalDocs?: number;
+  error?: string;
+}
+
+export async function apiGet<T = any>(
+  url: string,
+  options?: RequestInit,
+): Promise<T> {
+  const response = await fetch(url, {
+    ...options,
+    credentials: "include",
+  });
+  if (!response.ok) {
+    throw new Error(`API Error: ${response.status}`);
+  }
+  return response.json();
+}
+
+export async function apiPost<T = any>(
+  url: string,
+  body?: any,
+  options?: RequestInit,
+): Promise<T> {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+    credentials: "include",
+    ...options,
+  });
+  if (!response.ok) {
+    throw new Error(`API Error: ${response.status}`);
+  }
+  return response.json();
+}
+
+export async function apiPatch<T = any>(
+  url: string,
+  body?: any,
+  options?: RequestInit,
+): Promise<T> {
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+    credentials: "include",
+    ...options,
+  });
+  if (!response.ok) {
+    throw new Error(`API Error: ${response.status}`);
+  }
+  return response.json();
+}
+
+export async function apiPatchNoThrow<T = any>(
+  url: string,
+  body?: any,
+): Promise<{ ok: boolean; data?: T; error?: string }> {
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+    credentials: "include",
+  });
+  if (!response.ok) {
+    return { ok: false, error: `Error: ${response.status}` };
+  }
+  const data = await response.json();
+  return { ok: true, data };
+}
+
+export async function apiDelete<T = any>(
+  url: string,
+  options?: RequestInit,
+): Promise<T> {
+  const response = await fetch(url, {
+    method: "DELETE",
+    credentials: "include",
+    ...options,
+  });
+  if (!response.ok) {
+    throw new Error(`API Error: ${response.status}`);
+  }
+  return response.json();
+}
+
+export function buildQueryString(params: Record<string, any>): string {
+  const urlParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null && value !== "") {
+      urlParams.set(key, String(value));
+    }
+  }
+  return urlParams.toString();
+}
+
+export function withCacheBust(url: string): string {
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}t=${Date.now()}`;
+}
+
+export function buildSearchQuery(
+  search: string,
+  fields: string[],
+  limit: number = 50,
+): string {
+  if (!search || fields.length === 0) {
+    return `limit=${limit}`;
+  }
+  const searchQuery = fields
+    .map((f) => `where[${f}][contains]=${encodeURIComponent(search)}`)
+    .join("&");
+  return `${searchQuery}&limit=${limit}`;
+}
+
+export function buildCollectionUrl(
+  collection: string,
+  params?: Record<string, any>,
+): string {
+  let url = `/api/${collection}`;
+  if (params) {
+    const query = buildQueryString(params);
+    if (query) url += `?${query}`;
+  }
+  return withCacheBust(url);
+}
+
+export function buildDocumentUrl(
+  collection: string,
+  id: string,
+  params?: Record<string, any>,
+): string {
+  let url = `/api/${collection}/${id}`;
+  if (params) {
+    const query = buildQueryString(params);
+    if (query) url += `?${query}`;
+  }
+  return url;
+}
+
+export async function apiUpload<T = any>(
+  url: string,
+  body: FormData,
+): Promise<T> {
+  const response = await fetch(url, {
+    method: "POST",
+    body,
+    credentials: "include",
+  });
+  if (!response.ok) {
+    throw new Error(`Upload Error: ${response.status}`);
+  }
+  return response.json();
+}