@rebasepro/server-postgresql 0.6.0 → 0.7.0

package/dist/auth/ensure-tables.d.ts

@@ -1,10 +0,0 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import type { EntityCollection } from "@rebasepro/types";
-/**
- * Auto-create auth tables if they don't exist.
- *
- * @param db         — Drizzle database instance
- * @param collection — The collection that represents auth users.
- *                     When omitted, a default `rebase.users` table is created.
- */
-export declare function ensureAuthTablesExist(db: NodePgDatabase, collection?: EntityCollection): Promise<void>;

package/dist/auth/services.d.ts

@@ -1,231 +0,0 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import type { RebasePgTable } from "../types";
-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: RebasePgTable;
-    refreshTokens: RebasePgTable;
-    passwordResetTokens: RebasePgTable;
-    appConfig: RebasePgTable;
-    userIdentities: RebasePgTable;
-}
-/**
- * PostgreSQL implementation of UserRepository.
- * Handles all user-related database operations using Drizzle ORM.
- */
-export declare class UserService implements UserRepository {
-    private db;
-    private usersTable;
-    private userIdentitiesTable;
-    constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
-    private getQualifiedUsersTableName;
-    private mapRowToUser;
-    private mapPayload;
-    createUser(data: CreateUserData): Promise<UserData>;
-    getUserById(id: string): Promise<UserData | null>;
-    getUserByEmail(email: string): Promise<UserData | null>;
-    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
-    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
-    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
-    updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null>;
-    deleteUser(id: string): Promise<void>;
-    listUsers(): Promise<UserData[]>;
-    listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult>;
-    /**
-     * Update user's password hash
-     */
-    updatePassword(id: string, passwordHash: string): Promise<void>;
-    /**
-     * Set email verification status
-     */
-    setEmailVerified(id: string, verified: boolean): Promise<void>;
-    /**
-     * Set email verification token
-     */
-    setVerificationToken(id: string, token: string | null): Promise<void>;
-    /**
-     * Find user by email verification token
-     */
-    getUserByVerificationToken(token: string): Promise<UserData | null>;
-    /**
-     * Get roles for a user from database (inline TEXT[] column)
-     */
-    getUserRoles(userId: string): Promise<Role[]>;
-    /**
-     * Get role IDs for a user
-     */
-    getUserRoleIds(userId: string): Promise<string[]>;
-    /**
-     * Set roles for a user (replaces existing roles)
-     */
-    setUserRoles(userId: string, roleIds: string[]): Promise<void>;
-    /**
-     * Assign a specific role to new user (appends if not present)
-     */
-    assignDefaultRole(userId: string, roleId: string): Promise<void>;
-    /**
-     * Get user with their roles
-     */
-    getUserWithRoles(userId: string): Promise<{
-        user: UserData;
-        roles: Role[];
-    } | null>;
-}
-export declare class RefreshTokenService {
-    private db;
-    private refreshTokensTable;
-    constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
-    private getQualifiedRefreshTokensTableName;
-    createToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
-    findByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
-    deleteByHash(tokenHash: string): Promise<void>;
-    deleteAllForUser(userId: string): Promise<void>;
-    listForUser(userId: string): Promise<RefreshTokenInfo[]>;
-    deleteById(id: string, userId: string): Promise<void>;
-}
-/**
- * Password reset token service
- */
-export declare class PasswordResetTokenService {
-    private db;
-    private passwordResetTokensTable;
-    constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
-    private getQualifiedPasswordResetTokensTableName;
-    /**
-     * Create a password reset token
-     */
-    createToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
-    /**
-     * Find a valid (not expired, not used) token by hash
-     */
-    findValidByHash(tokenHash: string): Promise<{
-        userId: string;
-        expiresAt: Date;
-    } | null>;
-    /**
-     * Mark token as used
-     */
-    markAsUsed(tokenHash: string): Promise<void>;
-    /**
-     * Delete all tokens for a user
-     */
-    deleteAllForUser(userId: string): Promise<void>;
-    /**
-     * Clean up expired tokens
-     */
-    deleteExpired(): Promise<void>;
-}
-/**
- * PostgreSQL implementation of TokenRepository.
- * Combines refresh token and password reset token operations.
- */
-export declare class PostgresTokenRepository implements TokenRepository {
-    private db;
-    private refreshTokenService;
-    private passwordResetTokenService;
-    constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
-    createRefreshToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
-    findRefreshTokenByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
-    deleteRefreshToken(tokenHash: string): Promise<void>;
-    deleteAllRefreshTokensForUser(userId: string): Promise<void>;
-    listRefreshTokensForUser(userId: string): Promise<RefreshTokenInfo[]>;
-    deleteRefreshTokenById(id: string, userId: string): Promise<void>;
-    createPasswordResetToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
-    findValidPasswordResetToken(tokenHash: string): Promise<PasswordResetTokenInfo | null>;
-    markPasswordResetTokenUsed(tokenHash: string): Promise<void>;
-    deleteAllPasswordResetTokensForUser(userId: string): Promise<void>;
-    deleteExpiredTokens(): Promise<void>;
-}
-/**
- * PostgreSQL implementation of AuthRepository.
- * Combines user, role, and token repository operations.
- * This provides a convenient single-class interface for all auth operations.
- */
-export declare class PostgresAuthRepository implements AuthRepository {
-    private db;
-    private userService;
-    private tokenRepository;
-    constructor(db: NodePgDatabase, tableOrTables?: RebasePgTable | Partial<AuthSchemaTables>);
-    createUser(data: CreateUserData): Promise<UserData>;
-    getUserById(id: string): Promise<UserData | null>;
-    getUserByEmail(email: string): Promise<UserData | null>;
-    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
-    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
-    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
-    updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null>;
-    deleteUser(id: string): Promise<void>;
-    listUsers(): Promise<UserData[]>;
-    listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult>;
-    updatePassword(id: string, passwordHash: string): Promise<void>;
-    setEmailVerified(id: string, verified: boolean): Promise<void>;
-    setVerificationToken(id: string, token: string | null): Promise<void>;
-    getUserByVerificationToken(token: string): Promise<UserData | null>;
-    getUserRoles(userId: string): Promise<RoleData[]>;
-    getUserRoleIds(userId: string): Promise<string[]>;
-    setUserRoles(userId: string, roleIds: string[]): Promise<void>;
-    assignDefaultRole(userId: string, roleId: string): Promise<void>;
-    getUserWithRoles(userId: string): Promise<{
-        user: UserData;
-        roles: RoleData[];
-    } | null>;
-    getRoleById(id: string): Promise<RoleData | null>;
-    listRoles(): Promise<RoleData[]>;
-    createRole(_data: CreateRoleData): Promise<RoleData>;
-    updateRole(id: string, data: Partial<Omit<RoleData, "id">>): Promise<RoleData | null>;
-    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>;
-    deleteAllRefreshTokensForUser(userId: string): Promise<void>;
-    listRefreshTokensForUser(userId: string): Promise<RefreshTokenInfo[]>;
-    deleteRefreshTokenById(id: string, userId: string): Promise<void>;
-    createPasswordResetToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
-    findValidPasswordResetToken(tokenHash: string): Promise<PasswordResetTokenInfo | null>;
-    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;

package/dist/cli.d.ts

@@ -1 +0,0 @@
-export declare function runPluginCommand(args: string[]): Promise<void>;

package/dist/collections/PostgresCollectionRegistry.d.ts

@@ -1,47 +0,0 @@
-import { CollectionRegistry } from "@rebasepro/common";
-import { type EntityCollection } from "@rebasepro/types";
-import { PgEnum, PgTable } from "drizzle-orm/pg-core";
-import { Relations } from "drizzle-orm";
-import { CollectionRegistryInterface } from "../interfaces";
-/**
- * PostgreSQL-specific collection registry.
- * Extends the base CollectionRegistry with support for Drizzle ORM tables, enums, and relations.
- *
- * Satisfies CollectionRegistryInterface through inheritance from CollectionRegistry.
- */
-export declare class PostgresCollectionRegistry extends CollectionRegistry implements CollectionRegistryInterface {
-    private tables;
-    private enums;
-    private relations;
-    registerTable(table: PgTable, tableName: string): void;
-    getTable(tableName: string): PgTable | undefined;
-    /**
-     * Checks if a specific collection has a registered table
-     */
-    hasTableForCollection(tableName: string): boolean;
-    /**
-     * Returns all registered table names.
-     */
-    getTableNames(): string[];
-    /**
-     * Finds collections assigned to a specific driver that do not have a registered table.
-     */
-    getCollectionsWithoutTables(driverId?: string): EntityCollection[];
-    registerEnums(enums: Record<string, PgEnum<[string, ...string[]]>>): void;
-    registerRelations(relations: Record<string, Relations>): void;
-    getEnum(name: string): PgEnum<[string, ...string[]]> | undefined;
-    getRelation(name: string): Relations | undefined;
-    getAllEnums(): Record<string, PgEnum<[string, ...string[]]>>;
-    getAllRelations(): Record<string, Relations>;
-    /**
-     * Get the merged schema object (tables + relations) for use with Drizzle's
-     * relational query API (`db.query`).
-     */
-    getMergedSchema(): Record<string, unknown>;
-    /**
-     * Get the available Drizzle relation keys for a given collection path.
-     * Maps from the collection's relation property names to the Drizzle relation names
-     * defined in the schema.
-     */
-    getRelationKeysForCollection(collectionPath: string): string[];
-}

package/dist/connection.d.ts

@@ -1,65 +0,0 @@
-import { Pool } from "pg";
-/**
- * Configuration for the Postgres connection pool.
- *
- * Sensible defaults are provided for production Cloud Run / single-instance
- * deployments. Override via environment variables or explicit config.
- */
-export interface PostgresPoolConfig {
-    /** Maximum number of connections in the pool (default: 20) */
-    max?: number;
-    /** Close idle connections after this many ms (default: 30 000) */
-    idleTimeoutMillis?: number;
-    /** Abort connection attempts after this many ms (default: 10 000) */
-    connectionTimeoutMillis?: number;
-    /** Per-query timeout in ms (default: 30 000) */
-    queryTimeout?: number;
-    /** Per-statement timeout in ms (default: 30 000) */
-    statementTimeout?: number;
-    /** Enable TCP keep-alive (default: true) */
-    keepAlive?: boolean;
-}
-/**
- * Create a Drizzle-backed Postgres connection with a production-grade
- * connection pool.
- *
- * @param connectionString  Postgres connection URL
- * @param schema            Optional Drizzle schema for the relational API
- * @param poolConfig        Optional pool tuning (merged over defaults)
- *
- * @returns `{ db, pool, connectionString }` — the `pool` is exposed so
- *          callers can register shutdown hooks (`pool.end()`) or monitor
- *          pool metrics.
- */
-export declare function createPostgresDatabaseConnection(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 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;
-};

package/dist/data-transformer.d.ts

@@ -1,55 +0,0 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { EntityCollection, Properties, Property, Relation } from "@rebasepro/types";
-import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-/**
- * Data transformation utilities for converting between frontend and database formats.
- */
-/**
- * Typed result from `serializeDataToServer`.
- * Replaces the hidden `__inverseRelationUpdates` / `__joinPathRelationUpdates`
- * dunder-property mutation pattern with explicit, typed state management.
- */
-export interface SerializedEntityData {
-    /** Scalar column values ready for INSERT/UPDATE. */
-    scalarData: Record<string, unknown>;
-    /** Inverse relation updates that must be applied to target tables. */
-    inverseRelationUpdates: Array<{
-        relationKey: string;
-        relation: Relation;
-        newValue: unknown;
-        currentEntityId?: string | number;
-    }>;
-    /** JoinPath relation updates that require multi-hop writes. */
-    joinPathRelationUpdates: Array<{
-        relationKey: string;
-        relation: Relation;
-        newTargetId: string | number | null;
-    }>;
-}
-/**
- * Helper function to sanitize and convert dates to ISO strings
- */
-export declare function sanitizeAndConvertDates(obj: unknown): unknown;
-/**
- * Transform relations for database storage (relation objects to IDs)
- */
-export declare function serializeDataToServer<M extends Record<string, unknown>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): SerializedEntityData;
-/**
- * Serialize a single property value for database storage
- */
-export declare function serializePropertyToServer(value: unknown, property: Property): unknown;
-/**
- * Transform IDs back to relation objects for frontend
- */
-export declare function parseDataFromServer<M extends Record<string, unknown>>(data: M, collection: EntityCollection, db?: NodePgDatabase<Record<string, unknown>>, registry?: PostgresCollectionRegistry): Promise<M>;
-export declare function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown;
-/**
- * Lightweight value normalization for db.query results.
- * Only handles type coercion (dates, numbers, NaN) and property filtering.
- * Does NOT query the database for relations — those are already resolved
- * by Drizzle's relational query API.
- *
- * Use this instead of `parseDataFromServer` when processing results from
- * `db.query.findFirst/findMany` which return pre-hydrated relation data.
- */
-export declare function normalizeDbValues<M extends Record<string, unknown>>(data: M, collection: EntityCollection): M;

