@rebasepro/server-postgresql 0.4.0 → 0.6.0

package/src/auth/ensure-tables.ts

@@ -4,7 +4,6 @@ import { logger } from "@rebasepro/server-core";
 import type { EntityCollection } from "@rebasepro/types";
 
 
-
 /**
  * Auto-create auth tables if they don't exist.
  *
@@ -20,16 +19,17 @@ export async function ensureAuthTablesExist(db: NodePgDatabase, collection?: Ent
         let usersTableName = '"rebase"."users"';
         let userIdType = "TEXT";
         let usersSchema = "rebase";
+        let resolvedTable = "users";
         if (collection) {
-            const rawTable = ("table" in collection && typeof collection.table === "string")
+            resolvedTable = ("table" in collection && typeof collection.table === "string")
                 ? collection.table
                 : collection.slug;
             usersSchema = ("schema" in collection && typeof collection.schema === "string")
                 ? collection.schema
                 : "public";
             usersTableName = usersSchema === "public"
-                ? `"${rawTable}"`
-                : `"${usersSchema}"."${rawTable}"`;
+                ? `"${resolvedTable}"`
+                : `"${usersSchema}"."${resolvedTable}"`;
 
             // Derive ID column type from collection properties
             const idProp = collection.properties?.id;
@@ -44,6 +44,30 @@ export async function ensureAuthTablesExist(db: NodePgDatabase, collection?: Ent
             }
         }
 
+        // Introspect the database to find the actual type of usersTableName's ID column if the table exists
+        try {
+            const result = await db.execute(sql`
+                SELECT data_type 
+                FROM information_schema.columns 
+                WHERE table_schema = ${usersSchema} 
+                  AND table_name = ${resolvedTable} 
+                  AND column_name = 'id'
+            `);
+            if (result && result.rows && result.rows.length > 0) {
+                const dbType = String((result.rows[0] as { data_type: string }).data_type).toUpperCase();
+                if (dbType === "UUID") {
+                    userIdType = "UUID";
+                } else if (dbType === "INTEGER" || dbType === "SMALLINT" || dbType === "BIGINT") {
+                    userIdType = "INTEGER";
+                } else {
+                    userIdType = "TEXT";
+                }
+                logger.info(`✨ Detected ${usersTableName}.id type from database: ${dbType}. Using user_id type: ${userIdType}`);
+            }
+        } catch (err) {
+            // Ignore introspection errors, fallback to derived/default type
+            logger.warn(`⚠️ Failed to introspect ${usersTableName}.id type from database, falling back to config type: ${userIdType}`, { error: err });
+        }
 
 
         // ── Create schemas (idempotent) ──────────────────────────────────
@@ -81,7 +105,6 @@ export async function ensureAuthTablesExist(db: NodePgDatabase, collection?: Ent
         `);
 
 
-
         // Create refresh tokens table (includes user_agent, ip_address, and unique constraint)
         await db.execute(sql`
             CREATE TABLE IF NOT EXISTS ${sql.raw(refreshTokensTableName)} (

package/src/auth/services.ts

@@ -1,6 +1,7 @@
 import { eq, getTableName, sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { getTableConfig, PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
+import { getTableConfig } from "drizzle-orm/pg-core";
+import type { RebasePgTable } from "../types";
 import { users, refreshTokens, passwordResetTokens, userIdentities } from "../schema/auth-schema";
 import {
     UserRepository,
@@ -20,21 +21,20 @@ import {
     MfaFactor,
     MfaChallengeInfo,
     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>;
-    refreshTokens: PgTable & Record<string, AnyPgColumn>;
-    passwordResetTokens: PgTable & Record<string, AnyPgColumn>;
-    appConfig: PgTable & Record<string, AnyPgColumn>;
-    userIdentities: PgTable & Record<string, AnyPgColumn>;
+    users: RebasePgTable;
+    refreshTokens: RebasePgTable;
+    passwordResetTokens: RebasePgTable;
+    appConfig: RebasePgTable;
+    userIdentities: RebasePgTable;
 }
 
-function getColumnKey(table: (PgTable & Record<string, AnyPgColumn>) | undefined, ...keys: string[]): string | undefined {
+function getColumnKey(table: RebasePgTable | undefined, ...keys: string[]): string | undefined {
     if (!table) return undefined;
     for (const key of keys) {
         if (key in table) return key;
@@ -46,7 +46,7 @@ function getColumnKey(table: (PgTable & Record<string, AnyPgColumn>) | undefined
     return undefined;
 }
 
-function getColumn(table: (PgTable & Record<string, AnyPgColumn>) | undefined, ...keys: string[]): AnyPgColumn | undefined {
+function getColumn(table: RebasePgTable | undefined, ...keys: string[]): RebasePgTable[string] | undefined {
     if (!table) return undefined;
     const key = getColumnKey(table, ...keys);
     return key ? table[key] : undefined;
@@ -57,21 +57,21 @@ function getColumn(table: (PgTable & Record<string, AnyPgColumn>) | undefined, .
  * Handles all user-related database operations using Drizzle ORM.
  */
 export class UserService implements UserRepository {
-    private usersTable: PgTable & Record<string, AnyPgColumn>;
-    private userIdentitiesTable: PgTable & Record<string, AnyPgColumn>;
+    private usersTable: RebasePgTable;
+    private userIdentitiesTable: RebasePgTable;
 
     constructor(
         private db: NodePgDatabase,
-        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+        tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>
     ) {
         if (tableOrTables && ((tableOrTables as Partial<AuthSchemaTables>).users)) {
             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.usersTable = (tables.users || users) as RebasePgTable;
+            this.userIdentitiesTable = (tables.userIdentities || userIdentities) as RebasePgTable;
         } 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>;
+            const table = tableOrTables as RebasePgTable | undefined;
+            this.usersTable = table || (users as unknown as RebasePgTable);
+            this.userIdentitiesTable = userIdentities as unknown as RebasePgTable;
         }
     }
 
