@elizaos/plugin-sql 2.0.0-beta.1 → 2.0.11-beta.7

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

@@ -1,42 +0,0 @@
-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";
-import { type EmbeddingDimensionColumn } from "../schema/embedding";
-import type { PostgresConnectionManager } from "./manager";
-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

@@ -1,17 +0,0 @@
-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/pglite/adapter.d.ts

@@ -1,24 +0,0 @@
-import type { PGlite } from "@electric-sql/pglite";
-import { type Agent, type Entity, type Memory, type UUID } from "@elizaos/core";
-import { type PgliteDatabase } from "drizzle-orm/pglite";
-import { BaseDrizzleAdapter } from "../base";
-import { type EmbeddingDimensionColumn } from "../schema/embedding";
-import type { PGliteClientManager } from "./manager";
-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;
-}

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

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

@@ -1,32 +0,0 @@
-import { PGlite, type PGliteOptions } from "@electric-sql/pglite";
-import type { IDatabaseClientManager } from "../types";
-export declare class PGliteClientManager implements IDatabaseClientManager<PGlite> {
-    private client;
-    private options;
-    private shuttingDown;
-    private initialized;
-    private initializePromise;
-    private lockFd;
-    private lockPath;
-    constructor(options: PGliteOptions);
-    getConnection(): PGlite;
-    isShuttingDown(): boolean;
-    isInitialized(): boolean;
-    initialize(): Promise<void>;
-    close(): Promise<void>;
-    private setupShutdownHandlers;
-    private createClient;
-    private getDataDir;
-    private isFileBackedDataDir;
-    private getDataDirLockPath;
-    private getLockPid;
-    private isPidRunning;
-    private acquireDataDirLockIfNeeded;
-    private releaseDataDirLock;
-    private getErrorText;
-    private reconcilePglitePidFile;
-    private createActiveLockError;
-    private createManualResetRequiredError;
-    private queryMigrationsSchema;
-    private initializeInternal;
-}

package/src/dist/rls.d.ts

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

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

@@ -1,58 +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>;
-}

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

@@ -1,77 +0,0 @@
-import type { SchemaCheckConstraint, SchemaColumn, SchemaForeignKey, SchemaIndex, SchemaSnapshot, SchemaUniqueConstraint } from "../types";
-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

@@ -1,21 +0,0 @@
-import type { SchemaSnapshot } from "../types";
-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

@@ -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/src/dist/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/src/dist/runtime-migrator/index.d.ts

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

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

@@ -1,95 +0,0 @@
-import { type DataLossCheck } from "./drizzle-adapters/sql-generator";
-import type { DrizzleDB, RuntimeMigrationOptions } from "./types";
-export declare class RuntimeMigrator {
-    private db;
-    private migrationTracker;
-    private journalStorage;
-    private snapshotStorage;
-    private extensionManager;
-    private introspector;
-    constructor(db: DrizzleDB);
-    /**
-     * Get expected schema name for a plugin
-     * @elizaos/plugin-sql uses 'public' schema (core application)
-     * All other plugins should use namespaced schemas
-     */
-    private getExpectedSchemaName;
-    /**
-     * Ensure all schemas used in the snapshot exist
-     */
-    private ensureSchemasExist;
-    /**
-     * Validate schema usage and provide warnings
-     */
-    private validateSchemaUsage;
-    /**
-     * Generate a stable advisory lock ID from plugin name
-     * PostgreSQL advisory locks use bigint, so we need to hash the plugin name
-     * and convert to a stable bigint value
-     * Uses browser-compatible hashing
-     */
-    private getAdvisoryLockId;
-    /**
-     * Validate that a value is a valid PostgreSQL bigint
-     * PostgreSQL bigint range: -9223372036854775808 to 9223372036854775807
-     */
-    private validateBigInt;
-    /**
-     * Detect if a connection string represents a real PostgreSQL database
-     * (not PGLite, in-memory, or other non-PostgreSQL databases)
-     */
-    private isRealPostgresDatabase;
-    /**
-     * Initialize migration system - create necessary tables
-     * @throws Error if table creation fails
-     */
-    initialize(): Promise<void>;
-    /**
-     * Run migrations for a plugin/schema
-     * @param pluginName - Plugin identifier
-     * @param schema - Drizzle schema object
-     * @param options - Migration options (verbose, force, dryRun, allowDataLoss)
-     * @throws Error if destructive migrations blocked or migration fails
-     */
-    migrate(pluginName: string, schema: Record<string, unknown>, options?: RuntimeMigrationOptions): Promise<void>;
-    /**
-     * Execute migration in a transaction
-     */
-    private executeMigration;
-    /**
-     * Generate migration tag (like 0000_jazzy_shard)
-     */
-    private generateMigrationTag;
-    /**
-     * Get migration status for a plugin
-     * @param pluginName - Plugin identifier
-     * @returns Migration history and current state
-     */
-    getStatus(pluginName: string): Promise<{
-        hasRun: boolean;
-        lastMigration: {
-            id: number;
-            hash: string;
-            created_at: string;
-        } | null;
-        journal: {
-            version: string;
-            dialect: string;
-            entries: unknown[];
-        } | null;
-        snapshots: number;
-    }>;
-    /**
-     * Reset migrations for a plugin (dangerous - for development only)
-     * @param pluginName - Plugin identifier
-     * @warning Deletes all migration history - use only in development
-     */
-    reset(pluginName: string): Promise<void>;
-    /**
-     * Check if a migration would cause data loss without executing it
-     * @param pluginName - Plugin identifier
-     * @param schema - Drizzle schema to check
-     * @returns Data loss analysis or null if no changes
-     */
-    checkMigration(pluginName: string, schema: Record<string, unknown>): Promise<DataLossCheck | null>;
-}

