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

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

@@ -0,0 +1,95 @@
+import { type DataLossCheck } from "./drizzle-adapters/sql-generator.js";
+import type { DrizzleDB, RuntimeMigrationOptions } from "./types.js";
+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

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

@@ -0,0 +1,10 @@
+import type { DrizzleDB, Journal, JournalEntry } from "../types.js";
+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

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

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

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

@@ -0,0 +1,157 @@
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { PgliteDatabase } from "drizzle-orm/pglite";
+export type DrizzleDB = NodePgDatabase | PgliteDatabase;
+export interface Journal {
+    version: string;
+    dialect: string;
+    entries: JournalEntry[];
+}
+export interface JournalEntry {
+    idx: number;
+    version: string;
+    when: number;
+    tag: string;
+    breakpoints: boolean;
+}
+export interface MigrationMeta {
+    sql: string[];
+    folderMillis: number;
+    hash: string;
+    bps: boolean;
+}
+export interface SchemaColumn {
+    name: string;
+    type: string;
+    primaryKey?: boolean;
+    notNull?: boolean;
+    default?: string | number | boolean;
+    isUnique?: boolean;
+    uniqueName?: string;
+    uniqueType?: string;
+}
+export interface IndexColumn {
+    expression: string;
+    isExpression: boolean;
+    asc?: boolean;
+    nulls?: string;
+}
+export interface SchemaIndex {
+    name: string;
+    columns: IndexColumn[];
+    isUnique: boolean;
+    method?: string;
+    where?: string;
+    concurrently?: boolean;
+}
+export interface SchemaForeignKey {
+    name: string;
+    tableFrom: string;
+    schemaFrom?: string;
+    tableTo: string;
+    schemaTo: string;
+    columnsFrom: string[];
+    columnsTo: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
+export interface SchemaPrimaryKey {
+    name: string;
+    columns: string[];
+}
+export interface SchemaUniqueConstraint {
+    name: string;
+    columns: string[];
+    nullsNotDistinct?: boolean;
+}
+export interface SchemaCheckConstraint {
+    name: string;
+    value: string;
+}
+export interface SchemaTable {
+    name: string;
+    schema: string;
+    columns: Record<string, SchemaColumn>;
+    indexes: Record<string, SchemaIndex>;
+    foreignKeys: Record<string, SchemaForeignKey>;
+    compositePrimaryKeys: Record<string, SchemaPrimaryKey>;
+    uniqueConstraints: Record<string, SchemaUniqueConstraint>;
+    checkConstraints: Record<string, SchemaCheckConstraint>;
+}
+export interface SchemaEnum {
+    name: string;
+    schema: string;
+    values: string[];
+}
+export interface SchemaMeta {
+    schemas: Record<string, string>;
+    tables: Record<string, string>;
+    columns: Record<string, string>;
+}
+export interface SchemaSnapshot {
+    version: string;
+    dialect: string;
+    tables: Record<string, SchemaTable>;
+    schemas: Record<string, string>;
+    enums?: Record<string, SchemaEnum>;
+    _meta: SchemaMeta;
+    internal?: Record<string, unknown>;
+}
+export interface TableInfoRow {
+    table_schema: string;
+    table_name: string;
+}
+export interface ColumnInfoRow {
+    column_name: string;
+    is_nullable: string;
+    data_type: string;
+    column_default: string | null;
+    is_primary: boolean;
+}
+export interface IndexInfoRow {
+    name: string;
+    is_unique: boolean;
+    is_primary: boolean;
+    is_unique_constraint?: boolean;
+    columns: string[];
+    method?: string;
+}
+export interface ForeignKeyInfoRow {
+    name: string;
+    column_name: string;
+    foreign_table_name: string;
+    foreign_table_schema: string;
+    foreign_column_name: string;
+    delete_rule: string;
+    update_rule: string;
+}
+export interface PrimaryKeyInfoRow {
+    name: string;
+    columns: string[];
+}
+export interface UniqueConstraintInfoRow {
+    name: string;
+    columns: string[];
+}
+export interface CheckConstraintInfoRow {
+    name: string;
+    definition: string;
+}
+export interface EnumInfoRow {
+    schema: string;
+    name: string;
+    value: string;
+}
+export interface MigrationOptions {
+    migrationsTable?: string;
+    migrationsSchema?: string;
+}
+export interface RuntimeMigrationOptions {
+    /** Run without executing SQL statements */
+    dryRun?: boolean;
+    /** Log detailed information about the migration */
+    verbose?: boolean;
+    /** Force migration even in production with destructive changes */
+    force?: boolean;
+    /** Allow operations that will cause data loss (tables/columns being dropped) */
+    allowDataLoss?: boolean;
+}

package/src/dist/schema/agent.d.ts

@@ -0,0 +1,344 @@
+import type { MessageExample } from "@elizaos/core";
+/**
+ * Represents a table for storing agent data.
+ *
+ * @type {Table}
+ */
+export declare const agentTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "agents";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "agents";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        server_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "server_id";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "agents";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "agents";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        username: import("drizzle-orm/pg-core").PgColumn<{
+            name: "username";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        system: import("drizzle-orm/pg-core").PgColumn<{
+            name: "system";
+            tableName: "agents";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        bio: import("drizzle-orm/pg-core").PgColumn<{
+            name: "bio";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string | string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string | string[];
+        }>;
+        messageExamples: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message_examples";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: MessageExample[][];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: MessageExample[][];
+        }>;
+        postExamples: import("drizzle-orm/pg-core").PgColumn<{
+            name: "post_examples";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        topics: import("drizzle-orm/pg-core").PgColumn<{
+            name: "topics";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        adjectives: import("drizzle-orm/pg-core").PgColumn<{
+            name: "adjectives";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        knowledge: import("drizzle-orm/pg-core").PgColumn<{
+            name: "knowledge";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: (string | {
+                path: string;
+                shared?: boolean;
+            })[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: (string | {
+                path: string;
+                shared?: boolean;
+            })[];
+        }>;
+        plugins: import("drizzle-orm/pg-core").PgColumn<{
+            name: "plugins";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        settings: import("drizzle-orm/pg-core").PgColumn<{
+            name: "settings";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                [key: string]: string | number | boolean | Record<string, unknown> | undefined;
+                secrets?: {
+                    [key: string]: string | boolean | number;
+                };
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                [key: string]: string | number | boolean | Record<string, unknown> | undefined;
+                secrets?: {
+                    [key: string]: string | boolean | number;
+                };
+            };
+        }>;
+        style: import("drizzle-orm/pg-core").PgColumn<{
+            name: "style";
+            tableName: "agents";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                all?: string[];
+                chat?: string[];
+                post?: string[];
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                all?: string[];
+                chat?: string[];
+                post?: string[];
+            };
+        }>;
+    };
+    dialect: "pg";
+}>;