@@ -82,7 +82,7 @@ export class UserService implements UserRepository {
     }
 
     private mapRowToUser(row: Record<string, unknown>): UserData {
-        if (!row) return row as unknown as UserData;
+        if (!row) return row as UserData;
 
         const id = (row.id ?? row.uid) as string;
         const email = row.email as string;
@@ -171,18 +171,18 @@ export class UserService implements UserRepository {
 
         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 && 
+            if (tableColKey &&
+                tableColKey !== idKey &&
+                tableColKey !== emailKey &&
+                tableColKey !== passwordHashKey &&
+                tableColKey !== displayNameKey &&
+                tableColKey !== photoUrlKey &&
+                tableColKey !== emailVerifiedKey &&
+                tableColKey !== emailVerificationTokenKey &&
+                tableColKey !== emailVerificationSentAtKey &&
                 tableColKey !== isAnonymousKey &&
-                tableColKey !== createdAtKey && 
-                tableColKey !== updatedAtKey && 
+                tableColKey !== createdAtKey &&
+                tableColKey !== updatedAtKey &&
                 tableColKey !== metadataKey) {
                 payload[tableColKey] = val;
             } else {
@@ -220,7 +220,7 @@ export class UserService implements UserRepository {
     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)
@@ -495,18 +495,17 @@ export class UserService implements UserRepository {
 }
 
 
-
 export class RefreshTokenService {
-    private refreshTokensTable: PgTable & Record<string, AnyPgColumn>;
+    private refreshTokensTable: RebasePgTable;
 
     constructor(
         private db: NodePgDatabase,
-        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+        tableOrTables?: RebasePgTable | 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>;
+            this.refreshTokensTable = ((tableOrTables as Partial<AuthSchemaTables>).refreshTokens || refreshTokens) as RebasePgTable;
         } else {
-            this.refreshTokensTable = (tableOrTables as unknown as PgTable & Record<string, AnyPgColumn>) || (refreshTokens as unknown as PgTable & Record<string, AnyPgColumn>);
+            this.refreshTokensTable = (tableOrTables as RebasePgTable) || (refreshTokens as unknown as RebasePgTable);
         }
     }
 
@@ -595,16 +594,16 @@ export class RefreshTokenService {
  * Password reset token service
  */
 export class PasswordResetTokenService {
-    private passwordResetTokensTable: PgTable & Record<string, AnyPgColumn>;
+    private passwordResetTokensTable: RebasePgTable;
 
     constructor(
         private db: NodePgDatabase,
-        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+        tableOrTables?: RebasePgTable | 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>;
+            this.passwordResetTokensTable = ((tableOrTables as Partial<AuthSchemaTables>).passwordResetTokens || passwordResetTokens) as RebasePgTable;
         } else {
-            this.passwordResetTokensTable = (tableOrTables as unknown as PgTable & Record<string, AnyPgColumn>) || (passwordResetTokens as unknown as PgTable & Record<string, AnyPgColumn>);
+            this.passwordResetTokensTable = (tableOrTables as RebasePgTable) || (passwordResetTokens as unknown as RebasePgTable);
         }
     }
 
@@ -704,7 +703,7 @@ export class PostgresTokenRepository implements TokenRepository {
 
     constructor(
         private db: NodePgDatabase,
-        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+        tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>
     ) {
         this.refreshTokenService = new RefreshTokenService(db, tableOrTables);
         this.passwordResetTokenService = new PasswordResetTokenService(db, tableOrTables);
@@ -770,7 +769,7 @@ export class PostgresAuthRepository implements AuthRepository {
 
     constructor(
         private db: NodePgDatabase,
-        tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>
+        tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>
     ) {
         this.userService = new UserService(db, tableOrTables);
         this.tokenRepository = new PostgresTokenRepository(db, tableOrTables);
@@ -868,9 +867,21 @@ export class PostgresAuthRepository implements AuthRepository {
 
     async listRoles(): Promise<RoleData[]> {
         return [
-            { id: "admin", name: "Admin", isAdmin: true, defaultPermissions: null, collectionPermissions: null },
-            { id: "editor", name: "Editor", isAdmin: false, defaultPermissions: null, collectionPermissions: null },
-            { id: "viewer", name: "Viewer", isAdmin: false, defaultPermissions: null, collectionPermissions: null }
+            { id: "admin",
+name: "Admin",
+isAdmin: true,
+defaultPermissions: null,
+collectionPermissions: null },
+            { id: "editor",
+name: "Editor",
+isAdmin: false,
+defaultPermissions: null,
+collectionPermissions: null },
+            { id: "viewer",
+name: "Viewer",
+isAdmin: false,
+defaultPermissions: null,
+collectionPermissions: null }
         ];
     }
 
@@ -1016,7 +1027,7 @@ export class PostgresAuthRepository implements AuthRepository {
  * Handles all MFA-related database operations.
  */
 export class MfaService implements MfaRepository {
-    constructor(private db: NodePgDatabase, private schemaName: string = "rebase") {}
+    constructor(private db: NodePgDatabase, private schemaName = "rebase") {}
 
     private qualify(tableName: string): string {
         return `"${this.schemaName}"."${tableName}"`;