@elizaos/plugin-sql 1.6.5-alpha.13 → 1.6.5-alpha.15

package/dist/node/src/index.d.ts

@@ -1,33 +0,0 @@
-import type { IDatabaseAdapter, UUID } from '@elizaos/core';
-import { type Plugin } from '@elizaos/core';
-import * as schema from './schema';
-/**
- * Creates a database adapter based on the provided configuration.
- * If a postgresUrl is provided in the config, a PgDatabaseAdapter is initialized using the PostgresConnectionManager.
- * If no postgresUrl is provided, a PgliteDatabaseAdapter is initialized using PGliteClientManager with the dataDir from the config.
- *
- * @param {object} config - The configuration object.
- * @param {string} [config.dataDir] - The directory where data is stored. Defaults to "./.eliza/.elizadb".
- * @param {string} [config.postgresUrl] - The URL for the PostgreSQL database.
- * @param {UUID} agentId - The unique identifier for the agent.
- * @returns {IDatabaseAdapter} The created database adapter.
- */
-export declare function createDatabaseAdapter(config: {
-    dataDir?: string;
-    postgresUrl?: string;
-}, agentId: UUID): IDatabaseAdapter;
-/**
- * SQL plugin for database adapter using Drizzle ORM with dynamic plugin schema migrations
- *
- * @typedef {Object} Plugin
- * @property {string} name - The name of the plugin
- * @property {string} description - The description of the plugin
- * @property {Function} init - The initialization function for the plugin
- * @param {any} _ - Input parameter
- * @param {IAgentRuntime} runtime - The runtime environment for the agent
- */
-export declare const plugin: Plugin;
-export default plugin;
-export { DatabaseMigrationService } from './migration-service';
-export { installRLSFunctions, getOrCreateRlsServer, setServerContext, assignAgentToServer, applyRLSToNewTables, uninstallRLS, } from './rls';
-export { schema };

package/dist/node/src/index.node.d.ts

@@ -1,10 +0,0 @@
-import type { IDatabaseAdapter, UUID } from '@elizaos/core';
-import { type Plugin } from '@elizaos/core';
-export declare function createDatabaseAdapter(config: {
-    dataDir?: string;
-    postgresUrl?: string;
-}, agentId: UUID): IDatabaseAdapter;
-export declare const plugin: Plugin;
-export default plugin;
-export { DatabaseMigrationService } from './migration-service';
-export { installRLSFunctions, getOrCreateRlsServer, setServerContext, assignAgentToServer, applyRLSToNewTables, uninstallRLS, } from './rls';

package/dist/node/src/migration-service.d.ts

@@ -1,43 +0,0 @@
-import { type Plugin } from '@elizaos/core';
-import { RuntimeMigrator } from './runtime-migrator';
-import type { DrizzleDatabase } from './types';
-export declare class DatabaseMigrationService {
-    private db;
-    private registeredSchemas;
-    private migrator;
-    constructor();
-    /**
-     * Initialize service with database connection
-     * @param db - Drizzle database instance
-     */
-    initializeWithDatabase(db: DrizzleDatabase): Promise<void>;
-    /**
-     * Auto-discover and register schemas from plugins
-     * @param plugins - Array of plugins to scan for schemas
-     */
-    discoverAndRegisterPluginSchemas(plugins: Plugin[]): void;
-    /**
-     * Register a schema for a specific plugin
-     * @param pluginName - Plugin identifier
-     * @param schema - Drizzle schema object
-     */
-    registerSchema(pluginName: string, schema: any): void;
-    /**
-     * Run migrations for all registered plugins
-     * @param options - Migration options
-     * @param options.verbose - Log detailed output (default: true in dev, false in prod)
-     * @param options.force - Allow destructive migrations
-     * @param options.dryRun - Preview changes without applying
-     * @throws Error if any migration fails or destructive changes blocked
-     */
-    runAllPluginMigrations(options?: {
-        verbose?: boolean;
-        force?: boolean;
-        dryRun?: boolean;
-    }): Promise<void>;
-    /**
-     * Get the runtime migrator instance for advanced operations
-     * @returns RuntimeMigrator instance or null if not initialized
-     */
-    getMigrator(): RuntimeMigrator | null;
-}

package/dist/node/src/migrations.d.ts

