@elizaos/plugin-sql 2.0.3-beta.2 → 2.0.3-beta.3

package/src/dist/pg/adapter.d.ts

@@ -0,0 +1,42 @@
+import { type Agent, type Component, type Entity, type Memory, type UUID } from "@elizaos/core";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { Pool } from "pg";
+import { BaseDrizzleAdapter } from "../base.js";
+import { type EmbeddingDimensionColumn } from "../schema/embedding.js";
+import type { PostgresConnectionManager } from "./manager.js";
+export declare class PgDatabaseAdapter extends BaseDrizzleAdapter {
+    protected embeddingDimension: EmbeddingDimensionColumn;
+    private manager;
+    constructor(agentId: UUID, manager: PostgresConnectionManager, _schema?: Record<string, unknown>);
+    getManager(): PostgresConnectionManager;
+    withEntityContext<T>(entityId: UUID | null, callback: (tx: NodePgDatabase) => Promise<T>): Promise<T>;
+    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
+    getMemoriesByServerId(params: {
+        serverId: UUID;
+        count?: number;
+    }): Promise<Memory[]>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    protected withDatabase<T>(operation: () => Promise<T>): Promise<T>;
+    init(): Promise<void>;
+    isReady(): Promise<boolean>;
+    close(): Promise<void>;
+    getConnection(): Promise<NodePgDatabase>;
+    getRawConnection(): Pool;
+    createAgent(agent: Agent): Promise<boolean>;
+    getAgent(agentId: UUID): Promise<Agent | null>;
+    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
+    deleteAgent(agentId: UUID): Promise<boolean>;
+    createEntities(entities: Entity[]): Promise<UUID[]>;
+    getEntitiesByIds(entityIds: UUID[]): Promise<Entity[]>;
+    updateEntity(entity: Entity): Promise<void>;
+    createMemory(memory: Memory, tableName: string): Promise<UUID>;
+    getMemoryById(memoryId: UUID): Promise<Memory | null>;
+    updateMemory(memory: Partial<Memory> & {
+        id: UUID;
+    }): Promise<boolean>;
+    deleteMemory(memoryId: UUID): Promise<void>;
+    createComponent(component: Component): Promise<boolean>;
+    getComponent(entityId: UUID, type: string, worldId?: UUID, sourceEntityId?: UUID): Promise<Component | null>;
+    updateComponent(component: Component): Promise<void>;
+    deleteComponent(componentId: UUID): Promise<void>;
+}

package/src/dist/pg/manager.d.ts

