@elizaos/plugin-sql 1.0.9 → 1.0.10

package/dist/index.d.ts

@@ -2357,7 +2357,7 @@ declare const serverAgentsTable: drizzle_orm_pg_core.PgTableWithColumns<{
             name: "server_id";
             tableName: "server_agents";
             dataType: "string";
-            columnType: "PgText";
+            columnType: "PgUUID";
             data: string;
             driverParam: string;
             notNull: true;
@@ -2365,7 +2365,7 @@ declare const serverAgentsTable: drizzle_orm_pg_core.PgTableWithColumns<{
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -2374,7 +2374,7 @@ declare const serverAgentsTable: drizzle_orm_pg_core.PgTableWithColumns<{
             name: "agent_id";
             tableName: "server_agents";
             dataType: "string";
-            columnType: "PgText";
+            columnType: "PgUUID";
             data: string;
             driverParam: string;
             notNull: true;
@@ -2382,7 +2382,7 @@ declare const serverAgentsTable: drizzle_orm_pg_core.PgTableWithColumns<{
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;

package/dist/index.js

@@ -219,7 +219,7 @@ var embeddingTable = pgTable5(
   "embeddings",
   {
     id: uuid5("id").primaryKey().defaultRandom().notNull(),
-    memoryId: uuid5("memory_id").references(() => memoryTable.id),
+    memoryId: uuid5("memory_id").references(() => memoryTable.id, { onDelete: "cascade" }),
     createdAt: timestamp5("created_at").default(sql5`now()`).notNull(),
     dim384: vector2("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
     dim512: vector2("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
@@ -318,7 +318,7 @@ var logTable = pgTable9(
   {
     id: uuid9("id").defaultRandom().notNull(),
     createdAt: timestamp9("created_at", { withTimezone: true }).default(sql9`now()`).notNull(),
-    entityId: uuid9("entityId").notNull().references(() => entityTable.id),
+    entityId: uuid9("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
     body: jsonb8("body").notNull(),
     type: text8("type").notNull(),
     roomId: uuid9("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" })
@@ -422,7 +422,7 @@ var taskTable = pgTable12("tasks", {
   roomId: uuid12("roomId"),
   worldId: uuid12("worldId"),
   entityId: uuid12("entityId"),
-  agentId: uuid12("agent_id").notNull(),
+  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text11("tags").array().default(sql12`'{}'::text[]`),
   metadata: jsonb10("metadata").default(sql12`'{}'::jsonb`),
   createdAt: timestamp12("created_at", { withTimezone: true }).defaultNow(),
@@ -496,13 +496,12 @@ var channelParticipantsTable = pgTable16(
 );
 
 // src/schema/serverAgent.ts
-import { pgTable as pgTable17, text as text16, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable17, uuid as uuid13, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
 var serverAgentsTable = pgTable17(
   "server_agents",
   {
-    serverId: text16("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
-    agentId: text16("agent_id").notNull()
-    // This is the agent's UUID
+    serverId: uuid13("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+    agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
   },
   (table) => ({
     pk: primaryKey3({ columns: [table.serverId, table.agentId] })
@@ -582,12 +581,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async ensureEmbeddingDimension(dimension) {
     return this.withDatabase(async () => {
-      const existingMemory = await this.db.select({
-        embedding: embeddingTable
-      }).from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
+      const existingMemory = await this.db.select().from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
       if (existingMemory.length > 0) {
         const usedDimension = Object.entries(DIMENSION_MAP).find(
-          ([_, colName]) => existingMemory[0].embedding[colName] !== null
+          ([_, colName]) => existingMemory[0].embeddings[colName] !== null
         );
       }
       this.embeddingDimension = DIMENSION_MAP[dimension];
@@ -782,158 +779,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<boolean>} - A boolean indicating if the deletion was successful.
    */
   async deleteAgent(agentId) {
-    logger.debug(`[DB] Starting deletion of agent with ID: ${agentId}`);
+    logger.debug(`[DB] Deleting agent with ID: ${agentId}`);
     return this.withDatabase(async () => {
       try {
-        logger.debug(`[DB] Beginning database transaction for deleting agent: ${agentId}`);
-        const deletePromise = new Promise((resolve, reject) => {
-          const timeoutId = setTimeout(() => {
-            logger.error(`[DB] Transaction timeout reached for agent deletion: ${agentId}`);
-            reject(new Error("Database transaction timeout"));
-          }, 3e4);
-          this.db.transaction(async (tx) => {
-            try {
-              logger.debug(`[DB] Fetching entities for agent: ${agentId}`);
-              const entities = await tx.select({ entityId: entityTable.id }).from(entityTable).where(eq(entityTable.agentId, agentId));
-              const entityIds = entities.map((e) => e.entityId);
-              logger.debug(
-                `[DB] Found ${entityIds.length} entities to delete for agent ${agentId}`
-              );
-              logger.debug(`[DB] Fetching rooms for agent: ${agentId}`);
-              const rooms = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.agentId, agentId));
-              const roomIds = rooms.map((r) => r.roomId);
-              logger.debug(`[DB] Found ${roomIds.length} rooms for agent ${agentId}`);
-              logger.debug(
-                `[DB] Explicitly deleting ALL logs with matching entityIds and roomIds`
-              );
-              if (entityIds.length > 0) {
-                logger.debug(`[DB] Deleting logs for ${entityIds.length} entities (first batch)`);
-                const BATCH_SIZE = 50;
-                for (let i = 0; i < entityIds.length; i += BATCH_SIZE) {
-                  const batch = entityIds.slice(i, i + BATCH_SIZE);
-                  logger.debug(
-                    `[DB] Processing entity logs batch ${i / BATCH_SIZE + 1} with ${batch.length} entities`
-                  );
-                  await tx.delete(logTable).where(inArray(logTable.entityId, batch));
-                }
-                logger.debug(`[DB] Entity logs deletion completed successfully`);
-              }
-              if (roomIds.length > 0) {
-                logger.debug(`[DB] Deleting logs for ${roomIds.length} rooms (first batch)`);
-                const BATCH_SIZE = 50;
-                for (let i = 0; i < roomIds.length; i += BATCH_SIZE) {
-                  const batch = roomIds.slice(i, i + BATCH_SIZE);
-                  logger.debug(
-                    `[DB] Processing room logs batch ${i / BATCH_SIZE + 1} with ${batch.length} rooms`
-                  );
-                  await tx.delete(logTable).where(inArray(logTable.roomId, batch));
-                }
-                logger.debug(`[DB] Room logs deletion completed successfully`);
-              }
-              let memoryIds = [];
-              if (entityIds.length > 0) {
-                logger.debug(`[DB] Finding memories belonging to entities`);
-                const memories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.entityId, entityIds));
-                memoryIds = memories.map((m) => m.id);
-                logger.debug(`[DB] Found ${memoryIds.length} memories belonging to entities`);
-              }
-              logger.debug(`[DB] Finding memories belonging to agent directly`);
-              const agentMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(eq(memoryTable.agentId, agentId));
-              memoryIds = [...memoryIds, ...agentMemories.map((m) => m.id)];
-              logger.debug(`[DB] Found total of ${memoryIds.length} memories to delete`);
-              if (roomIds.length > 0) {
-                logger.debug(`[DB] Finding memories belonging to rooms`);
-                const roomMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
-                memoryIds = [...memoryIds, ...roomMemories.map((m) => m.id)];
-                logger.debug(`[DB] Updated total to ${memoryIds.length} memories to delete`);
-              }
-              if (memoryIds.length > 0) {
-                logger.debug(`[DB] Deleting embeddings for ${memoryIds.length} memories`);
-                const BATCH_SIZE = 100;
-                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
-                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
-                  await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, batch));
-                }
-                logger.debug(`[DB] Embeddings deleted successfully`);
-              }
-              if (memoryIds.length > 0) {
-                logger.debug(`[DB] Deleting ${memoryIds.length} memories`);
-                const BATCH_SIZE = 100;
-                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
-                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
-                  await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
-                }
-                logger.debug(`[DB] Memories deleted successfully`);
-              }
-              if (entityIds.length > 0) {
-                logger.debug(`[DB] Deleting components for entities`);
-                await tx.delete(componentTable).where(inArray(componentTable.entityId, entityIds));
-                logger.debug(`[DB] Components deleted successfully`);
-              }
-              if (entityIds.length > 0) {
-                logger.debug(`[DB] Deleting source entity references in components`);
-                await tx.delete(componentTable).where(inArray(componentTable.sourceEntityId, entityIds));
-                logger.debug(`[DB] Source entity references deleted successfully`);
-              }
-              if (roomIds.length > 0) {
-                logger.debug(`[DB] Deleting participations for rooms`);
-                await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-                logger.debug(`[DB] Participations deleted for rooms`);
-              }
-              logger.debug(`[DB] Deleting agent participations`);
-              await tx.delete(participantTable).where(eq(participantTable.agentId, agentId));
-              logger.debug(`[DB] Agent participations deleted`);
-              if (roomIds.length > 0) {
-                logger.debug(`[DB] Deleting rooms`);
-                await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
-                logger.debug(`[DB] Rooms deleted successfully`);
-              }
-              logger.debug(`[DB] Deleting cache entries`);
-              await tx.delete(cacheTable).where(eq(cacheTable.agentId, agentId));
-              logger.debug(`[DB] Cache entries deleted successfully`);
-              logger.debug(`[DB] Deleting relationships`);
-              if (entityIds.length > 0) {
-                await tx.delete(relationshipTable).where(inArray(relationshipTable.sourceEntityId, entityIds));
-                await tx.delete(relationshipTable).where(inArray(relationshipTable.targetEntityId, entityIds));
-              }
-              await tx.delete(relationshipTable).where(eq(relationshipTable.agentId, agentId));
-              logger.debug(`[DB] Relationships deleted successfully`);
-              if (entityIds.length > 0) {
-                logger.debug(`[DB] Deleting entities`);
-                await tx.delete(entityTable).where(eq(entityTable.agentId, agentId));
-                logger.debug(`[DB] Entities deleted successfully`);
-              }
-              logger.debug(`[DB] Checking for world references`);
-              const worlds = await tx.select({ id: worldTable.id }).from(worldTable).where(eq(worldTable.agentId, agentId));
-              if (worlds.length > 0) {
-                const worldIds = worlds.map((w) => w.id);
-                logger.debug(`[DB] Found ${worldIds.length} worlds to delete`);
-                await tx.delete(worldTable).where(inArray(worldTable.id, worldIds));
-                logger.debug(`[DB] Worlds deleted successfully`);
-              } else {
-                logger.debug(`[DB] No worlds found for this agent`);
-              }
-              logger.debug(`[DB] Deleting agent ${agentId}`);
-              await tx.delete(agentTable).where(eq(agentTable.id, agentId));
-              logger.debug(`[DB] Agent deleted successfully`);
-              resolve(true);
-            } catch (error) {
-              logger.error(`[DB] Error in transaction:`, error);
-              reject(error);
-            }
-          }).catch((transactionError) => {
-            clearTimeout(timeoutId);
-            reject(transactionError);
-          });
-        });
-        await deletePromise;
-        logger.success(`[DB] Agent ${agentId} successfully deleted`);
+        const result = await this.db.delete(agentTable).where(eq(agentTable.id, agentId)).returning();
+        if (result.length === 0) {
+          logger.warn(`[DB] Agent ${agentId} not found`);
+          return false;
+        }
+        logger.success(
+          `[DB] Agent ${agentId} and all related data successfully deleted via cascade`
+        );
         return true;
       } catch (error) {
-        logger.error(`[DB] Error in database transaction for agent deletion ${agentId}:`, error);
+        logger.error(`[DB] Failed to delete agent ${agentId}:`, error);
         if (error instanceof Error) {
-          logger.error(`[DB] Error name: ${error.name}, message: ${error.message}`);
-          logger.error(`[DB] Error stack: ${error.stack}`);
+          logger.error(`[DB] Error details: ${error.name} - ${error.message}`);
+          logger.error(`[DB] Stack trace: ${error.stack}`);
         }
         throw error;
       }
@@ -1107,8 +969,89 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<void>} A Promise that resolves when the entity is updated.
    */
   async updateEntity(entity) {
+    if (!entity.id) {
+      throw new Error("Entity ID is required for update");
+    }
+    return this.withDatabase(async () => {
+      await this.db.update(entityTable).set(entity).where(eq(entityTable.id, entity.id));
+    });
+  }
+  /**
+   * Asynchronously deletes an entity from the database based on the provided ID.
+   * @param {UUID} entityId - The ID of the entity to delete.
+   * @returns {Promise<void>} A Promise that resolves when the entity is deleted.
+   */
+  async deleteEntity(entityId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(componentTable).where(
+          or(eq(componentTable.entityId, entityId), eq(componentTable.sourceEntityId, entityId))
+        );
+        await tx.delete(entityTable).where(eq(entityTable.id, entityId));
+      });
+    });
+  }
+  /**
+   * Asynchronously retrieves entities by their names and agentId.
+   * @param {Object} params - The parameters for retrieving entities.
+   * @param {string[]} params.names - The names to search for.
+   * @param {UUID} params.agentId - The agent ID to filter by.
+   * @returns {Promise<Entity[]>} A Promise that resolves to an array of entities.
+   */
+  async getEntitiesByNames(params) {
+    return this.withDatabase(async () => {
+      const { names, agentId } = params;
+      const nameConditions = names.map((name) => sql16`${name} = ANY(${entityTable.names})`);
+      const query = sql16`
+        SELECT * FROM ${entityTable}
+        WHERE ${entityTable.agentId} = ${agentId}
+        AND (${sql16.join(nameConditions, sql16` OR `)})
+      `;
+      const result = await this.db.execute(query);
+      return result.rows.map((row) => ({
+        id: row.id,
+        agentId: row.agentId,
+        names: row.names || [],
+        metadata: row.metadata || {}
+      }));
+    });
+  }
+  /**
+   * Asynchronously searches for entities by name with fuzzy matching.
+   * @param {Object} params - The parameters for searching entities.
+   * @param {string} params.query - The search query.
+   * @param {UUID} params.agentId - The agent ID to filter by.
+   * @param {number} params.limit - The maximum number of results to return.
+   * @returns {Promise<Entity[]>} A Promise that resolves to an array of entities.
+   */
+  async searchEntitiesByName(params) {
     return this.withDatabase(async () => {
-      await this.db.update(entityTable).set(entity).where(and(eq(entityTable.id, entity.id), eq(entityTable.agentId, entity.agentId)));
+      const { query, agentId, limit = 10 } = params;
+      if (!query || query.trim() === "") {
+        const result2 = await this.db.select().from(entityTable).where(eq(entityTable.agentId, agentId)).limit(limit);
+        return result2.map((row) => ({
+          id: row.id,
+          agentId: row.agentId,
+          names: row.names || [],
+          metadata: row.metadata || {}
+        }));
+      }
+      const searchQuery = sql16`
+        SELECT * FROM ${entityTable}
+        WHERE ${entityTable.agentId} = ${agentId}
+        AND EXISTS (
+          SELECT 1 FROM unnest(${entityTable.names}) AS name
+          WHERE LOWER(name) LIKE LOWER(${"%" + query + "%"})
+        )
+        LIMIT ${limit}
+      `;
+      const result = await this.db.execute(searchQuery);
+      return result.rows.map((row) => ({
+        id: row.id,
+        agentId: row.agentId,
+        names: row.names || [],
+        metadata: row.metadata || {}
+      }));
     });
   }
   async getComponent(entityId, type, worldId, sourceEntityId) {
@@ -1484,7 +1427,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param value - The value to sanitize
    * @returns The sanitized value
    */
-  sanitizeJsonObject(value) {
+  sanitizeJsonObject(value, seen = /* @__PURE__ */ new WeakSet()) {
     if (value === null || value === void 0) {
       return value;
     }
@@ -1492,13 +1435,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return value.replace(/\u0000/g, "").replace(/\\(?!["\\/bfnrtu])/g, "\\\\").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u");
     }
     if (typeof value === "object") {
+      if (seen.has(value)) {
+        return null;
+      } else {
+        seen.add(value);
+      }
       if (Array.isArray(value)) {
-        return value.map((item) => this.sanitizeJsonObject(item));
+        return value.map((item) => this.sanitizeJsonObject(item, seen));
       } else {
         const result = {};
         for (const [key, val] of Object.entries(value)) {
           const sanitizedKey = typeof key === "string" ? key.replace(/\u0000/g, "").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u") : key;
-          result[sanitizedKey] = this.sanitizeJsonObject(val);
+          result[sanitizedKey] = this.sanitizeJsonObject(val, seen);
         }
         return result;
       }
@@ -3044,16 +2992,16 @@ var PGliteClientManager = class {
 import { logger as logger3 } from "@elizaos/core";
 import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
 var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
-  constructor(agentId, manager) {
-    super(agentId);
-    this.manager = manager;
-    this.manager = manager;
-    this.db = this.manager.getDatabase();
-  }
   static {
     __name(this, "PgDatabaseAdapter");
   }
   embeddingDimension = DIMENSION_MAP[384];
+  manager;
+  constructor(agentId, manager, schema) {
+    super(agentId);
+    this.manager = manager;
+    this.db = manager.getDatabase();
+  }
   /**
    * Runs database migrations. For PostgreSQL, migrations should be handled
    * externally or during deployment, so this is a no-op.
@@ -3113,12 +3061,60 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   async getConnection() {
     return this.manager.getConnection();
   }
+  async createAgent(agent) {
+    return super.createAgent(agent);
+  }
+  getAgent(agentId) {
+    return super.getAgent(agentId);
+  }
+  updateAgent(agentId, agent) {
+    return super.updateAgent(agentId, agent);
+  }
+  deleteAgent(agentId) {
+    return super.deleteAgent(agentId);
+  }
+  createEntities(entities) {
+    return super.createEntities(entities);
+  }
+  getEntityByIds(entityIds) {
+    return super.getEntityByIds(entityIds).then((result) => result || []);
+  }
+  updateEntity(entity) {
+    return super.updateEntity(entity);
+  }
+  createMemory(memory, tableName) {
+    return super.createMemory(memory, tableName);
+  }
+  getMemoryById(memoryId) {
+    return super.getMemoryById(memoryId);
+  }
+  searchMemories(params) {
+    return super.searchMemories(params);
+  }
+  updateMemory(memory) {
+    return super.updateMemory(memory);
+  }
+  deleteMemory(memoryId) {
+    return super.deleteMemory(memoryId);
+  }
+  createComponent(component) {
+    return super.createComponent(component);
+  }
+  getComponent(entityId, type, worldId, sourceEntityId) {
+    return super.getComponent(entityId, type, worldId, sourceEntityId);
+  }
+  updateComponent(component) {
+    return super.updateComponent(component);
+  }
+  deleteComponent(componentId) {
+    return super.deleteComponent(componentId);
+  }
 };
 
 // src/pg/manager.ts
+import { drizzle as drizzle3 } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 import { logger as logger4 } from "@elizaos/core";
-import { drizzle as drizzle3 } from "drizzle-orm/node-postgres";
 var PostgresConnectionManager = class {
   static {
     __name(this, "PostgresConnectionManager");
@@ -3139,16 +3135,25 @@ var PostgresConnectionManager = class {
     return this.pool.connect();
   }
   async testConnection() {
+    let client = null;
     try {
-      const client = await this.pool.connect();
+      client = await this.pool.connect();
       await client.query("SELECT 1");
-      client.release();
       return true;
     } catch (error) {
       logger4.error("Failed to connect to the database:", error);
       return false;
+    } finally {
+      if (client) {
+        client.release();
+      }
     }
   }
+  /**
+   * Closes the connection pool.
+   * @returns {Promise<void>}
+   * @memberof PostgresConnectionManager
+   */
   async close() {
     await this.pool.end();
   }
@@ -3991,17 +3996,15 @@ var ExtensionManager = class {
   static {
     __name(this, "ExtensionManager");
   }
-  async installRequiredExtensions() {
-    if (this.db?.driver?.constructor?.name === "PGlite") {
-      logger5.debug("[CUSTOM MIGRATOR] PGLite detected, skipping extension creation via SQL.");
-      return;
-    }
-    const extensions = ["vector", "fuzzystrmatch"];
-    for (const extension of extensions) {
+  async installRequiredExtensions(requiredExtensions) {
+    for (const extension of requiredExtensions) {
       try {
         await this.db.execute(sql17.raw(`CREATE EXTENSION IF NOT EXISTS "${extension}"`));
-      } catch (e) {
-        logger5.warn(`Could not install extension ${extension}:`, e);
+      } catch (error) {
+        logger5.warn(`Could not install extension ${extension}:`, {
+          message: error.message,
+          stack: error.stack
+        });
       }
     }
   }
@@ -4043,7 +4046,7 @@ async function runPluginMigrations(db, pluginName, schema) {
   const namespaceManager = new PluginNamespaceManager(db);
   const introspector = new DrizzleSchemaIntrospector();
   const extensionManager = new ExtensionManager(db);
-  await extensionManager.installRequiredExtensions();
+  await extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch"]);
   const schemaName = await namespaceManager.getPluginSchema(pluginName);
   await namespaceManager.ensureNamespace(schemaName);
   const existingTables = await namespaceManager.introspectExistingTables(schemaName);