@kyro-cms/admin 0.1.6 → 0.1.8

package/src/lib/db/drizzle-sqlite-adapter.ts

@@ -0,0 +1,227 @@
+import type { CollectionConfig } from "@kyro-cms/core";
+import type { DatabaseAdapter, DatabaseConfig } from "./adapter";
+import Database from "better-sqlite3";
+import path from "path";
+import fs from "fs";
+import { randomBytes } from "crypto";
+import { eq, desc, sql, and } from "drizzle-orm";
+import * as contentSchema from "./schema/sqlite-content";
+
+function getContentDbPath(): string {
+  return (
+    process.env.CONTENT_DB_PATH ||
+    path.join(process.cwd(), "data", "content.db")
+  );
+}
+
+function ensureDbDir(dbPath: string): void {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export class DrizzleSQLiteAdapter implements DatabaseAdapter {
+  private db: Database.Database;
+  private initialized = false;
+
+  constructor(config?: DatabaseConfig) {
+    const dbPath = config?.contentDbPath || getContentDbPath();
+    ensureDbDir(dbPath);
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("cache_size = -64000");
+  }
+
+  initialize(collections: Record<string, CollectionConfig>) {
+    if (this.initialized) return;
+
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS documents (
+        id TEXT PRIMARY KEY,
+        collection TEXT NOT NULL,
+        data TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS globals (
+        slug TEXT PRIMARY KEY,
+        data TEXT NOT NULL DEFAULT '{}',
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_documents_collection ON documents(collection);
+      CREATE INDEX IF NOT EXISTS idx_documents_created_at ON documents(created_at);
+    `);
+
+    this.initialized = true;
+  }
+
+  private getTimestamp(): string {
+    return new Date().toISOString();
+  }
+
+  private generateId(): string {
+    return randomBytes(16).toString("hex");
+  }
+
+  async find<T = any>(
+    slug: string,
+    options: { page?: number; limit?: number } = {},
+  ): Promise<{
+    docs: T[];
+    totalDocs: number;
+    totalPages: number;
+    page: number;
+  }> {
+    const page = options.page || 1;
+    const limit = options.limit || 25;
+    const start = (page - 1) * limit;
+
+    const totalResult = this.db
+      .prepare("SELECT COUNT(*) as cnt FROM documents WHERE collection = ?")
+      .get(slug) as { cnt: number };
+    const count = totalResult?.cnt || 0;
+
+    const docs = this.db
+      .prepare(
+        "SELECT data FROM documents WHERE collection = ? ORDER BY created_at DESC LIMIT ? OFFSET ?",
+      )
+      .all(slug, limit, start) as { data: string }[];
+
+    return {
+      docs: docs.map((d) => JSON.parse(d.data) as T),
+      totalDocs: count,
+      totalPages: Math.ceil(count / limit),
+      page,
+    };
+  }
+
+  async findById<T = any>(slug: string, id: string): Promise<T | null> {
+    const doc = this.db
+      .prepare("SELECT data FROM documents WHERE collection = ? AND id = ?")
+      .get(slug, id) as { data: string } | undefined;
+    return doc ? (JSON.parse(doc.data) as T) : null;
+  }
+
+  async create<T = any>(slug: string, data: Partial<T>): Promise<T> {
+    const now = this.getTimestamp();
+    const id = (data as any)?.id || this.generateId();
+    const newDoc = {
+      ...(data as Record<string, unknown>),
+      id,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.db
+      .prepare(
+        "INSERT INTO documents (id, collection, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+      )
+      .run(id, slug, JSON.stringify(newDoc), now, now);
+
+    return newDoc as T;
+  }
+
+  async update<T = any>(
+    slug: string,
+    id: string,
+    data: Partial<T>,
+  ): Promise<T | null> {
+    const existing = await this.findById<T>(slug, id);
+    if (!existing) return null;
+
+    const now = this.getTimestamp();
+    const updated = { ...existing, ...data, id, updatedAt: now };
+
+    this.db
+      .prepare(
+        "UPDATE documents SET data = ?, updated_at = ? WHERE collection = ? AND id = ?",
+      )
+      .run(JSON.stringify(updated), now, slug, id);
+
+    return updated as T;
+  }
+
+  async delete(slug: string, id: string): Promise<boolean> {
+    this.db
+      .prepare("DELETE FROM documents WHERE collection = ? AND id = ?")
+      .run(slug, id);
+    return true;
+  }
+
+  async findGlobal<T = any>(slug: string): Promise<T> {
+    const global = this.db
+      .prepare("SELECT data FROM globals WHERE slug = ?")
+      .get(slug) as { data: string } | undefined;
+    return global ? (JSON.parse(global.data) as T) : ({} as T);
+  }
+
+  async updateGlobal<T = any>(slug: string, data: Partial<T>): Promise<T> {
+    const now = this.getTimestamp();
+    const current = await this.findGlobal<T>(slug);
+    const updated = { ...current, ...data };
+
+    this.db
+      .prepare(
+        "INSERT OR REPLACE INTO globals (slug, data, updated_at) VALUES (?, ?, ?)",
+      )
+      .run(slug, JSON.stringify(updated), now);
+
+    return updated as T;
+  }
+
+  async seedGlobal(slug: string, data: any): Promise<void> {
+    const now = this.getTimestamp();
+    this.db
+      .prepare(
+        "INSERT OR IGNORE INTO globals (slug, data, updated_at) VALUES (?, ?, ?)",
+      )
+      .run(slug, JSON.stringify(data), now);
+  }
+
+  async count(slug: string): Promise<number> {
+    const result = this.db
+      .prepare("SELECT COUNT(*) as cnt FROM documents WHERE collection = ?")
+      .get(slug) as { cnt: number };
+    return result?.cnt || 0;
+  }
+
+  async seed(slug: string, docs: any[]): Promise<void> {
+    const now = this.getTimestamp();
+    const stmt = this.db.prepare(
+      "INSERT INTO documents (id, collection, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+    );
+
+    for (let i = 0; i < docs.length; i++) {
+      const doc = docs[i];
+      const id = doc.id || `${slug}-${i + 1}`;
+      stmt.run(
+        id,
+        slug,
+        JSON.stringify({
+          ...doc,
+          createdAt: doc.createdAt || now,
+          updatedAt: doc.updatedAt || now,
+        }),
+        now,
+        now,
+      );
+    }
+  }
+
+  async isSeeded(slug: string): Promise<boolean> {
+    return (await this.count(slug)) > 0;
+  }
+}
+
+let sqliteContentAdapter: DrizzleSQLiteAdapter | null = null;
+
+export function getSQLiteContentAdapter(
+  config?: DatabaseConfig,
+): DrizzleSQLiteAdapter {
+  if (!sqliteContentAdapter) {
+    sqliteContentAdapter = new DrizzleSQLiteAdapter(config);
+  }
+  return sqliteContentAdapter;
+}