@@ -0,0 +1,17 @@
+import { type UUID } from "@elizaos/core";
+import { type NodePgDatabase } from "drizzle-orm/node-postgres";
+import { Pool, type PoolClient } from "pg";
+export declare class PostgresConnectionManager {
+    private pool;
+    private db;
+    private closePromise;
+    private shuttingDown;
+    constructor(connectionString: string, rlsServerId?: string);
+    getDatabase(): NodePgDatabase;
+    getConnection(): Pool;
+    isShuttingDown(): boolean;
+    getClient(): Promise<PoolClient>;
+    testConnection(): Promise<boolean>;
+    withEntityContext<T>(entityId: UUID | null, callback: (tx: NodePgDatabase) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}

package/src/dist/pg/sslmode.d.ts

@@ -0,0 +1,6 @@
+/**
+ * pg-connection-string currently treats these sslmode values like verify-full,
+ * but warns that its next major version will switch them to libpq semantics.
+ * Make the current strict TLS behavior explicit before node-postgres parses it.
+ */
+export declare function normalizePgSslMode(connectionString: string): string;

package/src/dist/pglite/adapter.d.ts

@@ -0,0 +1,63 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { type Agent, type Entity, type Memory, type MemoryMetadata, type Relationship, type Room, type Task, type UUID, type World } from "@elizaos/core";
+import { type PgliteDatabase } from "drizzle-orm/pglite";
+import { BaseDrizzleAdapter } from "../base.js";
+import { type EmbeddingDimensionColumn } from "../schema/embedding.js";
+import type { PGliteClientManager } from "./manager.js";
+export declare class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
+    private manager;
+    protected embeddingDimension: EmbeddingDimensionColumn;
+    constructor(agentId: UUID, manager: PGliteClientManager);
+    withEntityContext<T>(_entityId: UUID | null, callback: (tx: PgliteDatabase) => Promise<T>): Promise<T>;
+    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
+    getMemoriesByServerId(params: {
+        serverId: UUID;
+        count?: number;
+    }): Promise<Memory[]>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    protected withDatabase<T>(operation: () => Promise<T>): Promise<T>;
+    init(): Promise<void>;
+    isReady(): Promise<boolean>;
+    close(): Promise<void>;
+    getConnection(): Promise<PgliteDatabase>;
+    getRawConnection(): PGlite;
+    createAgent(agent: Agent): Promise<boolean>;
+    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
+    deleteAgent(agentId: UUID): Promise<boolean>;
+    deleteAgents(agentIds: UUID[]): Promise<boolean>;
+    createEntities(entities: Entity[]): Promise<UUID[]>;
+    updateEntity(entity: Entity): Promise<void>;
+    deleteEntity(entityId: UUID): Promise<void>;
+    createWorld(world: World): Promise<UUID>;
+    updateWorld(world: World): Promise<void>;
+    removeWorld(id: UUID): Promise<void>;
+    createRooms(rooms: Room[]): Promise<UUID[]>;
+    updateRoom(room: Room): Promise<void>;
+    deleteRoom(roomId: UUID): Promise<void>;
+    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
+    createMemory(memory: Memory & {
+        metadata?: MemoryMetadata;
+    }, tableName: string): Promise<UUID>;
+    updateMemory(memory: Partial<Memory> & {
+        id: UUID;
+        metadata?: MemoryMetadata;
+    }): Promise<boolean>;
+    deleteMemory(memoryId: UUID): Promise<void>;
+    deleteManyMemories(memoryIds: UUID[]): Promise<void>;
+    deleteAllMemories(roomIds: UUID[], tableName: string): Promise<void>;
+    deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
+    createRelationship(params: {
+        sourceEntityId: UUID;
+        targetEntityId: UUID;
+        tags?: string[];
+        metadata?: {
+            [key: string]: unknown;
+        };
+    }): Promise<boolean>;
+    updateRelationship(relationship: Relationship): Promise<void>;
+    deleteRelationships(relationshipIds: UUID[]): Promise<void>;
+    createTask(task: Task): Promise<UUID>;
+    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
+    deleteTask(id: UUID): Promise<void>;
+}

package/src/dist/pglite/errors.d.ts

@@ -0,0 +1,20 @@
+export declare const PGLITE_ERROR_CODES: {
+    readonly ACTIVE_LOCK: "ELIZA_PGLITE_DATA_DIR_IN_USE";
+    readonly CORRUPT_DATA: "ELIZA_PGLITE_CORRUPT_DATA";
+    readonly MANUAL_RESET_REQUIRED: "ELIZA_PGLITE_MANUAL_RESET_REQUIRED";
+};
+export type PgliteErrorCode = (typeof PGLITE_ERROR_CODES)[keyof typeof PGLITE_ERROR_CODES];
+export declare class PgliteInitError extends Error {
+    readonly code: PgliteErrorCode;
+    readonly dataDir?: string;
+    constructor(code: PgliteErrorCode, message: string, options?: {
+        cause?: unknown;
+        dataDir?: string;
+    });
+}
+export declare function createPgliteInitError(code: PgliteErrorCode, message: string, options?: {
+    cause?: unknown;
+    dataDir?: string;
+}): PgliteInitError;
+export declare function getPgliteErrorCode(err: unknown): PgliteErrorCode | null;
+export declare function isFatalPgliteErrorCode(code: unknown): code is PgliteErrorCode;