package/dist/databasePoolManager.d.ts

@@ -1,20 +0,0 @@
-import { Pool } from "pg";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-export declare class DatabasePoolManager {
-    private pools;
-    private drizzleInstances;
-    readonly defaultDatabaseName: string;
-    private readonly rootConnectionString;
-    constructor(adminConnectionString: string);
-    getDrizzle(databaseName: string): NodePgDatabase<Record<string, never>>;
-    getPool(databaseName: string): Pool;
-    /**
-     * Disconnect and remove the pool for a specific database.
-     * Required before `CREATE DATABASE ... TEMPLATE` or `DROP DATABASE`,
-     * which need exclusive access to the target database.
-     */
-    disconnectDatabase(databaseName: string): Promise<void>;
-    /** Check if a pool exists for a given database name. */
-    hasPool(databaseName: string): boolean;
-    shutdown(): Promise<void>;
-}

package/dist/history/HistoryService.d.ts

@@ -1,71 +0,0 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-export interface HistoryEntry {
-    id: string;
-    table_name: string;
-    entity_id: string;
-    action: "create" | "update" | "delete";
-    changed_fields: string[] | null;
-    values: Record<string, unknown> | null;
-    previous_values: Record<string, unknown> | null;
-    updated_by: string | null;
-    updated_at: string;
-}
-export interface RecordHistoryParams {
-    tableName: string;
-    entityId: string;
-    action: "create" | "update" | "delete";
-    values?: Record<string, unknown> | null;
-    previousValues?: Record<string, unknown> | null;
-    updatedBy?: string | null;
-}
-export interface FetchHistoryOptions {
-    limit?: number;
-    offset?: number;
-}
-export interface HistoryRetentionConfig {
-    /** Max entries per entity. Oldest pruned first. Default 200. */
-    maxEntries: number;
-    /** Entries older than this many days are pruned. Default 90. */
-    ttlDays: number;
-}
-/**
- * Service for recording and querying entity change history.
- * Stores snapshots in the `rebase.entity_history` table.
- */
-export declare class HistoryService {
-    private db;
-    retention: HistoryRetentionConfig;
-    constructor(db: NodePgDatabase, retention?: Partial<HistoryRetentionConfig>);
-    /**
-     * Record a history entry for an entity change.
-     * This is intentionally fire-and-forget safe — errors are logged but never
-     * bubble up to block the main save/delete operation.
-     *
-     * After inserting, kicks off a non-blocking pruning pass for this entity.
-     */
-    recordHistory(params: RecordHistoryParams): Promise<void>;
-    /**
-     * Fetch history entries for an entity, ordered by most recent first.
-     */
-    fetchHistory(tableName: string, entityId: string, options?: FetchHistoryOptions): Promise<{
-        data: HistoryEntry[];
-        total: number;
-    }>;
-    /**
-     * Fetch a single history entry by ID.
-     */
-    fetchHistoryEntry(historyId: string): Promise<HistoryEntry | null>;
-    /**
-     * Prune history for a single entity: enforce maxEntries and TTL.
-     */
-    pruneEntity(tableName: string, entityId: string): Promise<number>;
-    /**
-     * Global prune: enforce TTL across ALL entities in a single sweep.
-     * Intended to be called periodically (e.g. once per hour or daily).
-     */
-    pruneExpired(): Promise<number>;
-}
-/**
- * Shallow comparison to find top-level keys that changed between two objects.
- */
-export declare function findChangedFields(oldValues: Record<string, unknown>, newValues: Record<string, unknown>): string[] | null;

package/dist/history/ensure-history-table.d.ts

@@ -1,7 +0,0 @@
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-/**
- * Auto-create the entity history table if it doesn't exist.
- * This runs on startup when history is enabled, following the same
- * pattern as `ensureAuthTablesExist`.
- */
-export declare function ensureHistoryTableExists(db: NodePgDatabase): Promise<void>;

package/dist/index.d.ts

@@ -1,14 +0,0 @@
-export * from "./connection";
-export * from "./interfaces";
-export * from "./PostgresBackendDriver";
-export * from "./databasePoolManager";
-export * from "./schema/auth-schema";
-export * from "./schema/generate-drizzle-schema-logic";
-export * from "./schema/generate-drizzle-schema";
-export * from "./utils/drizzle-conditions";
-export * from "./services/realtimeService";
-export * from "./websocket";
-export * from "./collections/PostgresCollectionRegistry";
-export * from "./services/BranchService";
-export * from "./PostgresBootstrapper";
-export * from "./PostgresAdapter";