role.repository

import { User, Role } from "../schema";
import dbClient from "../db";
import { eq } from "drizzle-orm";
import type { BaseRepository } from "./base.repository";

export class RoleCreationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "RoleCreationError";
  }
}

export class RoleRepository
  implements BaseRepository<typeof Role.$inferSelect>
{
  private db: Awaited<ReturnType<typeof dbClient>>;

  constructor(dbInstance: Awaited<ReturnType<typeof dbClient>>) {
    this.db = dbInstance;
  }

  async findById(id: string) {
    const [role] = await this.db.select().from(Role).where(eq(Role.id, id));
    return role;
  }

  async findByName(name: string) {
    const [role] = await this.db.select().from(Role).where(eq(Role.name, name));
    return role;
  }

  async create(data: typeof Role.$inferInsert) {
    try {
      const [role] = await this.db
        .insert(Role)
        .values(data)
        .onConflictDoUpdate({
          target: [Role.logto_id],
          set: data,
        })
        .returning();

      if (!role) {
        throw new RoleCreationError("Failed to create or update role");
      }

      return role;
    } catch (error) {
      // Handle specific database errors
      if (error instanceof Error) {
        // You can check for specific error types/codes here
        throw new RoleCreationError(`Failed to create role: ${error.message}`);
      }

      // Handle unknown errors
      throw new RoleCreationError(
        "An unexpected error occurred while creating the role"
      );
    }
  }
  async update(id: string, data: Partial<typeof Role.$inferInsert>) {
    const [role] = await this.db
      .update(Role)
      .set(data)
      .where(eq(Role.id, id))
      .returning();
    return role;
  }

  async delete(id: string) {
    await this.db.delete(Role).where(eq(Role.id, id));
  }
}