package/src/dist/pglite/manager.d.ts

@@ -0,0 +1,213 @@
+import { PGlite, type PGliteOptions } from "@electric-sql/pglite";
+import type { IDatabaseClientManager } from "../types.js";
+import { WriteBackService } from "../write-back/index.js";
+/**
+ * Canonical list of table names synced via Electric and tracked by the
+ * write-back service. Used by both syncShapesToTables (read path) and
+ * PgliteDatabaseAdapter (write path) so the two stay in sync.
+ */
+export declare const SYNCED_TABLE_NAMES: readonly ["agents", "entities", "worlds", "rooms", "participants", "memories", "relationships", "tasks"];
+/**
+ * Runtime sync status of the Electric Sync client wired into PGlite.
+ * - syncing: the sync stream is connecting or catching up with the source.
+ * - synced: the local PGlite is up-to-date with the Electric source.
+ * - error: the sync stream encountered a non-recoverable error.
+ * - disabled: no ELIZA_ELECTRIC_SYNC_URL was configured at boot.
+ */
+export type PgliteSyncStatus = "syncing" | "synced" | "error" | "disabled";
+/** Per-table sync state. */
+export type PgliteSyncTableState = "pending" | "synced" | "error";
+/** Per-table status map exposed by getSyncStatus(). */
+export type PgliteSyncTableStatus = Record<string, {
+    state: PgliteSyncTableState;
+    error?: string;
+}>;
+/**
+ * Result row type for live queries. Matches the shape returned by
+ * {@link https://pglite.dev/docs/live-queries | pg.live.query()}.
+ */
+export interface LiveQueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    fields: {
+        name: string;
+        dataTypeID: number;
+    }[];
+    affectedRows?: number;
+}
+/**
+ * Return value from {@link https://pglite.dev/docs/live-queries | pg.live.query()}.
+ */
+export interface LiveQueryReturn<T = Record<string, unknown>> {
+    initialResults: LiveQueryResult<T>;
+    unsubscribe: () => Promise<void>;
+    refresh: (options?: {
+        offset?: number;
+        limit?: number;
+    }) => Promise<void>;
+}
+/**
+ * The `pg.live` namespace added by the `@electric-sql/pglite/live` extension.
+ */
+export interface LiveNamespace {
+    query<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, callback: (result: LiveQueryResult<T>) => void): Promise<LiveQueryReturn<T>>;
+    incrementalQuery<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, key: string, callback: (result: LiveQueryResult<T>) => void): Promise<LiveQueryReturn<T>>;
+    changes<T = Record<string, unknown>>(sql: string, params: unknown[] | undefined, key: string, callback: (changes: unknown[]) => void): Promise<LiveQueryReturn<T>>;
+}
+export declare class PGliteClientManager implements IDatabaseClientManager<PGlite> {
+    private static readonly LOCK_STALE_MS;
+    private client;
+    private options;
+    private shuttingDown;
+    private initialized;
+    private initializePromise;
+    private lockFd;
+    private lockPath;
+    private syncUrl;
+    private agentId;
+    private syncStatus;
+    private syncError;
+    private syncUnsubscribe;
+    private syncTableStates;
+    private syncedTables;
+    private startSyncMutex;
+    private forceResyncMutex;
+    private writeBack;
+    constructor(options: PGliteOptions & {
+        syncUrl?: string;
+        agentId?: string;
+        writeBackBaseUrl?: string;
+        serviceKey?: string;
+    });
+    getConnection(): PGlite;
+    /**
+     * Access the write-back service for forwarding local writes to the
+     * cloud API. Returns null when write-back is not configured.
+     */
+    getWriteBack(): WriteBackService | null;
+    /**
+     * Notify the write-back service of a local write to a sync table.
+     * Called by the adapter after a successful write operation.
+     * No-op when write-back is not configured.
+     */
+    notifyWrite(table: string, operation: "insert" | "upsert" | "delete", row: Record<string, unknown>): void;
+    /**
+     * Current Electric Sync status.
+     * - "disabled": no ELIZA_ELECTRIC_SYNC_URL was configured.
+     * - "syncing": sync client is connecting or catching up.
+     * - "synced": local PGlite is up-to-date with the Electric source.
+     * - "error": sync encountered an error (see syncError).
+     *
+     * Also returns per-table state so operators can see which specific
+     * tables are healthy vs errored vs still pending.
+     */
+    getSyncStatus(): {
+        status: PgliteSyncStatus;
+        error: string | null;
+        tables: PgliteSyncTableStatus;
+        synced: string[];
+    };
+    isShuttingDown(): boolean;
+    isInitialized(): boolean;
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    private setupShutdownHandlers;
+    private createClient;
+    private getDataDir;
+    private isFileBackedDataDir;
+    private getDataDirLockPath;
+    private getLockInfo;
+    /**
+     * Decide whether an existing lock should be honored as held by a live owner.
+     *
+     * Single-writer safety comes first: a *confirmed-running* PID is always
+     * honored, regardless of how old its `createdAt` is. A long-running agent
+     * (days or weeks of uptime) must never have its live lock reclaimed by a
+     * second manager — that would open a dual-writer window, which is
+     * unrecoverable, whereas a falsely-bricked boot is recoverable by removing
+     * the lock file. This matches the sibling `reconcilePglitePidFile`, which
+     * also treats a live PID as "active".
+     *
+     * The staleness window only rescues the *unconfirmable* case. A bare
+     * `process.kill(pid, 0)` is vulnerable to PID reuse, and a recycled
+     * cross-user PID surfaces as `EPERM` (or another non-`ESRCH` error) rather
+     * than a clean success. For those we cannot prove the PID belongs to a live
+     * Eliza process, so we fall back to `createdAt`: a recent lock is still
+     * respected, but one older than `LOCK_STALE_MS` (or with no usable timestamp)
+     * is treated as stale and reclaimed so an aliased PID cannot brick boot
+     * forever. `ESRCH` is unambiguous — the process is gone and the lock is stale.
+     */
+    private isLockActive;
+    private acquireDataDirLockIfNeeded;
+    private releaseDataDirLock;
+    private getErrorText;
+    private reconcilePglitePidFile;
+    private createActiveLockError;
+    private createManualResetRequiredError;
+    private queryMigrationsSchema;
+    /**
+     * Ensure the Electric Sync stream is started. Idempotent — safe to call
+     * on every database operation. The first call after PGlite is initialized
+     * and after migrations have created the target tables will start the sync
+     * stream; subsequent calls are no-ops.
+     *
+     * This is deliberately separate from {@link initialize} because the Drizzle
+     * migrations that create the target tables run AFTER plugin init completes.
+     * Starting sync during init would try to insert into non-existent tables.
+     */
+    ensureSync(): Promise<void>;
+    /**
+     * Access the PGlite live query namespace for reactive queries that
+     * push updated results whenever the underlying tables change. Useful
+     * for dashboard health endpoints and real-time monitoring.
+     *
+     * Returns the {@link https://pglite.dev/docs/live-queries | pg.live}
+     * namespace, which provides:
+     *   - `live.query(sql, params, callback)` — simple live query
+     *   - `live.incrementalQuery(sql, params, key, callback)` — diff-based
+     *   - `live.changes(sql, params, key, callback)` — raw change stream
+     *
+     * Returns null when PGlite extensions are disabled.
+     */
+    liveQuery(): LiveNamespace | null;
+    /**
+     * Force-reset the Electric Sync stream: unsubscribe, drop all internal
+     * sync state from the `electric` schema, and restart from scratch.
+     *
+     * Use this when operators diagnose a split-brain scenario (local PGlite
+     * has diverged from the source Postgres) or when the sync stream is
+     * stuck in an unrecoverable error state. The local data in the synced
+     * tables is preserved — only the Electric metadata tables are dropped,
+     * forcing a full re-sync that reconstructs state from the source.
+     *
+     * Returns the sync status after the reset. When sync is not configured
+     * (no ELIZA_ELECTRIC_SYNC_URL), returns null.
+     */
+    forceResync(): Promise<{
+        status: PgliteSyncStatus;
+        error: string | null;
+        tables: PgliteSyncTableStatus;
+        synced: string[];
+    } | null>;
+    private forceResyncInternal;
+    /**
+     * Start the Electric Sync stream after PGlite is initialized.
+     * Uses the official multi-table {@link https://pglite.dev/docs/sync#multi-table-sync | syncShapesToTables}
+     * API so all shape updates that happened in a single Postgres transaction
+     * are applied in a single PGlite transaction, preserving consistency
+     * across all runtime tables.
+     *
+     * Each shape is filtered by agent_id so that in a shared-Neon deployment
+     * an agent only syncs its own data — preserving per-agent physical isolation
+     * even though the source Postgres is multi-tenant.
+     *
+     * Sync failures are non-fatal: the agent runs on its local PGlite
+     * regardless of sync health. Per-table error state is tracked so
+     * operators can diagnose individual table issues without assuming
+     * the entire sync is broken.
+     */
+    private startSync;
+    /** Internal body of startSync, extracted so the mutex wraps only the
+     *  syncShapesToTables call, not the early-return guards. */
+    private startSyncInternal;
+    private initializeInternal;
+}