@@ -1,15 +0,0 @@
-import { type IDatabaseAdapter } from '@elizaos/core';
-/**
- * TEMPORARY MIGRATION: develop → feat/entity-rls migration
- *
- * This migration runs automatically on startup and is idempotent.
- * It handles the migration from Owner RLS to Server RLS + Entity RLS, including:
- * - Disabling old RLS policies temporarily
- * - Renaming server_id → message_server_id in channels, worlds, rooms
- * - Converting TEXT → UUID where needed
- * - Dropping old server_id columns for RLS
- * - Cleaning up indexes
- *
- * @param adapter - Database adapter
- */
-export declare function migrateToEntityRLS(adapter: IDatabaseAdapter): Promise<void>;

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

@@ -1,78 +0,0 @@
-import { type UUID, Agent, Entity, Memory, Component } from '@elizaos/core';
-import { BaseDrizzleAdapter } from '../base';
-import { type EmbeddingDimensionColumn } from '../schema/embedding';
-import type { PostgresConnectionManager } from './manager';
-/**
- * Adapter class for interacting with a PostgreSQL database.
- * Extends BaseDrizzleAdapter.
- */
-export declare class PgDatabaseAdapter extends BaseDrizzleAdapter {
-    protected embeddingDimension: EmbeddingDimensionColumn;
-    private manager;
-    constructor(agentId: UUID, manager: PostgresConnectionManager, _schema?: any);
-    getManager(): PostgresConnectionManager;
-    /**
-     * Execute a callback with entity context for Entity RLS
-     * Delegates to the manager's withEntityContext method
-     *
-     * This is a public method because it's part of the adapter's public API
-     * for operations that need entity-scoped database access.
-     */
-    withEntityContext<T>(entityId: UUID | null, callback: (tx: any) => Promise<T>): Promise<T>;
-    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    getMemoriesByServerId(_params: {
-        serverId: UUID;
-        count?: number;
-    }): Promise<Memory[]>;
-    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
-    /**
-     * Executes the provided operation with a database connection.
-     *
-     * @template T
-     * @param {() => Promise<T>} operation - The operation to be executed with the database connection.
-     * @returns {Promise<T>} A promise that resolves with the result of the operation.
-     */
-    protected withDatabase<T>(operation: () => Promise<T>): Promise<T>;
-    /**
-     * Asynchronously initializes the PgDatabaseAdapter by running migrations using the manager.
-     * Logs a success message if initialization is successful, otherwise logs an error message.
-     *
-     * @returns {Promise<void>} A promise that resolves when initialization is complete.
-     */
-    init(): Promise<void>;
-    /**
-     * Checks if the database connection is ready and active.
-     * @returns {Promise<boolean>} A Promise that resolves to true if the connection is healthy.
-     */
-    isReady(): Promise<boolean>;
-    /**
-     * Asynchronously closes the manager associated with this instance.
-     *
-     * @returns A Promise that resolves once the manager is closed.
-     */
-    close(): Promise<void>;
-    /**
-     * Asynchronously retrieves the connection from the manager.
-     *
-     * @returns {Promise<Pool>} A Promise that resolves with the connection.
-     */
-    getConnection(): Promise<import("pg").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<boolean>;
-    getEntitiesByIds(entityIds: UUID[]): Promise<Entity[]>;
-    updateEntity(entity: Entity): Promise<void>;
-    createMemory(memory: Memory, tableName: string): Promise<UUID>;
-    getMemoryById(memoryId: UUID): Promise<Memory | null>;
-    searchMemories(params: any): Promise<any[]>;
-    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/dist/node/src/pg/manager.d.ts

@@ -1,33 +0,0 @@
-import { type NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { Pool, type PoolClient } from 'pg';
-import { type UUID } from '@elizaos/core';
-export declare class PostgresConnectionManager {
-    private pool;
-    private db;
-    constructor(connectionString: string, rlsServerId?: string);
-    getDatabase(): NodePgDatabase;
-    getConnection(): Pool;
-    getClient(): Promise<PoolClient>;
-    testConnection(): Promise<boolean>;
-    /**
-     * Execute a query with entity context for Entity RLS.
-     * Sets app.entity_id before executing the callback.
-     *
-     * Server RLS context (if enabled) is already set via Pool's application_name.
-     *
-     * If Entity RLS is not installed (ENABLE_DATA_ISOLATION=false), this method
-     * gracefully degrades to executing the callback without setting entity context.
-     *
-     * @param entityId - The entity UUID to set as context (or null for server operations)
-     * @param callback - The database operations to execute with the entity context
-     * @returns The result of the callback
-     * @throws {Error} If the callback fails or if there's a critical Entity RLS configuration issue
-     */
-    withEntityContext<T>(entityId: UUID | null, callback: (tx: NodePgDatabase) => Promise<T>): Promise<T>;
-    /**
-     * Closes the connection pool.
-     * @returns {Promise<void>}
-     * @memberof PostgresConnectionManager
-     */
-    close(): Promise<void>;
-}

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

@@ -1,76 +0,0 @@
-import { type UUID, type Agent, type Entity, type Memory } from '@elizaos/core';
-import { BaseDrizzleAdapter } from '../base';
-import { type EmbeddingDimensionColumn } from '../schema/embedding';
-import type { PGliteClientManager } from './manager';
-/**
- * PgliteDatabaseAdapter class represents an adapter for interacting with a PgliteDatabase.
- * Extends BaseDrizzleAdapter.
- *
- * @constructor
- * @param {UUID} agentId - The ID of the agent.
- * @param {PGliteClientManager} manager - The manager for the Pglite client.
- *
- * @method withDatabase
- * @param {() => Promise<T>} operation - The operation to perform on the database.
- * @return {Promise<T>} - The result of the operation.
- *
- * @method init
- * @return {Promise<void>} - A Promise that resolves when the initialization is complete.
- *
- * @method close
- * @return {void} - A Promise that resolves when the database is closed.
- */
-export declare class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
-    private manager;
-    protected embeddingDimension: EmbeddingDimensionColumn;
-    /**
-     * Constructor for creating an instance of a class.
-     * @param {UUID} agentId - The unique identifier for the agent.
-     * @param {PGliteClientManager} manager - The manager for the Pglite client.
-     */
-    constructor(agentId: UUID, manager: PGliteClientManager);
-    /**
-     * Execute a callback with entity context for Entity RLS
-     * PGLite: No RLS support, just execute the callback in a simple transaction
-     *
-     * This is a public method because it's part of the adapter's public API
-     * for operations that need entity-scoped database access.
-     */
-    withEntityContext<T>(_entityId: UUID | null, callback: (tx: any) => Promise<T>): Promise<T>;
-    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    getMemoriesByServerId(_params: {
-        serverId: UUID;
-        count?: number;
-    }): Promise<Memory[]>;
-    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
-    /**
-     * Asynchronously runs the provided database operation while checking if the database is currently shutting down.
-     * If the database is shutting down, a warning is logged and null is returned.
-     *
-     * @param {Function} operation - The database operation to be performed.
-     * @returns {Promise<T>} A promise that resolves with the result of the database operation.
-     */
-    protected withDatabase<T>(operation: () => Promise<T>): Promise<T>;
-    /**
-     * Asynchronously initializes the database by running migrations.
-     *
-     * @returns {Promise<void>} A Promise that resolves when the database initialization is complete.
-     */
-    init(): Promise<void>;
-    /**
-     * Checks if the database connection is ready and active.
-     * For PGLite, this checks if the client is not in a shutting down state.
-     * @returns {Promise<boolean>} A Promise that resolves to true if the connection is healthy.
-     */
-    isReady(): Promise<boolean>;
-    /**
-     * Asynchronously closes the database.
-     */
-    close(): Promise<void>;
-    /**
-     * Asynchronously retrieves the connection from the client.
-     *
-     * @returns {Promise<PGlite>} A Promise that resolves with the connection.
-     */
-    getConnection(): Promise<import("@electric-sql/pglite").PGlite>;
-}

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

@@ -1,21 +0,0 @@
-import { PGlite, type PGliteOptions } from '@electric-sql/pglite';
-import type { IDatabaseClientManager } from '../types';
-/**
- * Class representing a database client manager for PGlite.
- * @implements { IDatabaseClientManager }
- */
-export declare class PGliteClientManager implements IDatabaseClientManager<PGlite> {
-    private client;
-    private shuttingDown;
-    /**
-     * Constructor for creating a new instance of PGlite with the provided options.
-     * Initializes the PGlite client with additional extensions.
-     * @param {PGliteOptions} options - The options to configure the PGlite client.
-     */
-    constructor(options: PGliteOptions);
-    getConnection(): PGlite;
-    isShuttingDown(): boolean;
-    initialize(): Promise<void>;
-    close(): Promise<void>;
-    private setupShutdownHandlers;
-}

package/dist/node/src/rls.d.ts

@@ -1,156 +0,0 @@
-import { type IDatabaseAdapter } from '@elizaos/core';
-/**
- * PostgreSQL Row-Level Security (RLS) for Multi-Server and Entity Isolation
- *
- * This module provides two layers of database-level security:
- *
- * 1. **Server RLS** - Multi-server isolation
- *    - Isolates data between different ElizaOS server instances
- *    - Uses `server_id` column added dynamically to all tables
- *    - Server context set via PostgreSQL `application_name` connection parameter
- *    - Prevents data leakage between different deployments/environments
- *
- * 2. **Entity RLS** - User/agent-level privacy isolation
- *    - Isolates data between different users (Clients (plugins/API) users)
- *    - Uses `entity_id`, `author_id`, or joins via `participants` table
- *    - Entity context set via `app.entity_id` transaction-local variable
- *    - Provides DM privacy and multi-user isolation within a server
- *
- * CRITICAL SECURITY REQUIREMENTS:
- * - RLS policies DO NOT apply to PostgreSQL superuser accounts
- * - Use a REGULAR (non-superuser) database user
- * - Grant only necessary permissions (CREATE, SELECT, INSERT, UPDATE, DELETE)
- * - NEVER use the 'postgres' superuser or any superuser account
- * - Superusers bypass ALL RLS policies by design, defeating the isolation mechanism
- *
- * ARCHITECTURE:
- * - Server RLS: Uses PostgreSQL `application_name` (set at connection pool level)
- * - Entity RLS: Uses `SET LOCAL app.entity_id` (set per transaction)
- * - Policies use FORCE ROW LEVEL SECURITY to enforce even for table owners
- * - Automatic index creation for performance (`server_id`, `entity_id`, `room_id`)
- *
- * @module rls
- */
-/**
- * Install PostgreSQL functions required for Server RLS and Entity RLS
- *
- * This function creates all necessary PostgreSQL stored procedures for both
- * Server RLS (multi-server isolation) and Entity RLS (user privacy isolation).
- *
- * **Server RLS Functions Created:**
- * - `current_server_id()` - Returns server UUID from `application_name`
- * - `add_server_isolation(schema, table)` - Adds Server RLS to a single table
- * - `apply_rls_to_all_tables()` - Applies Server RLS to all eligible tables
- *
- * **Entity RLS Functions Created:**
- * - `current_entity_id()` - Returns entity UUID from `app.entity_id` session variable
- * - `add_entity_isolation(schema, table)` - Adds Entity RLS to a single table
- * - `apply_entity_rls_to_all_tables()` - Applies Entity RLS to all eligible tables
- *
- * **Security Model:**
- * - Server RLS: Isolation between different ElizaOS instances (environments/deployments)
- * - Entity RLS: Isolation between different users within a server instance
- * - Both layers stack - a user can only see data from their server AND their accessible entities
- *
- * **Important Notes:**
- * - Must be called before `applyRLSToNewTables()` or `applyEntityRLSToAllTables()`
- * - Creates `servers` table if it doesn't exist
- * - Automatically calls `installEntityRLS()` to set up both layers
- * - Uses `%I` identifier quoting in format() to prevent SQL injection
- * - Policies use FORCE RLS to enforce even for table owners
- *
- * @param adapter - Database adapter with access to the Drizzle ORM instance
- * @returns Promise that resolves when all RLS functions are installed
- * @throws {Error} If database connection fails or SQL execution fails
- *
- * @example
- * ```typescript
- * // Install RLS functions on server startup
- * await installRLSFunctions(database);
- * await getOrCreateRlsServer(database, serverId);
- * await setServerContext(database, serverId);
- * await applyRLSToNewTables(database);
- * ```
- */
-export declare function installRLSFunctions(adapter: IDatabaseAdapter): Promise<void>;
-/**
- * Get or create RLS server using Drizzle ORM
- */
-export declare function getOrCreateRlsServer(adapter: IDatabaseAdapter, serverId: string): Promise<string>;
-/**
- * Set RLS context on PostgreSQL connection pool
- * This function validates that the server exists and has correct UUID format
- */
-export declare function setServerContext(adapter: IDatabaseAdapter, serverId: string): Promise<void>;
-/**
- * Assign agent to server using Drizzle ORM
- */
-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>;
-/**
- * Disable RLS globally
- * SIMPLE APPROACH:
- * - Disables RLS for ALL server instances
- * - Keeps server_id columns and data intact
- * - Use only in development or when migrating to single-server mode
- */
-export declare function uninstallRLS(adapter: IDatabaseAdapter): Promise<void>;
-/**
- * Install Entity RLS functions for user privacy isolation
- *
- * This provides database-level privacy between different entities (client users: Plugins/API)
- * interacting with agents, independent of JWT authentication.
- *
- * **How Entity RLS Works:**
- * - Each database transaction sets `app.entity_id` before querying
- * - Policies filter rows based on entity ownership or participant membership
- * - Two isolation strategies:
- *   1. Direct ownership: `entity_id` or `author_id` column matches `current_entity_id()`
- *   2. Shared access: `room_id`/`channel_id` exists in `participants` table for the entity
- *
- * **Performance Considerations:**
- * - **Subquery policies** (for `room_id`/`channel_id`) run on EVERY row access
- * - Indexes are automatically created on: `entity_id`, `author_id`, `room_id`, `channel_id`
- * - The `participants` table should have an index on `(entity_id, channel_id)`
- * - For large datasets (>1M rows), consider:
- *   - Materialized views for frequently accessed entity-filtered data
- *   - Partitioning large tables by date or entity_id
- *
- * **Optimization Tips:**
- * - Direct column policies (`entity_id = current_entity_id()`) are faster than subquery policies
- * - The `participants` lookup is cached per transaction but still requires index scans
- *
- * **Tables Excluded from Entity RLS:**
- * - `servers` - Server RLS table
- * - `users` - Authentication (no entity isolation)
- * - `entity_mappings` - Cross-platform entity mapping
- * - `drizzle_migrations`, `__drizzle_migrations` - Migration tracking
- *
- * @param adapter - Database adapter with access to the Drizzle ORM instance
- * @returns Promise that resolves when Entity RLS functions are installed
- * @throws {Error} If database connection fails or SQL execution fails
- *
- * @example
- * ```typescript
- * // Called automatically by installRLSFunctions()
- * await installRLSFunctions(database);
- *
- * // Or call separately if needed
- * await installEntityRLS(database);
- * await applyEntityRLSToAllTables(database);
- * ```
- */
-export declare function installEntityRLS(adapter: IDatabaseAdapter): Promise<void>;
-/**
- * Apply Entity RLS policies to all eligible tables
- * Call this after installEntityRLS() to activate the policies
- */
-export declare function applyEntityRLSToAllTables(adapter: IDatabaseAdapter): Promise<void>;
-/**
- * Remove Entity RLS (for rollback or testing)
- * Drops entity RLS functions and policies but keeps server RLS intact
- */
-export declare function uninstallEntityRLS(adapter: IDatabaseAdapter): Promise<void>;

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

@@ -1,62 +0,0 @@
-import type { DrizzleDB, SchemaSnapshot } from '../types';
-/**
- * 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>;
-    /**
-     * Derive schema name from plugin name
-     */
-    private deriveSchemaName;
-}

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

