@rebasepro/server-postgresql 0.2.3 → 0.2.5

package/dist/server-postgresql/src/PostgresBackendDriver.d.ts

@@ -45,12 +45,13 @@ export declare class PostgresBackendDriver implements DataDriver {
      */
     get restFetchService(): import("./services").EntityFetchService;
     private resolveCollectionCallbacks;
-    fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, vectorSearch }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
     listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;
     fetchEntity<M extends Record<string, unknown>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
     listenEntity<M extends Record<string, unknown>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
     saveEntity<M extends Record<string, unknown>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
     deleteEntity<M extends Record<string, unknown>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
+    deleteAll(path: string): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
     countEntities<M extends Record<string, unknown>>({ path, collection, filter, searchString }: FetchCollectionProps<M>): Promise<number>;
     private getTargetDb;
@@ -103,6 +104,7 @@ export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
     listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
     saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
     deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
+    deleteAll(path: string): Promise<void>;
     checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
     countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
 }

package/dist/server-postgresql/src/PostgresBootstrapper.d.ts

@@ -16,6 +16,7 @@ import type { PostgresDriverConfig } from "@rebasepro/server-core";
  */
 export interface PostgresDriverInternals {
     db: NodePgDatabase<any>;
+    readDb?: NodePgDatabase<any>;
     registry: PostgresCollectionRegistry;
     realtimeService: RealtimeService;
     driver: PostgresBackendDriver;

package/dist/server-postgresql/src/auth/services.d.ts

@@ -1,11 +1,9 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { PgTable, AnyPgColumn } from "drizzle-orm/pg-core";
-import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, UserIdentityData, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
+import { UserRepository, TokenRepository, MfaRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, UserIdentityData, ListUsersOptions, PaginatedUsersResult, MfaFactor, MfaChallengeInfo, RoleData as Role } from "@rebasepro/server-core";
 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>;
@@ -19,8 +17,6 @@ export declare class UserService implements UserRepository {
     private db;
     private usersTable;
     private userIdentitiesTable;
-    private userRolesTable;
-    private rolesTable;
     constructor(db: NodePgDatabase, tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>);
     private getQualifiedUsersTableName;
     private mapRowToUser;
@@ -52,7 +48,7 @@ export declare class UserService implements UserRepository {
      */
     getUserByVerificationToken(token: string): Promise<UserData | null>;
     /**
-     * Get roles for a user from database
+     * Get roles for a user from database (inline TEXT[] column)
      */
     getUserRoles(userId: string): Promise<Role[]>;
     /**
@@ -60,11 +56,11 @@ export declare class UserService implements UserRepository {
      */
     getUserRoleIds(userId: string): Promise<string[]>;
     /**
-     * Set roles for a user
+     * Set roles for a user (replaces existing roles)
      */
     setUserRoles(userId: string, roleIds: string[]): Promise<void>;
     /**
-     * Assign a specific role to new user
+     * Assign a specific role to new user (appends if not present)
      */
     assignDefaultRole(userId: string, roleId: string): Promise<void>;
     /**
@@ -75,24 +71,6 @@ export declare class UserService implements UserRepository {
         roles: Role[];
     } | null>;
 }
-/**
- * PostgreSQL implementation of RoleRepository.
- * Handles all role-related database operations using Drizzle ORM.
- */
-export declare class RoleService implements RoleRepository {
-    private db;
-    private rolesTable;
-    constructor(db: NodePgDatabase, tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>);
-    private getQualifiedRolesTableName;
-    getRoleById(id: string): Promise<Role | null>;
-    listRoles(): Promise<Role[]>;
-    createRole(data: Omit<Role, "isAdmin" | "collectionPermissions"> & {
-        isAdmin?: boolean;
-        collectionPermissions?: Role["collectionPermissions"];
-    }): Promise<Role>;
-    updateRole(id: string, data: Partial<Omit<Role, "id">>): Promise<Role | null>;
-    deleteRole(id: string): Promise<void>;
-}
 export declare class RefreshTokenService {
     private db;
     private refreshTokensTable;
@@ -166,7 +144,6 @@ export declare class PostgresTokenRepository implements TokenRepository {
 export declare class PostgresAuthRepository implements AuthRepository {
     private db;
     private userService;
-    private roleService;
     private tokenRepository;
     constructor(db: NodePgDatabase, tableOrTables?: (PgTable & Record<string, AnyPgColumn>) | Partial<AuthSchemaTables>);
     createUser(data: CreateUserData): Promise<UserData>;
@@ -193,9 +170,9 @@ export declare class PostgresAuthRepository implements AuthRepository {
     } | null>;
     getRoleById(id: string): Promise<RoleData | null>;
     listRoles(): Promise<RoleData[]>;
-    createRole(data: CreateRoleData): Promise<RoleData>;
+    createRole(_data: CreateRoleData): Promise<RoleData>;
     updateRole(id: string, data: Partial<Omit<RoleData, "id">>): Promise<RoleData | null>;
-    deleteRole(id: string): Promise<void>;
+    deleteRole(_id: string): Promise<void>;
     createRefreshToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
     findRefreshTokenByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
     deleteRefreshToken(tokenHash: string): Promise<void>;
@@ -207,8 +184,48 @@ export declare class PostgresAuthRepository implements AuthRepository {
     markPasswordResetTokenUsed(tokenHash: string): Promise<void>;
     deleteAllPasswordResetTokensForUser(userId: string): Promise<void>;
     deleteExpiredTokens(): Promise<void>;
+    private _mfaService;
+    private getMfaService;
+    createMfaFactor(userId: string, factorType: "totp", secretEncrypted: string, friendlyName?: string): Promise<MfaFactor>;
+    getMfaFactors(userId: string): Promise<MfaFactor[]>;
+    getMfaFactorById(factorId: string): Promise<(MfaFactor & {
+        secretEncrypted: string;
+    }) | null>;
+    verifyMfaFactor(factorId: string): Promise<void>;
+    deleteMfaFactor(factorId: string, userId: string): Promise<void>;
+    createMfaChallenge(factorId: string, ipAddress?: string): Promise<MfaChallengeInfo>;
+    getMfaChallengeById(challengeId: string): Promise<MfaChallengeInfo | null>;
+    verifyMfaChallenge(challengeId: string): Promise<void>;
+    createRecoveryCodes(userId: string, codeHashes: string[]): Promise<void>;
+    useRecoveryCode(userId: string, codeHash: string): Promise<boolean>;
+    getUnusedRecoveryCodeCount(userId: string): Promise<number>;
+    deleteAllRecoveryCodes(userId: string): Promise<void>;
+    hasVerifiedMfaFactors(userId: string): Promise<boolean>;
+}
+/**
+ * PostgreSQL implementation of MfaRepository.
+ * Handles all MFA-related database operations.
+ */
+export declare class MfaService implements MfaRepository {
+    private db;
+    private schemaName;
+    constructor(db: NodePgDatabase, schemaName?: string);
+    private qualify;
+    createMfaFactor(userId: string, factorType: "totp", secretEncrypted: string, friendlyName?: string): Promise<MfaFactor>;
+    getMfaFactors(userId: string): Promise<MfaFactor[]>;
+    getMfaFactorById(factorId: string): Promise<(MfaFactor & {
+        secretEncrypted: string;
+    }) | null>;
+    verifyMfaFactor(factorId: string): Promise<void>;
+    deleteMfaFactor(factorId: string, userId: string): Promise<void>;
+    createMfaChallenge(factorId: string, ipAddress?: string): Promise<MfaChallengeInfo>;
+    getMfaChallengeById(challengeId: string): Promise<MfaChallengeInfo | null>;
+    verifyMfaChallenge(challengeId: string): Promise<void>;
+    createRecoveryCodes(userId: string, codeHashes: string[]): Promise<void>;
+    useRecoveryCode(userId: string, codeHash: string): Promise<boolean>;
+    getUnusedRecoveryCodeCount(userId: string): Promise<number>;
+    deleteAllRecoveryCodes(userId: string): Promise<void>;
+    hasVerifiedMfaFactors(userId: string): Promise<boolean>;
 }
 /** PostgreSQL user repository implementation */
 export type PostgresUserRepository = UserService;
-/** PostgreSQL role repository implementation */
-export type PostgresRoleRepository = RoleService;

package/dist/server-postgresql/src/connection.d.ts

@@ -38,3 +38,28 @@ export declare function createPostgresDatabaseConnection(connectionString: strin
     pool: Pool;
     connectionString: string;
 };
+/**
+ * Create a direct (non-pooled) connection for operations that require
+ * session-level features incompatible with PgBouncer transaction mode,
+ * such as LISTEN/NOTIFY, prepared statements, or advisory locks.
+ *
+ * Uses a smaller pool since this is only for specific use cases.
+ */
+export declare function createDirectDatabaseConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+        $client: Pool;
+    };
+    pool: Pool;
+    connectionString: string;
+};
+/**
+ * Create a read-only connection for routing read queries to replicas.
+ * Uses a moderate pool size since reads are distributed across replicas.
+ */
+export declare function createReadReplicaConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+        $client: Pool;
+    };
+    pool: Pool;
+    connectionString: string;
+};