package/src/dist/rls.d.ts

@@ -0,0 +1,13 @@
+import { type IDatabaseAdapter } from "@elizaos/core";
+export declare function installRLSFunctions(adapter: IDatabaseAdapter): Promise<void>;
+export declare function getOrCreateRlsServer(adapter: IDatabaseAdapter, serverId: string): Promise<string>;
+export declare function setServerContext(adapter: IDatabaseAdapter, serverId: string): Promise<void>;
+export declare function assignAgentToServer(adapter: IDatabaseAdapter, agentId: string, serverId: string): Promise<void>;
+/**
+ * Apply RLS to all tables by calling PostgreSQL function
+ */
+export declare function applyRLSToNewTables(adapter: IDatabaseAdapter): Promise<void>;
+export declare function uninstallRLS(adapter: IDatabaseAdapter): Promise<void>;
+export declare function installEntityRLS(adapter: IDatabaseAdapter): Promise<void>;
+export declare function applyEntityRLSToAllTables(adapter: IDatabaseAdapter): Promise<void>;
+export declare function uninstallEntityRLS(adapter: IDatabaseAdapter): Promise<void>;

package/src/dist/runtime-migrator/crypto-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Browser-compatible crypto utilities
+ * Uses the Web Crypto API which is available in both browsers and Node.js
+ */
+/**
+ * Simple synchronous hash function for change detection
+ * This is NOT cryptographic - it's just for comparing snapshots
+ * Uses djb2 hash algorithm for speed and simplicity
+ */
+export declare function simpleHash(str: string): string;
+/**
+ * Create a longer hash by combining multiple passes
+ * This provides better distribution for larger inputs
+ */
+export declare function extendedHash(str: string): string;
+/**
+ * Async SHA-256 hash using Web Crypto API
+ * Works in both browsers and Node.js (v15+)
+ */
+export declare function sha256Async(data: string): Promise<string>;
+/**
+ * Generate a stable bigint from a string for advisory lock IDs
+ * Uses a simple hash that produces consistent results across runs
+ */
+export declare function stringToBigInt(str: string): bigint;