@@ -1,59 +0,0 @@
-import type { SchemaSnapshot } from '../types';
-export interface SchemaDiff {
-    tables: {
-        created: string[];
-        deleted: string[];
-        modified: Array<{
-            name: string;
-            changes: any;
-        }>;
-    };
-    columns: {
-        added: Array<{
-            table: string;
-            column: string;
-            definition: any;
-        }>;
-        deleted: Array<{
-            table: string;
-            column: string;
-        }>;
-        modified: Array<{
-            table: string;
-            column: string;
-            changes: any;
-        }>;
-    };
-    indexes: {
-        created: any[];
-        deleted: any[];
-        altered: Array<{
-            old: any;
-            new: any;
-        }>;
-    };
-    foreignKeys: {
-        created: any[];
-        deleted: any[];
-        altered: Array<{
-            old: any;
-            new: any;
-        }>;
-    };
-    uniqueConstraints: {
-        created: any[];
-        deleted: any[];
-    };
-    checkConstraints: {
-        created: any[];
-        deleted: any[];
-    };
-}
-/**
- * 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/dist/node/src/runtime-migrator/drizzle-adapters/snapshot-generator.d.ts

@@ -1,18 +0,0 @@
-import type { SchemaSnapshot } from '../types';
-/**
- * Generate a snapshot from a Drizzle schema
- * This is a port of Drizzle's pgSerializer.generatePgSnapshot
- */
-export declare function generateSnapshot(schema: any): Promise<SchemaSnapshot>;
-/**
- * Calculate hash of a snapshot for change detection
- */
-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;

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

@@ -1,38 +0,0 @@
-import type { SchemaSnapshot } from '../types';
-import type { SchemaDiff } from './diff-calculator';
-/**
- * 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/dist/node/src/runtime-migrator/extension-manager.d.ts

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

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

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