@rebasepro/server-postgresql 0.7.0 → 0.8.0

package/dist/data-transformer.d.ts

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,14 @@
+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";