package/src/dist/runtime-migrator/drizzle-adapters/database-introspector.d.ts

@@ -0,0 +1,58 @@
+import type { DrizzleDB, SchemaSnapshot } from "../types.js";
+/**
+ * Introspect the current database state and generate a snapshot
+ * This is used when no previous snapshot exists for a plugin
+ * to capture the existing database state before migrations
+ */
+export declare class DatabaseIntrospector {
+    private db;
+    constructor(db: DrizzleDB);
+    /**
+     * Introspect all tables in the database and generate a snapshot
+     * @param schemaName - Schema to introspect (default: 'public')
+     * @returns Schema snapshot of current database state
+     */
+    introspectSchema(schemaName?: string): Promise<SchemaSnapshot>;
+    /**
+     * Get all tables in a schema
+     */
+    private getTables;
+    /**
+     * Get columns for a table
+     */
+    private getColumns;
+    /**
+     * Get indexes for a table
+     */
+    private getIndexes;
+    /**
+     * Get foreign keys for a table
+     */
+    private getForeignKeys;
+    /**
+     * Get primary keys for a table
+     */
+    private getPrimaryKeys;
+    /**
+     * Get unique constraints for a table
+     */
+    private getUniqueConstraints;
+    /**
+     * Get check constraints for a table
+     */
+    private getCheckConstraints;
+    /**
+     * Get enums in a schema
+     */
+    private getEnums;
+    /**
+     * Parse default value for a column
+     */
+    private parseDefault;
+    /**
+     * Check if tables exist for a plugin by checking if any tables exist in its schema
+     * @param pluginName - Name of the plugin
+     * @returns True if tables exist, false otherwise
+     */
+    hasExistingTables(pluginName: string): Promise<boolean>;
+}

