@kyro-cms/admin 0.3.1 → 0.3.4

package/src/lib/db/drizzle-postgres-auth-adapter.ts

@@ -1,304 +0,0 @@
-import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import type { AuthAdapter, AuthUser, Session, UserRole } from "@kyro-cms/core";
-import { eq, and, gt, desc, sql } from "drizzle-orm";
-import bcrypt from "bcryptjs";
-import { randomBytes } from "crypto";
-import postgres from "postgres";
-import { drizzle } from "drizzle-orm/postgres-js";
-import {
-  users,
-  sessions,
-  roles,
-  auditLogs,
-  passwordHistory,
-  lockouts,
-} from "./schema/postgres-auth";
-import type { AuditLog, AuditLogFilter } from "@kyro-cms/core";
-
-export interface PostgresAuthAdapterOptions {
-  db?: PostgresJsDatabase;
-  connectionString?: string;
-  sessionTTL?: number;
-  refreshTokenTTL?: number;
-}
-
-const DEFAULT_SESSION_TTL = 86400;
-const DEFAULT_REFRESH_TTL = 604800;
-
-export class PostgresAuthAdapter implements AuthAdapter {
-  private db: PostgresJsDatabase;
-  private sessionTTL: number;
-  private refreshTTL: number;
-
-  constructor(private options: PostgresAuthAdapterOptions) {
-    if (options.db) {
-      this.db = options.db;
-    } else if (options.connectionString) {
-      const client = postgres(options.connectionString, { max: 10 });
-      this.db = drizzle(client);
-    } else {
-      throw new Error("Either db or connectionString must be provided");
-    }
-    this.sessionTTL = options.sessionTTL || DEFAULT_SESSION_TTL;
-    this.refreshTTL = options.refreshTokenTTL || DEFAULT_REFRESH_TTL;
-  }
-
-  private generateId(): string {
-    return crypto.randomUUID();
-  }
-
-  async createUser(data: {
-    email: string;
-    passwordHash: string;
-    role: UserRole;
-    tenantId?: string;
-  }): Promise<AuthUser> {
-    const now = new Date();
-    const [user] = await this.db
-      .insert(users)
-      .values({
-        email: data.email.toLowerCase(),
-        passwordHash: data.passwordHash,
-        role: data.role,
-        tenantId: data.tenantId,
-      })
-      .returning();
-    return {
-      id: user.id,
-      email: user.email,
-      role: user.role as UserRole,
-      tenantId: user.tenantId || undefined,
-      createdAt: user.createdAt.toISOString(),
-      updatedAt: user.updatedAt.toISOString(),
-    };
-  }
-
-  async findUserByEmail(email: string): Promise<AuthUser | null> {
-    const result = await this.db
-      .select()
-      .from(users)
-      .where(eq(users.email, email.toLowerCase()))
-      .limit(1);
-    const user = result[0];
-    if (!user) return null;
-    return {
-      id: user.id,
-      email: user.email,
-      role: user.role as UserRole,
-      tenantId: user.tenantId || undefined,
-      createdAt: user.createdAt.toISOString(),
-      updatedAt: user.updatedAt.toISOString(),
-    };
-  }
-
-  async findUserById(id: string): Promise<AuthUser | null> {
-    const result = await this.db
-      .select()
-      .from(users)
-      .where(eq(users.id, id))
-      .limit(1);
-    const user = result[0];
-    if (!user) return null;
-    return {
-      id: user.id,
-      email: user.email,
-      role: user.role as UserRole,
-      tenantId: user.tenantId || undefined,
-      createdAt: user.createdAt.toISOString(),
-      updatedAt: user.updatedAt.toISOString(),
-    };
-  }
-
-  async updateUser(
-    id: string,
-    data: Partial<AuthUser>,
-  ): Promise<AuthUser | null> {
-    const updates: Record<string, unknown> = { updatedAt: new Date() };
-    if (data.email) updates.email = data.email.toLowerCase();
-    if (data.role) updates.role = data.role;
-    if (data.passwordHash) updates.passwordHash = data.passwordHash;
-
-    const result = await this.db
-      .update(users)
-      .set(updates)
-      .where(eq(users.id, id))
-      .returning();
-    const user = result[0];
-    if (!user) return null;
-    return {
-      id: user.id,
-      email: user.email,
-      role: user.role as UserRole,
-      tenantId: user.tenantId || undefined,
-      createdAt: user.createdAt.toISOString(),
-      updatedAt: user.updatedAt.toISOString(),
-    };
-  }
-
-  async deleteUser(id: string): Promise<boolean> {
-    await this.db.delete(users).where(eq(users.id, id));
-    return true;
-  }
-
-  async verifyPassword(password: string, hash: string): Promise<boolean> {
-    return bcrypt.compare(password, hash);
-  }
-
-  async hashPassword(password: string): Promise<string> {
-    return bcrypt.hash(password, 10);
-  }
-
-  async createSession(
-    userId: string,
-    data?: { ipAddress?: string; userAgent?: string },
-  ): Promise<Session> {
-    const now = new Date();
-    const expiresAt = new Date(now.getTime() + this.sessionTTL * 1000);
-    const token = randomBytes(32).toString("hex");
-    const refreshToken = randomBytes(32).toString("hex");
-
-    const result = await this.db
-      .insert(sessions)
-      .values({
-        userId,
-        token,
-        refreshToken,
-        expiresAt,
-      })
-      .returning();
-
-    return {
-      id: result[0].id,
-      token: result[0].token,
-      refreshToken: result[0].refreshToken || undefined,
-      userId: result[0].userId,
-      expiresAt: result[0].expiresAt.toISOString(),
-      createdAt: now.toISOString(),
-      ipAddress: data?.ipAddress,
-      userAgent: data?.userAgent,
-    };
-  }
-
-  async findSessionByToken(token: string): Promise<Session | null> {
-    const now = new Date();
-    const result = await this.db
-      .select()
-      .from(sessions)
-      .where(and(eq(sessions.token, token), gt(sessions.expiresAt, now)))
-      .limit(1);
-    const session = result[0];
-    if (!session) return null;
-    return {
-      id: session.id,
-      token: session.token,
-      refreshToken: session.refreshToken || undefined,
-      userId: session.userId,
-      expiresAt: session.expiresAt.toISOString(),
-      createdAt: session.createdAt.toISOString(),
-    };
-  }
-
-  async deleteSession(sessionId: string): Promise<boolean> {
-    await this.db.delete(sessions).where(eq(sessions.token, sessionId));
-    return true;
-  }
-
-  async deleteUserSessions(userId: string): Promise<number> {
-    await this.db.delete(sessions).where(eq(sessions.userId, userId));
-    return 1;
-  }
-
-  async hasAnyUsers(): Promise<boolean> {
-    const result = await this.db
-      .select({ count: sql<number>`count(*)` })
-      .from(users);
-    return Number(result[0]?.count || 0) > 0;
-  }
-
-  async findAuditLogs(
-    filter: AuditLogFilter,
-  ): Promise<{ logs: AuditLog[]; total: number }> {
-    const {
-      limit = 50,
-      offset = 0,
-      userId,
-      action,
-      success,
-      startDate,
-      endDate,
-    } = filter;
-
-    const conditions = [];
-    if (userId) conditions.push(eq(auditLogs.userId, userId));
-    if (action) {
-      if (Array.isArray(action)) {
-        conditions.push(sql`${auditLogs.action} = ANY(${action})`);
-      } else {
-        conditions.push(eq(auditLogs.action, action));
-      }
-    }
-    if (success !== undefined) conditions.push(eq(auditLogs.success, success));
-    if (startDate) conditions.push(sql`${auditLogs.createdAt} >= ${startDate}`);
-    if (endDate) conditions.push(sql`${auditLogs.createdAt} <= ${endDate}`);
-
-    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-
-    const countResult = await this.db
-      .select({ count: sql<number>`count(*)` })
-      .from(auditLogs)
-      .where(whereClause);
-
-    const logs = await this.db
-      .select()
-      .from(auditLogs)
-      .where(whereClause)
-      .orderBy(desc(auditLogs.createdAt))
-      .limit(limit)
-      .offset(offset);
-
-    return {
-      logs: logs.map((log) => ({
-        id: log.id,
-        timestamp: log.createdAt,
-        action: log.action as AuditLog["action"],
-        userId: log.userId || undefined,
-        userEmail: log.userEmail || undefined,
-        role: log.role || undefined,
-        resource: log.resource,
-        ipAddress: log.ipAddress || undefined,
-        userAgent: log.userAgent || undefined,
-        success: log.success,
-        error: log.error || undefined,
-        metadata: log.metadata || undefined,
-      })),
-      total: Number(countResult[0]?.count || 0),
-    };
-  }
-
-  async createAuditLog(
-    data: Omit<AuditLog, "id" | "timestamp">,
-  ): Promise<AuditLog> {
-    const id = this.generateId();
-    const timestamp = new Date();
-
-    await this.db.insert(auditLogs).values({
-      id,
-      action: data.action,
-      userId: data.userId,
-      userEmail: data.userEmail,
-      role: data.role,
-      resource: data.resource,
-      ipAddress: data.ipAddress,
-      userAgent: data.userAgent,
-      success: data.success,
-      error: data.error,
-      metadata: data.metadata,
-    });
-
-    return {
-      ...data,
-      id,
-      timestamp,
-    };
-  }
-}

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

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