@kyro-cms/admin 0.3.2 → 0.3.4

package/src/lib/db/index.ts

@@ -1,449 +0,0 @@
-import type { CollectionConfig } from "@kyro-cms/core";
-import type { DatabaseAdapter, DatabaseConfig, DatabaseType } from "./adapter";
-import type { AuthAdapter } from "@kyro-cms/core";
-
-let contentAdapter: DatabaseAdapter | null = null;
-let authAdapterInstance: AuthAdapter | null = null;
-let currentConfig: DatabaseConfig | null = null;
-
-export interface DatabaseConfig {
-  type: DatabaseType;
-  connectionString?: string;
-  host?: string;
-  port?: number;
-  database?: string;
-  username?: string;
-  password?: string;
-  poolMin?: number;
-  poolMax?: number;
-  contentDbPath?: string;
-  authDbPath?: string;
-}
-
-export function getDatabaseConfig(): DatabaseConfig {
-  const connectionString =
-    process.env.DB_CONNECTION_STRING || process.env.DATABASE_URL;
-
-  let type: DatabaseType = "sqlite";
-  if (connectionString) {
-    if (connectionString.startsWith("postgresql://")) type = "postgres";
-    else if (connectionString.startsWith("mysql://")) type = "mysql";
-    else if (connectionString.startsWith("mongodb://")) type = "mongodb";
-  } else if (process.env.DB_TYPE) {
-    type = process.env.DB_TYPE as DatabaseType;
-  }
-
-  return {
-    type,
-    connectionString,
-    host: process.env.DB_HOST || "localhost",
-    port: parseInt(process.env.DB_PORT || "5432"),
-    database:
-      process.env.DB_NAME || connectionString?.split("/").pop() || "kyro",
-    username: process.env.DB_USER,
-    password: process.env.DB_PASSWORD,
-    poolMin: parseInt(process.env.DB_POOL_MIN || "5"),
-    poolMax: parseInt(process.env.DB_POOL_MAX || "20"),
-    contentDbPath: process.env.CONTENT_DB_PATH || "./data/content.db",
-    authDbPath: process.env.AUTH_DB_PATH || "./data/auth.db",
-  };
-}
-
-export function getAuthConfig(): DatabaseConfig {
-  const type =
-    (process.env.AUTH_DB_TYPE as DatabaseType) || getDatabaseConfig().type;
-
-  return {
-    type,
-    connectionString:
-      process.env.AUTH_DB_CONNECTION_STRING || process.env.AUTH_DATABASE_URL,
-    host: process.env.AUTH_DB_HOST || getDatabaseConfig().host,
-    port: parseInt(
-      process.env.AUTH_DB_PORT || String(getDatabaseConfig().port),
-    ),
-    database: process.env.AUTH_DB_NAME || getDatabaseConfig().database,
-    username: process.env.AUTH_DB_USER || getDatabaseConfig().username,
-    password: process.env.AUTH_DB_PASSWORD || getDatabaseConfig().password,
-    authDbPath: process.env.AUTH_DB_PATH || "./data/auth.db",
-  };
-}
-
-export async function initializeDatabase(
-  collections: Record<string, CollectionConfig> = {},
-): Promise<DatabaseAdapter> {
-  const config = getDatabaseConfig();
-
-  if (contentAdapter && currentConfig?.type === config.type) {
-    contentAdapter.initialize(collections);
-    return contentAdapter;
-  }
-
-  currentConfig = config;
-
-  switch (config.type) {
-    case "sqlite": {
-      const { getSQLiteContentAdapter } =
-        await import("./drizzle-sqlite-adapter");
-      contentAdapter = getSQLiteContentAdapter(config);
-      break;
-    }
-    case "postgres": {
-      const { PostgresAdapter } = await import("./drizzle-postgres-adapter");
-      contentAdapter = new PostgresAdapter(config);
-      break;
-    }
-    case "mysql": {
-      const { MySQLAdapter } = await import("./drizzle-mysql-adapter");
-      contentAdapter = new MySQLAdapter(config);
-      break;
-    }
-    case "mongodb": {
-      const { MongoDBAdapter } = await import("./mongodb-adapter");
-      contentAdapter = new MongoDBAdapter(config);
-      break;
-    }
-    default:
-      throw new Error(`Unsupported database type: ${config.type}`);
-  }
-
-  contentAdapter.initialize(collections);
-  return contentAdapter;
-}
-
-export function getDatabaseAdapter(): DatabaseAdapter {
-  if (!contentAdapter) {
-    throw new Error(
-      "Database not initialized. Call initializeDatabase() first.",
-    );
-  }
-  return contentAdapter;
-}
-
-export function isDatabaseInitialized(): boolean {
-  return contentAdapter !== null;
-}
-
-export async function getAuthAdapter(): Promise<AuthAdapter> {
-  if (authAdapterInstance) {
-    return authAdapterInstance;
-  }
-
-  const authDbType =
-    (process.env.AUTH_DB_TYPE as DatabaseType) || getDatabaseConfig().type;
-  const config = getAuthConfig();
-
-  switch (authDbType) {
-    case "sqlite": {
-      const { getSQLiteAuthAdapter } =
-        await import("./drizzle-sqlite-auth-adapter");
-      authAdapterInstance = getSQLiteAuthAdapter();
-      break;
-    }
-    case "postgres": {
-      const { PostgresAuthAdapter } =
-        await import("./drizzle-postgres-auth-adapter");
-      authAdapterInstance = new PostgresAuthAdapter({
-        connectionString:
-          config.connectionString ||
-          `postgresql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`,
-      });
-      break;
-    }
-    case "mysql": {
-      const { MySQLAuthAdapter } = await import("./drizzle-mysql-auth-adapter");
-      authAdapterInstance = new MySQLAuthAdapter({
-        connectionString:
-          config.connectionString ||
-          `mysql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`,
-      });
-      break;
-    }
-    case "mongodb": {
-      const { MongoDBAuthAdapter } = await import("./mongodb-auth-adapter");
-      authAdapterInstance = new MongoDBAuthAdapter({
-        connectionString:
-          config.connectionString ||
-          `mongodb://${config.username}:${config.password}@${config.host}:${config.port}`,
-        database: config.database || "kyro",
-      });
-      break;
-    }
-    default: {
-      const { getSQLiteAuthAdapter: fallback } =
-        await import("./drizzle-sqlite-auth-adapter");
-      authAdapterInstance = fallback();
-    }
-  }
-
-  return authAdapterInstance;
-}
-
-export function getDatabaseType(): DatabaseType {
-  return getDatabaseConfig().type;
-}
-
-export function getAuthDatabaseType(): DatabaseType {
-  return (process.env.AUTH_DB_TYPE as DatabaseType) || getDatabaseConfig().type;
-}
-
-let migrationsRun = false;
-
-export async function runMigrations(): Promise<void> {
-  if (migrationsRun) return;
-
-  const config = getDatabaseConfig();
-  const dbType = config.type;
-
-  console.log(`[db] Running migrations for ${dbType}...`);
-
-  try {
-    if (dbType === "postgres") {
-      const { default: pg } = await import("pg");
-      const pool = new pg.Pool({
-        connectionString:
-          config.connectionString ||
-          `postgresql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`,
-      });
-
-      const client = await pool.connect();
-
-      await client.query(`
-        CREATE TABLE IF NOT EXISTS settings (
-          key VARCHAR(255) PRIMARY KEY,
-          value TEXT NOT NULL,
-          description TEXT,
-          updated_at TIMESTAMP DEFAULT NOW()
-        )
-      `);
-
-      await client.query(`
-        CREATE TABLE IF NOT EXISTS media (
-          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          filename VARCHAR(255) NOT NULL UNIQUE,
-          title VARCHAR(255),
-          original_name VARCHAR(255) NOT NULL,
-          mime_type VARCHAR(100) NOT NULL,
-          file_size INTEGER NOT NULL,
-          width INTEGER,
-          height INTEGER,
-          url TEXT NOT NULL UNIQUE,
-          thumbnail_url TEXT,
-          folder VARCHAR(255),
-          provider VARCHAR(50) NOT NULL,
-          alt TEXT,
-          caption TEXT,
-          metadata JSONB,
-          created_at TIMESTAMP DEFAULT NOW() NOT NULL,
-          updated_at TIMESTAMP DEFAULT NOW() NOT NULL
-        )
-      `);
-
-      await client.query(
-        `CREATE INDEX IF NOT EXISTS media_folder_idx ON media(folder)`,
-      );
-      await client.query(
-        `CREATE INDEX IF NOT EXISTS media_provider_idx ON media(provider)`,
-      );
-      await client.query(
-        `CREATE INDEX IF NOT EXISTS media_filename_idx ON media(filename)`,
-      );
-
-      await client.query(`
-        CREATE TABLE IF NOT EXISTS media_folders (
-          path VARCHAR(500) PRIMARY KEY,
-          name VARCHAR(255) NOT NULL,
-          parent_path VARCHAR(500),
-          created_at TIMESTAMP DEFAULT NOW()
-        )
-      `);
-
-      client.release();
-      await pool.end();
-
-      migrationsRun = true;
-      console.log(`[db] Migrations complete`);
-    } else if (dbType === "sqlite") {
-      const Database = (await import("better-sqlite3")).default;
-      const db = new Database(config.contentDbPath || "./data/content.db");
-
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS settings (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          description TEXT,
-          updated_at TEXT DEFAULT (datetime('now'))
-        )
-      `);
-
-      try {
-        db.exec(`
-          CREATE TABLE IF NOT EXISTS media (
-            id TEXT PRIMARY KEY,
-            filename TEXT NOT NULL UNIQUE,
-            title TEXT,
-            original_name TEXT NOT NULL,
-            mime_type TEXT NOT NULL,
-            file_size INTEGER NOT NULL,
-            width INTEGER,
-            height INTEGER,
-            url TEXT NOT NULL UNIQUE,
-            thumbnail_url TEXT,
-            folder TEXT,
-            provider TEXT NOT NULL,
-            alt TEXT,
-            caption TEXT,
-            metadata TEXT,
-            created_at TEXT DEFAULT (datetime('now')),
-            updated_at TEXT DEFAULT (datetime('now'))
-          )
-        `);
-      } catch (e) {
-        // Table exists - try adding missing columns
-        try {
-          const tableInfo = db.prepare("PRAGMA table_info(media)").all();
-          const existingColumns = new Set(tableInfo.map((c: any) => c.name));
-
-          const requiredCols = [
-            { name: "title", sql: "ALTER TABLE media ADD COLUMN title TEXT" },
-            {
-              name: "thumbnail_url",
-              sql: "ALTER TABLE media ADD COLUMN thumbnail_url TEXT",
-            },
-            { name: "folder", sql: "ALTER TABLE media ADD COLUMN folder TEXT" },
-            {
-              name: "provider",
-              sql: "ALTER TABLE media ADD COLUMN provider TEXT NOT NULL DEFAULT 'local'",
-            },
-            { name: "alt", sql: "ALTER TABLE media ADD COLUMN alt TEXT" },
-            {
-              name: "caption",
-              sql: "ALTER TABLE media ADD COLUMN caption TEXT",
-            },
-            {
-              name: "metadata",
-              sql: "ALTER TABLE media ADD COLUMN metadata TEXT",
-            },
-          ];
-
-          for (const col of requiredCols) {
-            if (!existingColumns.has(col.name)) {
-              try {
-                db.exec(col.sql);
-              } catch {}
-            }
-          }
-        } catch {}
-      }
-
-      db.exec(`CREATE INDEX IF NOT EXISTS media_folder_idx ON media(folder)`);
-      db.exec(
-        `CREATE INDEX IF NOT EXISTS media_provider_idx ON media(provider)`,
-      );
-      db.exec(
-        `CREATE INDEX IF NOT EXISTS media_filename_idx ON media(filename)`,
-      );
-
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS media_folders (
-          path TEXT PRIMARY KEY,
-          name TEXT NOT NULL,
-          parent_path TEXT,
-          created_at TEXT DEFAULT (datetime('now'))
-        )
-      `);
-
-      db.close();
-
-      migrationsRun = true;
-      console.log(`[db] Migrations complete`);
-    } else if (dbType === "mysql") {
-      const mysql = await import("mysql2/promise");
-      const connString =
-        config.connectionString ||
-        `mysql://${config.username}:${config.password}@${config.host}:${config.port}/${config.database}`;
-      const pool = await mysql.createPool({ uri: connString });
-
-      await pool.execute(`
-        CREATE TABLE IF NOT EXISTS settings (
-          \`key\` VARCHAR(255) PRIMARY KEY,
-          \`value\` TEXT NOT NULL,
-          \`description\` TEXT,
-          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-      `);
-
-      await pool.execute(`
-        CREATE TABLE IF NOT EXISTS media (
-          id VARCHAR(36) PRIMARY KEY,
-          filename VARCHAR(255) NOT NULL UNIQUE,
-          title VARCHAR(255),
-          original_name VARCHAR(255) NOT NULL,
-          mime_type VARCHAR(100) NOT NULL,
-          file_size INTEGER NOT NULL,
-          width INTEGER,
-          height INTEGER,
-          url TEXT NOT NULL UNIQUE,
-          thumbnail_url TEXT,
-          folder VARCHAR(255),
-          provider VARCHAR(50) NOT NULL,
-          alt TEXT,
-          caption TEXT,
-          metadata JSON,
-          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-          updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-      `);
-
-      await pool.execute(
-        `CREATE INDEX IF NOT EXISTS media_folder_idx ON media(folder)`,
-      );
-      await pool.execute(
-        `CREATE INDEX IF NOT EXISTS media_provider_idx ON media(provider)`,
-      );
-      await pool.execute(
-        `CREATE INDEX IF NOT EXISTS media_filename_idx ON media(filename)`,
-      );
-
-      await pool.execute(`
-        CREATE TABLE IF NOT EXISTS media_folders (
-          path VARCHAR(500) PRIMARY KEY,
-          name VARCHAR(255) NOT NULL,
-          parent_path VARCHAR(500),
-          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-      `);
-
-      await pool.end();
-
-      migrationsRun = true;
-      console.log(`[db] Migrations complete`);
-    } else if (dbType === "mongodb") {
-      const { MongoClient } = await import("mongodb");
-      const connString =
-        config.connectionString || `mongodb://${config.host}:${config.port}`;
-      const client = new MongoClient(connString);
-      await client.connect();
-      const db = client.db(config.database);
-
-      const settingsCollection = db.collection("settings");
-      await settingsCollection.createIndex("key", { unique: true });
-
-      const mediaCollection = db.collection("media");
-      await mediaCollection.createIndex("filename", { unique: true });
-      await mediaCollection.createIndex("url", { unique: true });
-      await mediaCollection.createIndex("folder");
-      await mediaCollection.createIndex("provider");
-      await mediaCollection.createIndex("created_at");
-
-      const foldersCollection = db.collection("media_folders");
-      await foldersCollection.createIndex("path", { unique: true });
-
-      await client.close();
-
-      migrationsRun = true;
-      console.log(`[db] Migrations complete`);
-    }
-  } catch (error) {
-    console.error(`[db] Migration error:`, error);
-  }
-}