package/src/dist/runtime-migrator/drizzle-adapters/diff-calculator.d.ts

@@ -0,0 +1,77 @@
+import type { SchemaCheckConstraint, SchemaColumn, SchemaForeignKey, SchemaIndex, SchemaSnapshot, SchemaUniqueConstraint } from "../types.js";
+export interface ColumnChanges {
+    typeChanged?: boolean;
+    prevType?: string;
+    newType?: string;
+    nullabilityChanged?: boolean;
+    wasNullable?: boolean;
+    isNullable?: boolean;
+    defaultChanged?: boolean;
+    prevDefault?: string | number | boolean;
+    newDefault?: string | number | boolean;
+    from?: SchemaColumn;
+    to?: SchemaColumn;
+}
+export interface TableChanges {
+    columnsAdded: string[];
+    columnsDeleted: string[];
+    columnsModified: string[];
+}
+export interface SchemaDiff {
+    tables: {
+        created: string[];
+        deleted: string[];
+        modified: Array<{
+            name: string;
+            changes: TableChanges;
+        }>;
+    };
+    columns: {
+        added: Array<{
+            table: string;
+            column: string;
+            definition: SchemaColumn;
+        }>;
+        deleted: Array<{
+            table: string;
+            column: string;
+        }>;
+        modified: Array<{
+            table: string;
+            column: string;
+            changes: ColumnChanges;
+        }>;
+    };
+    indexes: {
+        created: SchemaIndex[];
+        deleted: SchemaIndex[];
+        altered: Array<{
+            old: SchemaIndex;
+            new: SchemaIndex;
+        }>;
+    };
+    foreignKeys: {
+        created: SchemaForeignKey[];
+        deleted: SchemaForeignKey[];
+        altered: Array<{
+            old: SchemaForeignKey;
+            new: SchemaForeignKey;
+        }>;
+    };
+    uniqueConstraints: {
+        created: SchemaUniqueConstraint[];
+        deleted: SchemaUniqueConstraint[];
+    };
+    checkConstraints: {
+        created: SchemaCheckConstraint[];
+        deleted: SchemaCheckConstraint[];
+    };
+}
+/**
+ * Calculate the difference between two snapshots
+ */
+export declare function calculateDiff(previousSnapshot: SchemaSnapshot | null, currentSnapshot: SchemaSnapshot): Promise<SchemaDiff>;
+/**
+ * Check if a diff has any changes
+ */
+export declare function hasDiffChanges(diff: SchemaDiff): boolean;

