@elizaos/plugin-sql 1.5.9-alpha.2 → 1.5.9-alpha.4

package/dist/{custom-migrator.d.ts → node/src/custom-migrator.d.ts}

@@ -72,4 +72,3 @@ export declare class ExtensionManager {
 }
 export declare function runPluginMigrations(db: DrizzleDB, pluginName: string, schema: any): Promise<void>;
 export {};
-//# sourceMappingURL=custom-migrator.d.ts.map

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

@@ -0,0 +1,32 @@
+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 { schema };

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

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

package/dist/{migration-service.d.ts → node/src/migration-service.d.ts}

@@ -9,4 +9,3 @@ export declare class DatabaseMigrationService {
     registerSchema(pluginName: string, schema: any): void;
     runAllPluginMigrations(): Promise<void>;
 }
-//# sourceMappingURL=migration-service.d.ts.map

package/dist/{pg → node/src/pg}/adapter.d.ts

@@ -73,4 +73,3 @@ export declare class PgDatabaseAdapter extends BaseDrizzleAdapter {
     updateComponent(component: Component): Promise<void>;
     deleteComponent(componentId: UUID): Promise<void>;
 }
-//# sourceMappingURL=adapter.d.ts.map

package/dist/{pg → node/src/pg}/manager.d.ts

@@ -15,4 +15,3 @@ export declare class PostgresConnectionManager {
      */
     close(): Promise<void>;
 }
-//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +1,74 @@
+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);
+    getEntityByIds(entityIds: UUID[]): Promise<Entity[] | null>;
+    getMemoriesByServerId(_params: {
+        serverId: UUID;
+        count?: number;
+    }): Promise<Memory[]>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
+    /**
+     * Runs database migrations. For PGLite, migrations are handled by the
+     * migration service, not the adapter itself.
+     * @returns {Promise<void>}
+     */
+    runMigrations(): Promise<void>;
+    /**
+     * 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

@@ -0,0 +1,21 @@
+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/schema/agent.d.ts

@@ -0,0 +1,327 @@
+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;
+        }, {}, {}>;
+        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]: unknown;
+                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]: unknown;
+                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";
+}>;

package/dist/node/src/schema/cache.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Represents a PostgreSQL table for caching data.
+ *
+ * @type {pgTable}
+ */
+export declare const cacheTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cache";
+    schema: undefined;
+    columns: {
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "cache";
+            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;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "cache";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "cache";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            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: "cache";
+            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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "cache";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;