package/src/dist/runtime-migrator/schema-transformer.d.ts

@@ -1,18 +0,0 @@
-type DrizzleSchema = Record<string, unknown>;
-/**
- * Transform a plugin's schema to use the appropriate namespace
- *
- * @elizaos/plugin-sql uses 'public' schema (no transformation)
- * Other plugins get their tables wrapped in a namespaced schema
- */
-export declare function transformPluginSchema(pluginName: string, schema: DrizzleSchema): DrizzleSchema;
-/**
- * Derive a valid PostgreSQL schema name from a plugin name
- */
-export declare function deriveSchemaName(pluginName: string): string;
-/**
- * Create a namespaced schema helper for plugins
- * This is what plugins should ideally use to define their tables
- */
-export declare function createPluginSchema(pluginName: string): import("drizzle-orm/pg-core").PgSchema<string>;
-export {};

package/src/dist/runtime-migrator/storage/journal-storage.d.ts

@@ -1,10 +0,0 @@
-import type { DrizzleDB, Journal, JournalEntry } from "../types";
-export declare class JournalStorage {
-    private db;
-    constructor(db: DrizzleDB);
-    loadJournal(pluginName: string): Promise<Journal | null>;
-    saveJournal(pluginName: string, journal: Journal): Promise<void>;
-    addEntry(pluginName: string, entry: JournalEntry): Promise<void>;
-    getNextIdx(pluginName: string): Promise<number>;
-    updateJournal(pluginName: string, idx: number, tag: string, breakpoints?: boolean): Promise<void>;
-}

package/src/dist/runtime-migrator/storage/migration-tracker.d.ts

@@ -1,13 +0,0 @@
-import type { DrizzleDB } from "../types";
-export declare class MigrationTracker {
-    private db;
-    constructor(db: DrizzleDB);
-    ensureSchema(): Promise<void>;
-    ensureTables(): Promise<void>;
-    getLastMigration(pluginName: string): Promise<{
-        id: number;
-        hash: string;
-        created_at: string;
-    } | null>;
-    recordMigration(pluginName: string, hash: string, createdAt: number): Promise<void>;
-}

package/src/dist/runtime-migrator/storage/snapshot-storage.d.ts

@@ -1,9 +0,0 @@
-import type { DrizzleDB, SchemaSnapshot } from "../types";
-export declare class SnapshotStorage {
-    private db;
-    constructor(db: DrizzleDB);
-    saveSnapshot(pluginName: string, idx: number, snapshot: SchemaSnapshot): Promise<void>;
-    loadSnapshot(pluginName: string, idx: number): Promise<SchemaSnapshot | null>;
-    getLatestSnapshot(pluginName: string): Promise<SchemaSnapshot | null>;
-    getAllSnapshots(pluginName: string): Promise<SchemaSnapshot[]>;
-}