package/src/dist/runtime-migrator/drizzle-adapters/snapshot-generator.d.ts

@@ -0,0 +1,21 @@
+import type { SchemaSnapshot } from "../types.js";
+type DrizzleSchema = Record<string, unknown>;
+/**
+ * Generate a snapshot from a Drizzle schema
+ * This is a port of Drizzle's pgSerializer.generatePgSnapshot
+ */
+export declare function generateSnapshot(schema: DrizzleSchema): Promise<SchemaSnapshot>;
+/**
+ * Calculate hash of a snapshot for change detection
+ * Uses a browser-compatible hash function
+ */
+export declare function hashSnapshot(snapshot: SchemaSnapshot): string;
+/**
+ * Create an empty snapshot for initial migration
+ */
+export declare function createEmptySnapshot(): SchemaSnapshot;
+/**
+ * Compare two snapshots and detect if there are changes
+ */
+export declare function hasChanges(previousSnapshot: SchemaSnapshot | null, currentSnapshot: SchemaSnapshot): boolean;
+export {};

package/src/dist/runtime-migrator/drizzle-adapters/sql-generator.d.ts

@@ -0,0 +1,38 @@
+import type { SchemaSnapshot } from "../types.js";
+import type { SchemaDiff } from "./diff-calculator.js";
+/**
+ * Data loss detection result
+ * Based on Drizzle's pgPushUtils approach
+ */
+export interface DataLossCheck {
+    hasDataLoss: boolean;
+    tablesToRemove: string[];
+    columnsToRemove: string[];
+    tablesToTruncate: string[];
+    typeChanges: Array<{
+        table: string;
+        column: string;
+        from: string;
+        to: string;
+    }>;
+    warnings: string[];
+    requiresConfirmation: boolean;
+}
+/**
+ * Check for potential data loss in schema changes
+ * Based on Drizzle's pgSuggestions function
+ */
+export declare function checkForDataLoss(diff: SchemaDiff): DataLossCheck;
+/**
+ * Generate SQL statements from a schema diff
+ * This follows Drizzle's approach: create all tables first, then add foreign keys
+ */
+export declare function generateMigrationSQL(previousSnapshot: SchemaSnapshot | null, currentSnapshot: SchemaSnapshot, diff?: SchemaDiff): Promise<string[]>;
+/**
+ * Generate SQL for renaming a table
+ */
+export declare function generateRenameTableSQL(oldName: string, newName: string): string;
+/**
+ * Generate SQL for renaming a column
+ */
+export declare function generateRenameColumnSQL(table: string, oldName: string, newName: string): string;

package/src/dist/runtime-migrator/extension-manager.d.ts

@@ -0,0 +1,6 @@
+import type { DrizzleDB } from "./types.js";
+export declare class ExtensionManager {
+    private db;
+    constructor(db: DrizzleDB);
+    installRequiredExtensions(extensions: string[]): Promise<void>;
+}

package/src/dist/runtime-migrator/index.d.ts

@@ -0,0 +1,8 @@
+export { calculateDiff, hasDiffChanges, type SchemaDiff, } from "./drizzle-adapters/diff-calculator.js";
+export { createEmptySnapshot, generateSnapshot, hasChanges, hashSnapshot, } from "./drizzle-adapters/snapshot-generator.js";
+export { generateMigrationSQL, generateRenameColumnSQL, generateRenameTableSQL, } from "./drizzle-adapters/sql-generator.js";
+export { RuntimeMigrator } from "./runtime-migrator.js";
+export { JournalStorage } from "./storage/journal-storage.js";
+export { MigrationTracker } from "./storage/migration-tracker.js";
+export { SnapshotStorage } from "./storage/snapshot-storage.js";
+export * from "./types.js";