package/src/lib/db/mongodb-adapter.ts

@@ -1,207 +0,0 @@
-import type { CollectionConfig } from "@kyro-cms/core";
-import type { DatabaseAdapter, DatabaseConfig } from "./adapter";
-import { MongoClient, Db } from "mongodb";
-import { randomBytes } from "crypto";
-
-export class MongoDBAdapter implements DatabaseAdapter {
-  private client: MongoClient | null = null;
-  private db: Db | null = null;
-  private initialized = false;
-
-  constructor(private config: DatabaseConfig) {}
-
-  private async getDb(): Promise<Db> {
-    if (!this.client) {
-      const connectionString =
-        this.config.connectionString ||
-        `mongodb://${this.config.username}:${this.config.password}@${this.config.host}:${this.config.port}`;
-      this.client = new MongoClient(connectionString);
-      await this.client.connect();
-    }
-    if (!this.db) {
-      this.db = this.client!.db(this.config.database || "kyro");
-    }
-    return this.db;
-  }
-
-  async connect(): Promise<void> {
-    await this.getDb();
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.client) {
-      await this.client.close();
-      this.client = null;
-      this.db = null;
-    }
-  }
-
-  initialize(collections: Record<string, CollectionConfig>): void {
-    if (this.initialized) return;
-    this.initialized = true;
-  }
-
-  private getTimestamp(): string {
-    return new Date().toISOString();
-  }
-
-  private async generateId(slug: string): Promise<string> {
-    const db = await this.getDb();
-    const count = await db
-      .collection("documents")
-      .countDocuments({ collection: slug });
-    return `${slug}-${count + 1}`;
-  }
-
-  async find<T = any>(
-    slug: string,
-    options: { page?: number; limit?: number } = {},
-  ): Promise<{
-    docs: T[];
-    totalDocs: number;
-    totalPages: number;
-    page: number;
-  }> {
-    const db = await this.getDb();
-    const page = options.page || 1;
-    const limit = options.limit || 25;
-    const start = (page - 1) * limit;
-
-    const totalDocs = await db
-      .collection("documents")
-      .countDocuments({ collection: slug });
-    const docs = await db
-      .collection("documents")
-      .find({ collection: slug })
-      .sort({ createdAt: -1 })
-      .skip(start)
-      .limit(limit)
-      .toArray();
-
-    return {
-      docs: docs.map((d) => d.data as T),
-      totalDocs,
-      totalPages: Math.ceil(totalDocs / limit),
-      page,
-    };
-  }
-
-  async findById<T = any>(slug: string, id: string): Promise<T | null> {
-    const db = await this.getDb();
-    const doc = await db
-      .collection("documents")
-      .findOne({ collection: slug, id });
-    return doc ? (doc.data as T) : null;
-  }
-
-  async create<T = any>(slug: string, data: Partial<T>): Promise<T> {
-    const db = await this.getDb();
-    const now = this.getTimestamp();
-    const id = await this.generateId(slug);
-    const newDoc = {
-      id,
-      collection: slug,
-      data: {
-        id,
-        ...(data as Record<string, unknown>),
-        createdAt: now,
-        updatedAt: now,
-      },
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    await db.collection("documents").insertOne(newDoc);
-    return newDoc.data as T;
-  }
-
-  async update<T = any>(
-    slug: string,
-    id: string,
-    data: Partial<T>,
-  ): Promise<T | null> {
-    const db = await this.getDb();
-    const existing = await this.findById<T>(slug, id);
-    if (!existing) return null;
-
-    const now = this.getTimestamp();
-    const updated = { ...existing, ...data, id, updatedAt: now };
-
-    await db
-      .collection("documents")
-      .updateOne(
-        { collection: slug, id },
-        { $set: { data: updated, updatedAt: now } },
-      );
-
-    return updated as T;
-  }
-
-  async delete(slug: string, id: string): Promise<boolean> {
-    const db = await this.getDb();
-    await db.collection("documents").deleteOne({ collection: slug, id });
-    return true;
-  }
-
-  async findGlobal<T = any>(slug: string): Promise<T> {
-    const db = await this.getDb();
-    const global = await db.collection("globals").findOne({ slug });
-    return global ? (global.data as T) : ({} as T);
-  }
-
-  async updateGlobal<T = any>(slug: string, data: Partial<T>): Promise<T> {
-    const db = await this.getDb();
-    const now = this.getTimestamp();
-    const current = await this.findGlobal<T>(slug);
-    const updated = { ...current, ...data };
-
-    await db
-      .collection("globals")
-      .updateOne(
-        { slug },
-        { $set: { data: updated, updatedAt: now } },
-        { upsert: true },
-      );
-
-    return updated as T;
-  }
-
-  async seedGlobal(slug: string, data: any): Promise<void> {
-    const db = await this.getDb();
-    const now = this.getTimestamp();
-    await db
-      .collection("globals")
-      .updateOne(
-        { slug },
-        { $setOnInsert: { slug, data, updatedAt: now } },
-        { upsert: true },
-      );
-  }
-
-  async count(slug: string): Promise<number> {
-    const db = await this.getDb();
-    return db.collection("documents").countDocuments({ collection: slug });
-  }
-
-  async seed(slug: string, docs: any[]): Promise<void> {
-    const db = await this.getDb();
-    const now = this.getTimestamp();
-    const insertDocs = docs.map((doc, i) => ({
-      id: doc.id || `${slug}-${i + 1}`,
-      collection: slug,
-      data: {
-        ...doc,
-        createdAt: doc.createdAt || now,
-        updatedAt: doc.updatedAt || now,
-      },
-      createdAt: doc.createdAt || now,
-      updatedAt: doc.updatedAt || now,
-    }));
-
-    await db.collection("documents").insertMany(insertDocs);
-  }
-
-  async isSeeded(slug: string): Promise<boolean> {
-    return (await this.count(slug)) > 0;
-  }
-}