@rebasepro/server-postgresql 0.1.0 → 0.2.1

package/src/auth/services.ts

@@ -1,6 +1,7 @@
-import { eq, sql } from "drizzle-orm";
+import { eq, getTableName, sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { users, userIdentities, refreshTokens, passwordResetTokens, User, NewUser } from "../schema/auth-schema";
+import { getTableConfig, PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+import { users, roles, userRoles, refreshTokens, passwordResetTokens, userIdentities } from "../schema/auth-schema";
 import {
     UserRepository,
     RoleRepository,
@@ -18,61 +19,224 @@ import {
     RoleData as Role
 // @ts-ignore
 } from "@rebasepro/server-core";
+import { toSnakeCase, camelCase } from "@rebasepro/utils";
 
 export type { Role };
 
+export interface AuthSchemaTables {
+    users: PgTable & Record<string, AnyPgColumn>;
+    roles: PgTable & Record<string, AnyPgColumn>;
+    userRoles: PgTable & Record<string, AnyPgColumn>;
+    refreshTokens: PgTable & Record<string, AnyPgColumn>;
+    passwordResetTokens: PgTable & Record<string, AnyPgColumn>;
+    appConfig: PgTable & Record<string, AnyPgColumn>;
+    userIdentities: PgTable & Record<string, AnyPgColumn>;
+}
+
+function getColumnKey(table: (PgTable & Record<string, AnyPgColumn>) | undefined, ...keys: string[]): string | undefined {
+    if (!table) return undefined;
+    for (const key of keys) {
+        if (key in table) return key;
+        const snake = toSnakeCase(key);
+        if (snake in table) return snake;
+        const camel = camelCase(key);
+        if (camel in table) return camel;
+    }
+    return undefined;
+}
+
+function getColumn(table: (PgTable & Record<string, AnyPgColumn>) | undefined, ...keys: string[]): AnyPgColumn | undefined {
+    if (!table) return undefined;
+    const key = getColumnKey(table, ...keys);
+    return key ? table[key] : undefined;
+}
+
 /**
  * PostgreSQL implementation of UserRepository.
  * Handles all user-related database operations using Drizzle ORM.
  */
 export class UserService implements UserRepository {
-    constructor(private db: NodePgDatabase) { }
+    private usersTable: PgTable & Record<string, AnyPgColumn>;
+    private userIdentitiesTable: PgTable & Record<string, AnyPgColumn>;
+    private userRolesTable: PgTable & Record<string, AnyPgColumn>;
+    private rolesTable: PgTable & Record<string, AnyPgColumn>;
+
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        if (tableOrTables && ((tableOrTables as Partial<AuthSchemaTables>).users || (tableOrTables as Partial<AuthSchemaTables>).roles)) {
+            const tables = tableOrTables as Partial<AuthSchemaTables>;
+            this.usersTable = (tables.users || users) as unknown as PgTable & Record<string, AnyPgColumn>;
+            this.userIdentitiesTable = (tables.userIdentities || userIdentities) as unknown as PgTable & Record<string, AnyPgColumn>;
+            this.userRolesTable = (tables.userRoles || userRoles) as unknown as PgTable & Record<string, AnyPgColumn>;
+            this.rolesTable = (tables.roles || roles) as unknown as PgTable & Record<string, AnyPgColumn>;
+        } else {
+            const table = tableOrTables as (PgTable & Record<string, AnyPgColumn>) | undefined;
+            this.usersTable = table || (users as unknown as PgTable & Record<string, AnyPgColumn>);
+            this.userIdentitiesTable = userIdentities as unknown as PgTable & Record<string, AnyPgColumn>;
+            this.userRolesTable = userRoles as unknown as PgTable & Record<string, AnyPgColumn>;
+            this.rolesTable = roles as unknown as PgTable & Record<string, AnyPgColumn>;
+        }
+    }
+
+    private getQualifiedUsersTableName(): string {
+        const name = getTableName(this.usersTable);
+        const schema = getTableConfig(this.usersTable).schema || "public";
+        return `"${schema}"."${name}"`;
+    }
+
+    private mapRowToUser(row: Record<string, unknown>): UserData {
+        if (!row) return row as unknown as UserData;
+
+        const id = (row.id ?? row.uid) as string;
+        const email = row.email as string;
+        const passwordHash = (row.password_hash ?? row.passwordHash ?? null) as string | null | undefined;
+        const displayName = (row.display_name ?? row.displayName ?? null) as string | null | undefined;
+        const photoUrl = (row.photo_url ?? row.photoUrl ?? row.photoURL ?? null) as string | null | undefined;
+        const emailVerified = (row.email_verified ?? row.emailVerified ?? false) as boolean;
+        const emailVerificationToken = (row.email_verification_token ?? row.emailVerificationToken ?? null) as string | null | undefined;
+        const emailVerificationSentAt = (row.email_verification_sent_at ?? row.emailVerificationSentAt ?? null) as string | number | Date | null;
+        const createdAt = (row.created_at ?? row.createdAt) as string | number | Date | undefined;
+        const updatedAt = (row.updated_at ?? row.updatedAt) as string | number | Date | undefined;
+
+        const metadata: Record<string, any> = { ...((row.metadata as Record<string, any> | undefined) || {}) };
+
+        const knownKeys = new Set([
+            "id", "uid", "email",
+            "password_hash", "passwordHash",
+            "display_name", "displayName",
+            "photo_url", "photoUrl", "photoURL",
+            "email_verified", "emailVerified",
+            "email_verification_token", "emailVerificationToken",
+            "email_verification_sent_at", "emailVerificationSentAt",
+            "created_at", "createdAt",
+            "updated_at", "updatedAt",
+            "metadata"
+        ]);
+
+        for (const [key, val] of Object.entries(row)) {
+            if (!knownKeys.has(key)) {
+                const camelKey = camelCase(key);
+                metadata[camelKey] = val;
+            }
+        }
 
-    async createUser(data: NewUser): Promise<User> {
-        const [user] = await this.db.insert(users).values(data).returning();
-        return user;
+        return {
+            id,
+            email,
+            passwordHash,
+            displayName,
+            photoUrl,
+            emailVerified,
+            emailVerificationToken,
+            emailVerificationSentAt: emailVerificationSentAt ? new Date(emailVerificationSentAt) : null,
+            createdAt: createdAt ? new Date(createdAt) : new Date(),
+            updatedAt: updatedAt ? new Date(updatedAt) : new Date(),
+            metadata
+        };
     }
 
-    async getUserById(id: string): Promise<User | null> {
-        const [user] = await this.db.select().from(users).where(eq(users.id, id));
-        return user || null;
+    private mapPayload(data: Partial<CreateUserData>): Record<string, unknown> {
+        if (!data) return {};
+
+        const payload: Record<string, unknown> = {};
+
+        const idKey = getColumnKey(this.usersTable, "id") || "id";
+        const emailKey = getColumnKey(this.usersTable, "email") || "email";
+        const passwordHashKey = getColumnKey(this.usersTable, "passwordHash", "password_hash") || "passwordHash";
+        const displayNameKey = getColumnKey(this.usersTable, "displayName", "display_name") || "displayName";
+        const photoUrlKey = getColumnKey(this.usersTable, "photoUrl", "photo_url") || "photoUrl";
+        const emailVerifiedKey = getColumnKey(this.usersTable, "emailVerified", "email_verified") || "emailVerified";
+        const emailVerificationTokenKey = getColumnKey(this.usersTable, "emailVerificationToken", "email_verification_token") || "emailVerificationToken";
+        const emailVerificationSentAtKey = getColumnKey(this.usersTable, "emailVerificationSentAt", "email_verification_sent_at") || "emailVerificationSentAt";
+        const createdAtKey = getColumnKey(this.usersTable, "createdAt", "created_at") || "createdAt";
+        const updatedAtKey = getColumnKey(this.usersTable, "updatedAt", "updated_at") || "updatedAt";
+        const metadataKey = getColumnKey(this.usersTable, "metadata") || "metadata";
+
+        if ("id" in data) payload[idKey] = data.id;
+        if ("email" in data) payload[emailKey] = data.email;
+        if ("passwordHash" in data) payload[passwordHashKey] = data.passwordHash;
+        if ("displayName" in data) payload[displayNameKey] = data.displayName;
+        if ("photoUrl" in data) payload[photoUrlKey] = data.photoUrl;
+        if ("emailVerified" in data) payload[emailVerifiedKey] = data.emailVerified;
+        if ("emailVerificationToken" in data) payload[emailVerificationTokenKey] = data.emailVerificationToken;
+        if ("emailVerificationSentAt" in data) payload[emailVerificationSentAtKey] = data.emailVerificationSentAt;
+        if ("createdAt" in data) payload[createdAtKey] = data.createdAt;
+        if ("updatedAt" in data) payload[updatedAtKey] = data.updatedAt;
+
+        const metadata: Record<string, any> = { ...(data.metadata || {}) };
+        const remainingMetadata: Record<string, any> = {};
+
+        for (const [key, val] of Object.entries(metadata)) {
+            const tableColKey = getColumnKey(this.usersTable, key);
+            if (tableColKey && 
+                tableColKey !== idKey && 
+                tableColKey !== emailKey && 
+                tableColKey !== passwordHashKey && 
+                tableColKey !== displayNameKey && 
+                tableColKey !== photoUrlKey && 
+                tableColKey !== emailVerifiedKey && 
+                tableColKey !== emailVerificationTokenKey && 
+                tableColKey !== emailVerificationSentAtKey && 
+                tableColKey !== createdAtKey && 
+                tableColKey !== updatedAtKey && 
+                tableColKey !== metadataKey) {
+                payload[tableColKey] = val;
+            } else {
+                remainingMetadata[key] = val;
+            }
+        }
+
+        if (metadataKey in this.usersTable) {
+            payload[metadataKey] = remainingMetadata;
+        }
+
+        return payload;
     }
 
-    async getUserByEmail(email: string): Promise<User | null> {
-        const [user] = await this.db.select().from(users).where(eq(users.email, email.toLowerCase()));
-        return user || null;
+    async createUser(data: CreateUserData): Promise<UserData> {
+        const payload = this.mapPayload(data);
+        const [row] = (await this.db.insert(this.usersTable).values(payload).returning()) as Record<string, unknown>[];
+        return this.mapRowToUser(row);
     }
 
-    async getUserByIdentity(provider: string, providerId: string): Promise<User | null> {
-        const result = await this.db.execute(sql`
-            SELECT u.*
-            FROM rebase.users u
-            INNER JOIN rebase.user_identities ui ON u.id = ui.user_id
-            WHERE ui.provider = ${provider} AND ui.provider_id = ${providerId}
-            LIMIT 1
-        `);
+    async getUserById(id: string): Promise<UserData | null> {
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return null;
+        const [row] = await this.db.select().from(this.usersTable).where(eq(idCol, id));
+        return row ? this.mapRowToUser(row as Record<string, unknown>) : null;
+    }
 
-        if (result.rows.length === 0) return null;
+    async getUserByEmail(email: string): Promise<UserData | null> {
+        const emailCol = getColumn(this.usersTable, "email");
+        if (!emailCol) return null;
+        const [row] = await this.db.select().from(this.usersTable).where(eq(emailCol, email.toLowerCase()));
+        return row ? this.mapRowToUser(row as Record<string, unknown>) : null;
+    }
 
-        const row = result.rows[0] as Record<string, unknown>;
-        return {
-            id: row.id as string,
-            email: row.email as string,
-            passwordHash: (row.password_hash as string | null) ?? null,
-            displayName: (row.display_name as string | null) ?? null,
-            photoUrl: (row.photo_url as string | null) ?? null,
-            emailVerified: (row.email_verified as boolean | undefined) ?? false,
-            emailVerificationToken: (row.email_verification_token as string | null) ?? null,
-            emailVerificationSentAt: (row.email_verification_sent_at as Date | null) ?? null,
-            createdAt: row.created_at as Date,
-            updatedAt: row.updated_at as Date
-        } as User;
+    async getUserByIdentity(provider: string, providerId: string): Promise<UserData | null> {
+        const userIdCol = getColumn(this.usersTable, "id");
+        if (!userIdCol) return null;
+        
+        const result = await this.db
+            .select({ user: this.usersTable })
+            .from(this.usersTable)
+            .innerJoin(this.userIdentitiesTable, eq(userIdCol, this.userIdentitiesTable.userId))
+            .where(
+                sql`${this.userIdentitiesTable.provider} = ${provider} AND ${this.userIdentitiesTable.providerId} = ${providerId}`
+            )
+            .limit(1);
+
+        if (result.length === 0) return null;
+        return this.mapRowToUser(result[0].user as Record<string, unknown>);
     }
 
     async getUserIdentities(userId: string): Promise<UserIdentityData[]> {
+        const schema = getTableConfig(this.userIdentitiesTable).schema || "public";
         const result = await this.db.execute(sql`
             SELECT id, user_id, provider, provider_id, profile_data, created_at, updated_at
-            FROM rebase.user_identities
+            FROM ${sql.raw(`"${schema}"."user_identities"`)}
             WHERE user_id = ${userId}
         `);
 
@@ -88,30 +252,38 @@ export class UserService implements UserRepository {
     }
 
     async linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void> {
-        await this.db.insert(userIdentities).values({
+        await this.db.insert(this.userIdentitiesTable).values({
             userId,
             provider,
             providerId,
             profileData: profileData || null
-        }).onConflictDoNothing({ target: [userIdentities.provider, userIdentities.providerId] });
+        }).onConflictDoNothing({ target: [this.userIdentitiesTable.provider, this.userIdentitiesTable.providerId] });
     }
 
-    async updateUser(id: string, data: Partial<Omit<NewUser, "id">>): Promise<User | null> {
-        const [user] = await this.db
-            .update(users)
-            .set({ ...data,
-updatedAt: new Date() })
-            .where(eq(users.id, id))
-            .returning();
-        return user || null;
+    async updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null> {
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return null;
+        const payload = this.mapPayload(data);
+        const updatedAtKey = getColumnKey(this.usersTable, "updatedAt", "updated_at") || "updatedAt";
+        payload[updatedAtKey] = new Date();
+
+        const [row] = (await this.db
+            .update(this.usersTable)
+            .set(payload)
+            .where(eq(idCol, id))
+            .returning()) as Record<string, unknown>[];
+        return row ? this.mapRowToUser(row) : null;
     }
 
     async deleteUser(id: string): Promise<void> {
-        await this.db.delete(users).where(eq(users.id, id));
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return;
+        await this.db.delete(this.usersTable).where(eq(idCol, id));
     }
 
-    async listUsers(): Promise<User[]> {
-        return this.db.select().from(users);
+    async listUsers(): Promise<UserData[]> {
+        const rows = await this.db.select().from(this.usersTable);
+        return (rows as Record<string, unknown>[]).map(row => this.mapRowToUser(row));
     }
 
     async listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult> {
@@ -122,125 +294,139 @@ updatedAt: new Date() })
         const orderDir = options?.orderDir || "desc";
         const roleId = options?.roleId;
 
-        // Map camelCase field names to snake_case column names
-        const columnMap: Record<string, string> = {
-            email: "email",
-            displayName: "display_name",
-            createdAt: "created_at",
-            updatedAt: "updated_at",
-            provider: "provider"
-        };
-        const orderColumn = columnMap[orderBy] || "created_at";
+        const orderCol = getColumn(this.usersTable, orderBy);
+        const orderColumn = orderCol ? orderCol.name : "created_at";
         const direction = orderDir === "asc" ? sql`ASC` : sql`DESC`;
 
+        const emailCol = getColumn(this.usersTable, "email");
+        const emailColumn = emailCol ? emailCol.name : "email";
+        const displayNameCol = getColumn(this.usersTable, "displayName", "display_name");
+        const displayNameColumn = displayNameCol ? displayNameCol.name : "display_name";
+        const idCol = getColumn(this.usersTable, "id");
+        const idColumn = idCol ? idCol.name : "id";
+
+        const usersTableName = this.getQualifiedUsersTableName();
+        const rolesSchema = getTableConfig(this.userRolesTable).schema || "public";
+
         const conditions = [];
         if (roleId) {
-            conditions.push(sql`EXISTS (SELECT 1 FROM rebase.user_roles ur WHERE ur.user_id = users.id AND ur.role_id = ${roleId})`);
+            conditions.push(sql`EXISTS (SELECT 1 FROM ${sql.raw(`"${rolesSchema}"."user_roles"`)} ur WHERE ur.user_id = ${sql.raw(usersTableName)}.${sql.raw(idColumn)} AND ur.role_id = ${roleId})`);
         }
         if (search) {
             const pattern = `%${search}%`;
-            conditions.push(sql`(email ILIKE ${pattern} OR display_name ILIKE ${pattern})`);
+            conditions.push(sql`(${sql.raw(usersTableName)}.${sql.raw(emailColumn)} ILIKE ${pattern} OR ${sql.raw(usersTableName)}.${sql.raw(displayNameColumn)} ILIKE ${pattern})`);
         }
 
         const whereClause = conditions.length > 0 ? sql`WHERE ${sql.join(conditions, sql` AND `)}` : sql``;
 
         // Sorting: users with roles first if no role filter, then by requested order
         const orderByClause = roleId
-            ? sql`ORDER BY ${sql.raw(orderColumn)} ${direction}`
-            : sql`ORDER BY (SELECT count(*) FROM rebase.user_roles ur WHERE ur.user_id = users.id) DESC, ${sql.raw(orderColumn)} ${direction}`;
+            ? sql`ORDER BY ${sql.raw(usersTableName)}.${sql.raw(orderColumn)} ${direction}`
+            : sql`ORDER BY (SELECT count(*) FROM ${sql.raw(`"${rolesSchema}"."user_roles"`)} ur WHERE ur.user_id = ${sql.raw(usersTableName)}.${sql.raw(idColumn)}) DESC, ${sql.raw(usersTableName)}.${sql.raw(orderColumn)} ${direction}`;
 
         const countResult = await this.db.execute(sql`
-            SELECT count(*)::int as total FROM rebase.users
+            SELECT count(*)::int as total FROM ${sql.raw(usersTableName)}
             ${whereClause}
         `);
         const total = (countResult.rows[0] as { total: number }).total;
 
         const dataResult = await this.db.execute(sql`
-            SELECT * FROM rebase.users
+            SELECT * FROM ${sql.raw(usersTableName)}
             ${whereClause}
             ${orderByClause}
             LIMIT ${limit} OFFSET ${offset}
         `);
-        const rows = dataResult.rows as User[];
+        const rows = dataResult.rows;
 
-        // Map snake_case rows to camelCase UserData
-        const mappedUsers: User[] = rows.map((row: Record<string, unknown>) => ({
-            id: row.id as string,
-            email: row.email as string,
-            passwordHash: ((row.password_hash ?? row.passwordHash) as string | null) ?? null,
-            displayName: ((row.display_name ?? row.displayName) as string | null) ?? null,
-            photoUrl: ((row.photo_url ?? row.photoUrl) as string | null) ?? null,
-            emailVerified: ((row.email_verified ?? row.emailVerified) as boolean | undefined) ?? false,
-            emailVerificationToken: ((row.email_verification_token ?? row.emailVerificationToken) as string | null) ?? null,
-            emailVerificationSentAt: ((row.email_verification_sent_at ?? row.emailVerificationSentAt) as Date | null) ?? null,
-            createdAt: (row.created_at ?? row.createdAt) as Date,
-            updatedAt: (row.updated_at ?? row.updatedAt) as Date
-        })) as User[];
+        // Map rows to camelCase UserData
+        const mappedUsers: UserData[] = (rows as Record<string, unknown>[]).map((row) => this.mapRowToUser(row));
 
         return { users: mappedUsers,
-total,
-limit,
-offset };
+            total,
+            limit,
+            offset };
     }
 
     /**
      * Update user's password hash
      */
     async updatePassword(id: string, passwordHash: string): Promise<void> {
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return;
+        const passwordHashColKey = getColumnKey(this.usersTable, "passwordHash", "password_hash") || "passwordHash";
+        const updatedAtColKey = getColumnKey(this.usersTable, "updatedAt", "updated_at") || "updatedAt";
+
         await this.db
-            .update(users)
-            .set({ passwordHash,
-updatedAt: new Date() })
-            .where(eq(users.id, id));
+            .update(this.usersTable)
+            .set({
+                [passwordHashColKey]: passwordHash,
+                [updatedAtColKey]: new Date()
+            })
+            .where(eq(idCol, id));
     }
 
     /**
      * Set email verification status
      */
     async setEmailVerified(id: string, verified: boolean): Promise<void> {
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return;
+        const emailVerifiedColKey = getColumnKey(this.usersTable, "emailVerified", "email_verified") || "emailVerified";
+        const emailVerificationTokenColKey = getColumnKey(this.usersTable, "emailVerificationToken", "email_verification_token") || "emailVerificationToken";
+        const updatedAtColKey = getColumnKey(this.usersTable, "updatedAt", "updated_at") || "updatedAt";
+
         await this.db
-            .update(users)
+            .update(this.usersTable)
             .set({
-                emailVerified: verified,
-                emailVerificationToken: null,
-                updatedAt: new Date()
+                [emailVerifiedColKey]: verified,
+                [emailVerificationTokenColKey]: null,
+                [updatedAtColKey]: new Date()
             })
-            .where(eq(users.id, id));
+            .where(eq(idCol, id));
     }
 
     /**
      * Set email verification token
      */
     async setVerificationToken(id: string, token: string | null): Promise<void> {
+        const idCol = getColumn(this.usersTable, "id");
+        if (!idCol) return;
+        const emailVerificationTokenColKey = getColumnKey(this.usersTable, "emailVerificationToken", "email_verification_token") || "emailVerificationToken";
+        const emailVerificationSentAtColKey = getColumnKey(this.usersTable, "emailVerificationSentAt", "email_verification_sent_at") || "emailVerificationSentAt";
+        const updatedAtColKey = getColumnKey(this.usersTable, "updatedAt", "updated_at") || "updatedAt";
+
         await this.db
-            .update(users)
+            .update(this.usersTable)
             .set({
-                emailVerificationToken: token,
-                emailVerificationSentAt: token ? new Date() : null,
-                updatedAt: new Date()
+                [emailVerificationTokenColKey]: token,
+                [emailVerificationSentAtColKey]: token ? new Date() : null,
+                [updatedAtColKey]: new Date()
             })
-            .where(eq(users.id, id));
+            .where(eq(idCol, id));
     }
 
     /**
      * Find user by email verification token
      */
-    async getUserByVerificationToken(token: string): Promise<User | null> {
-        const [user] = await this.db
+    async getUserByVerificationToken(token: string): Promise<UserData | null> {
+        const tokenCol = getColumn(this.usersTable, "emailVerificationToken", "email_verification_token");
+        if (!tokenCol) return null;
+        const [row] = await this.db
             .select()
-            .from(users)
-            .where(eq(users.emailVerificationToken, token));
-        return user || null;
+            .from(this.usersTable)
+            .where(eq(tokenCol, token));
+        return row ? this.mapRowToUser(row as Record<string, unknown>) : null;
     }
 
     /**
      * Get roles for a user from database
      */
     async getUserRoles(userId: string): Promise<Role[]> {
+        const rolesSchema = getTableConfig(this.rolesTable).schema || "public";
         const result = await this.db.execute(sql`
             SELECT r.id, r.name, r.is_admin, r.default_permissions, r.collection_permissions, r.config
-            FROM rebase.roles r
-            INNER JOIN rebase.user_roles ur ON r.id = ur.role_id
+            FROM ${sql.raw(`"${rolesSchema}"."roles"`)} r
+            INNER JOIN ${sql.raw(`"${rolesSchema}"."user_roles"`)} ur ON r.id = ur.role_id
             WHERE ur.user_id = ${userId}
         `);
 
@@ -266,13 +452,14 @@ updatedAt: new Date() })
      * Set roles for a user
      */
     async setUserRoles(userId: string, roleIds: string[]): Promise<void> {
+        const rolesSchema = getTableConfig(this.userRolesTable).schema || "public";
         // Delete existing roles
-        await this.db.execute(sql`DELETE FROM rebase.user_roles WHERE user_id = ${userId}`);
+        await this.db.execute(sql`DELETE FROM ${sql.raw(`"${rolesSchema}"."user_roles"`)} WHERE user_id = ${userId}`);
 
         // Insert new roles
         for (const roleId of roleIds) {
             await this.db.execute(sql`
-                INSERT INTO rebase.user_roles (user_id, role_id)
+                INSERT INTO ${sql.raw(`"${rolesSchema}"."user_roles"`)} (user_id, role_id)
                 VALUES (${userId}, ${roleId})
                 ON CONFLICT DO NOTHING
             `);
@@ -283,8 +470,9 @@ updatedAt: new Date() })
      * Assign a specific role to new user
      */
     async assignDefaultRole(userId: string, roleId: string): Promise<void> {
+        const rolesSchema = getTableConfig(this.userRolesTable).schema || "public";
         await this.db.execute(sql`
-            INSERT INTO rebase.user_roles (user_id, role_id)
+            INSERT INTO ${sql.raw(`"${rolesSchema}"."user_roles"`)} (user_id, role_id)
             VALUES (${userId}, ${roleId})
             ON CONFLICT DO NOTHING
         `);
@@ -293,13 +481,13 @@ updatedAt: new Date() })
     /**
      * Get user with their roles
      */
-    async getUserWithRoles(userId: string): Promise<{ user: User; roles: Role[] } | null> {
+    async getUserWithRoles(userId: string): Promise<{ user: UserData; roles: Role[] } | null> {
         const user = await this.getUserById(userId);
         if (!user) return null;
 
         const roles = await this.getUserRoles(userId);
         return { user,
-roles };
+            roles };
     }
 }
 
@@ -308,12 +496,30 @@ roles };
  * Handles all role-related database operations using Drizzle ORM.
  */
 export class RoleService implements RoleRepository {
-    constructor(private db: NodePgDatabase) { }
+    private rolesTable: PgTable & Record<string, AnyPgColumn>;
+
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        if (tableOrTables && ((tableOrTables as Partial<AuthSchemaTables>).roles || (tableOrTables as Partial<AuthSchemaTables>).users)) {
+            this.rolesTable = ((tableOrTables as Partial<AuthSchemaTables>).roles || roles) as unknown as PgTable & Record<string, AnyPgColumn>;
+        } else {
+            this.rolesTable = (tableOrTables as unknown as PgTable & Record<string, AnyPgColumn>) || (roles as unknown as PgTable & Record<string, AnyPgColumn>);
+        }
+    }
+
+    private getQualifiedRolesTableName(): string {
+        const name = getTableName(this.rolesTable);
+        const schema = getTableConfig(this.rolesTable).schema || "public";
+        return `"${schema}"."${name}"`;
+    }
 
     async getRoleById(id: string): Promise<Role | null> {
+        const tableName = this.getQualifiedRolesTableName();
         const result = await this.db.execute(sql`
             SELECT id, name, is_admin, default_permissions, collection_permissions, config
-            FROM rebase.roles
+            FROM ${sql.raw(tableName)}
             WHERE id = ${id}
         `);
 
@@ -331,9 +537,10 @@ export class RoleService implements RoleRepository {
     }
 
     async listRoles(): Promise<Role[]> {
+        const tableName = this.getQualifiedRolesTableName();
         const result = await this.db.execute(sql`
             SELECT id, name, is_admin, default_permissions, collection_permissions, config
-            FROM rebase.roles
+            FROM ${sql.raw(tableName)}
             ORDER BY name
         `);
 
@@ -348,8 +555,9 @@ export class RoleService implements RoleRepository {
     }
 
     async createRole(data: Omit<Role, "isAdmin" | "collectionPermissions"> & { isAdmin?: boolean; collectionPermissions?: Role["collectionPermissions"] }): Promise<Role> {
+        const tableName = this.getQualifiedRolesTableName();
         const result = await this.db.execute(sql`
-            INSERT INTO rebase.roles (id, name, is_admin, default_permissions, collection_permissions, config)
+            INSERT INTO ${sql.raw(tableName)} (id, name, is_admin, default_permissions, collection_permissions, config)
             VALUES (
                 ${data.id},
                 ${data.name},
@@ -373,12 +581,12 @@ export class RoleService implements RoleRepository {
     }
 
     async updateRole(id: string, data: Partial<Omit<Role, "id">>): Promise<Role | null> {
-        // For now, use simpler approach
         const existing = await this.getRoleById(id);
         if (!existing) return null;
 
+        const tableName = this.getQualifiedRolesTableName();
         await this.db.execute(sql`
-            UPDATE rebase.roles 
+            UPDATE ${sql.raw(tableName)}
             SET 
                 name = ${data.name ?? existing.name},
                 is_admin = ${data.isAdmin ?? existing.isAdmin},
@@ -392,12 +600,30 @@ export class RoleService implements RoleRepository {
     }
 
     async deleteRole(id: string): Promise<void> {
-        await this.db.execute(sql`DELETE FROM rebase.roles WHERE id = ${id}`);
+        const tableName = this.getQualifiedRolesTableName();
+        await this.db.execute(sql`DELETE FROM ${sql.raw(tableName)} WHERE id = ${id}`);
     }
 }
 
 export class RefreshTokenService {
-    constructor(private db: NodePgDatabase) { }
+    private refreshTokensTable: PgTable & Record<string, AnyPgColumn>;
+
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        if (tableOrTables && ((tableOrTables as Partial<AuthSchemaTables>).refreshTokens || (tableOrTables as Partial<AuthSchemaTables>).users)) {
+            this.refreshTokensTable = ((tableOrTables as Partial<AuthSchemaTables>).refreshTokens || refreshTokens) as unknown as PgTable & Record<string, AnyPgColumn>;
+        } else {
+            this.refreshTokensTable = (tableOrTables as unknown as PgTable & Record<string, AnyPgColumn>) || (refreshTokens as unknown as PgTable & Record<string, AnyPgColumn>);
+        }
+    }
+
+    private getQualifiedRefreshTokensTableName(): string {
+        const name = getTableName(this.refreshTokensTable);
+        const schema = getTableConfig(this.refreshTokensTable).schema || "public";
+        return `"${schema}"."${name}"`;
+    }
 
     async createToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void> {
         // Fallback to empty string because UNIQUE constraints treat NULLs as strictly distinct in standard Postgres.
@@ -407,14 +633,15 @@ export class RefreshTokenService {
 
         // Delete any existing session for this user/device combo, then insert.
         // This approach doesn't require the unique_device_session constraint to exist.
+        const tableName = this.getQualifiedRefreshTokensTableName();
         await this.db.execute(sql`
-            DELETE FROM rebase.refresh_tokens 
+            DELETE FROM ${sql.raw(tableName)} 
             WHERE user_id = ${userId} 
             AND user_agent = ${safeUserAgent} 
             AND ip_address = ${safeIpAddress}
         `);
 
-        await this.db.insert(refreshTokens)
+        await this.db.insert(this.refreshTokensTable)
             .values({
                 userId,
                 tokenHash,
@@ -427,49 +654,49 @@ export class RefreshTokenService {
     async findByHash(tokenHash: string): Promise<RefreshTokenInfo | null> {
         const [token] = await this.db
             .select({
-                id: refreshTokens.id,
-                userId: refreshTokens.userId,
-                tokenHash: refreshTokens.tokenHash,
-                expiresAt: refreshTokens.expiresAt,
-                createdAt: refreshTokens.createdAt,
-                userAgent: refreshTokens.userAgent,
-                ipAddress: refreshTokens.ipAddress
+                id: this.refreshTokensTable.id,
+                userId: this.refreshTokensTable.userId,
+                tokenHash: this.refreshTokensTable.tokenHash,
+                expiresAt: this.refreshTokensTable.expiresAt,
+                createdAt: this.refreshTokensTable.createdAt,
+                userAgent: this.refreshTokensTable.userAgent,
+                ipAddress: this.refreshTokensTable.ipAddress
             })
-            .from(refreshTokens)
-            .where(eq(refreshTokens.tokenHash, tokenHash));
+            .from(this.refreshTokensTable)
+            .where(eq(this.refreshTokensTable.tokenHash, tokenHash));
 
-        return token || null;
+        return (token as RefreshTokenInfo) || null;
     }
 
     async deleteByHash(tokenHash: string): Promise<void> {
-        await this.db.delete(refreshTokens).where(eq(refreshTokens.tokenHash, tokenHash));
+        await this.db.delete(this.refreshTokensTable).where(eq(this.refreshTokensTable.tokenHash, tokenHash));
     }
 
     async deleteAllForUser(userId: string): Promise<void> {
-        await this.db.delete(refreshTokens).where(eq(refreshTokens.userId, userId));
+        await this.db.delete(this.refreshTokensTable).where(eq(this.refreshTokensTable.userId, userId));
     }
 
     async listForUser(userId: string): Promise<RefreshTokenInfo[]> {
         const tokens = await this.db
             .select({
-                id: refreshTokens.id,
-                userId: refreshTokens.userId,
-                tokenHash: refreshTokens.tokenHash,
-                expiresAt: refreshTokens.expiresAt,
-                createdAt: refreshTokens.createdAt,
-                userAgent: refreshTokens.userAgent,
-                ipAddress: refreshTokens.ipAddress
+                id: this.refreshTokensTable.id,
+                userId: this.refreshTokensTable.userId,
+                tokenHash: this.refreshTokensTable.tokenHash,
+                expiresAt: this.refreshTokensTable.expiresAt,
+                createdAt: this.refreshTokensTable.createdAt,
+                userAgent: this.refreshTokensTable.userAgent,
+                ipAddress: this.refreshTokensTable.ipAddress
             })
-            .from(refreshTokens)
-            .where(eq(refreshTokens.userId, userId))
-            .orderBy(refreshTokens.createdAt);
+            .from(this.refreshTokensTable)
+            .where(eq(this.refreshTokensTable.userId, userId))
+            .orderBy(this.refreshTokensTable.createdAt);
 
-        return tokens;
+        return tokens as RefreshTokenInfo[];
     }
 
     async deleteById(id: string, userId: string): Promise<void> {
-        await this.db.delete(refreshTokens)
-            .where(sql`${refreshTokens.id} = ${id} AND ${refreshTokens.userId} = ${userId}`);
+        await this.db.delete(this.refreshTokensTable)
+            .where(sql`${this.refreshTokensTable.id} = ${id} AND ${this.refreshTokensTable.userId} = ${userId}`);
     }
 }
 
@@ -477,19 +704,37 @@ export class RefreshTokenService {
  * Password reset token service
  */
 export class PasswordResetTokenService {
-    constructor(private db: NodePgDatabase) { }
+    private passwordResetTokensTable: PgTable & Record<string, AnyPgColumn>;
+
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        if (tableOrTables && ((tableOrTables as Partial<AuthSchemaTables>).passwordResetTokens || (tableOrTables as Partial<AuthSchemaTables>).users)) {
+            this.passwordResetTokensTable = ((tableOrTables as Partial<AuthSchemaTables>).passwordResetTokens || passwordResetTokens) as unknown as PgTable & Record<string, AnyPgColumn>;
+        } else {
+            this.passwordResetTokensTable = (tableOrTables as unknown as PgTable & Record<string, AnyPgColumn>) || (passwordResetTokens as unknown as PgTable & Record<string, AnyPgColumn>);
+        }
+    }
+
+    private getQualifiedPasswordResetTokensTableName(): string {
+        const name = getTableName(this.passwordResetTokensTable);
+        const schema = getTableConfig(this.passwordResetTokensTable).schema || "public";
+        return `"${schema}"."${name}"`;
+    }
 
     /**
      * Create a password reset token
      */
     async createToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void> {
         // Delete any existing unused tokens for this user
+        const tableName = this.getQualifiedPasswordResetTokensTableName();
         await this.db.execute(sql`
-            DELETE FROM rebase.password_reset_tokens 
+            DELETE FROM ${sql.raw(tableName)} 
             WHERE user_id = ${userId} AND used_at IS NULL
         `);
 
-        await this.db.insert(passwordResetTokens).values({
+        await this.db.insert(this.passwordResetTokensTable).values({
             userId,
             tokenHash,
             expiresAt
@@ -502,18 +747,19 @@ export class PasswordResetTokenService {
     async findValidByHash(tokenHash: string): Promise<{ userId: string; expiresAt: Date } | null> {
         const [token] = await this.db
             .select({
-                userId: passwordResetTokens.userId,
-                expiresAt: passwordResetTokens.expiresAt
+                userId: this.passwordResetTokensTable.userId,
+                expiresAt: this.passwordResetTokensTable.expiresAt
             })
-            .from(passwordResetTokens)
-            .where(eq(passwordResetTokens.tokenHash, tokenHash));
+            .from(this.passwordResetTokensTable)
+            .where(eq(this.passwordResetTokensTable.tokenHash, tokenHash)) as unknown as Array<{ userId: string; expiresAt: Date }>;
 
         if (!token) return null;
 
         // Check if expired or used
+        const tableName = this.getQualifiedPasswordResetTokensTableName();
         const result = await this.db.execute(sql`
             SELECT user_id, expires_at 
-            FROM rebase.password_reset_tokens 
+            FROM ${sql.raw(tableName)} 
             WHERE token_hash = ${tokenHash} 
               AND used_at IS NULL 
               AND expires_at > NOW()
@@ -533,24 +779,25 @@ export class PasswordResetTokenService {
      */
     async markAsUsed(tokenHash: string): Promise<void> {
         await this.db
-            .update(passwordResetTokens)
+            .update(this.passwordResetTokensTable)
             .set({ usedAt: new Date() })
-            .where(eq(passwordResetTokens.tokenHash, tokenHash));
+            .where(eq(this.passwordResetTokensTable.tokenHash, tokenHash));
     }
 
     /**
      * Delete all tokens for a user
      */
     async deleteAllForUser(userId: string): Promise<void> {
-        await this.db.delete(passwordResetTokens).where(eq(passwordResetTokens.userId, userId));
+        await this.db.delete(this.passwordResetTokensTable).where(eq(this.passwordResetTokensTable.userId, userId));
     }
 
     /**
      * Clean up expired tokens
      */
     async deleteExpired(): Promise<void> {
+        const tableName = this.getQualifiedPasswordResetTokensTableName();
         await this.db.execute(sql`
-            DELETE FROM rebase.password_reset_tokens 
+            DELETE FROM ${sql.raw(tableName)} 
             WHERE expires_at < NOW()
         `);
     }
@@ -564,9 +811,12 @@ export class PostgresTokenRepository implements TokenRepository {
     private refreshTokenService: RefreshTokenService;
     private passwordResetTokenService: PasswordResetTokenService;
 
-    constructor(private db: NodePgDatabase) {
-        this.refreshTokenService = new RefreshTokenService(db);
-        this.passwordResetTokenService = new PasswordResetTokenService(db);
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        this.refreshTokenService = new RefreshTokenService(db, tableOrTables);
+        this.passwordResetTokenService = new PasswordResetTokenService(db, tableOrTables);
     }
 
     // Refresh token operations
@@ -628,28 +878,31 @@ export class PostgresAuthRepository implements AuthRepository {
     private roleService: RoleService;
     private tokenRepository: PostgresTokenRepository;
 
-    constructor(private db: NodePgDatabase) {
-        this.userService = new UserService(db);
-        this.roleService = new RoleService(db);
-        this.tokenRepository = new PostgresTokenRepository(db);
+    constructor(
+        private db: NodePgDatabase,
+        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+    ) {
+        this.userService = new UserService(db, tableOrTables);
+        this.roleService = new RoleService(db, tableOrTables);
+        this.tokenRepository = new PostgresTokenRepository(db, tableOrTables);
     }
 
     // User operations (delegate to UserService)
 
     async createUser(data: CreateUserData): Promise<UserData> {
-        return this.userService.createUser(data as NewUser) as Promise<UserData>;
+        return this.userService.createUser(data);
     }
 
     async getUserById(id: string): Promise<UserData | null> {
-        return this.userService.getUserById(id) as Promise<UserData | null>;
+        return this.userService.getUserById(id);
     }
 
     async getUserByEmail(email: string): Promise<UserData | null> {
-        return this.userService.getUserByEmail(email) as Promise<UserData | null>;
+        return this.userService.getUserByEmail(email);
     }
 
     async getUserByIdentity(provider: string, providerId: string): Promise<UserData | null> {
-        return this.userService.getUserByIdentity(provider, providerId) as Promise<UserData | null>;
+        return this.userService.getUserByIdentity(provider, providerId);
     }
 
     async getUserIdentities(userId: string): Promise<UserIdentityData[]> {
@@ -661,7 +914,7 @@ export class PostgresAuthRepository implements AuthRepository {
     }
 
     async updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null> {
-        return this.userService.updateUser(id, data) as Promise<UserData | null>;
+        return this.userService.updateUser(id, data);
     }
 
     async deleteUser(id: string): Promise<void> {
@@ -669,7 +922,7 @@ export class PostgresAuthRepository implements AuthRepository {
     }
 
     async listUsers(): Promise<UserData[]> {
-        return this.userService.listUsers() as Promise<UserData[]>;
+        return this.userService.listUsers();
     }
 
     async listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult> {
@@ -689,7 +942,7 @@ export class PostgresAuthRepository implements AuthRepository {
     }
 
     async getUserByVerificationToken(token: string): Promise<UserData | null> {
-        return this.userService.getUserByVerificationToken(token) as Promise<UserData | null>;
+        return this.userService.getUserByVerificationToken(token);
     }
 
     async getUserRoles(userId: string): Promise<RoleData[]> {
@@ -709,8 +962,7 @@ export class PostgresAuthRepository implements AuthRepository {
     }
 
     async getUserWithRoles(userId: string): Promise<{ user: UserData; roles: RoleData[] } | null> {
-        const result = await this.userService.getUserWithRoles(userId);
-        return result as { user: UserData; roles: RoleData[] } | null;
+        return this.userService.getUserWithRoles(userId);
     }
 
     // Role operations (delegate to RoleService)
@@ -796,4 +1048,3 @@ export type PostgresUserRepository = UserService;
 
 /** PostgreSQL role repository implementation */
 export type PostgresRoleRepository = RoleService;
-