@elizaos/plugin-sql 1.0.0-beta.68 → 1.0.0-beta.69

package/dist/index.js

@@ -862,26 +862,32 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Asynchronously retrieves an entity and its components by entity ID.
-   * @param {UUID} entityId - The unique identifier of the entity to retrieve.
-   * @returns {Promise<Entity | null>} A Promise that resolves to the entity with its components if found, null otherwise.
+   * Asynchronously retrieves an entity and its components by entity IDs.
+   * @param {UUID[]} entityIds - The unique identifiers of the entities to retrieve.
+   * @returns {Promise<Entity[] | null>} A Promise that resolves to the entity with its components if found, null otherwise.
    */
-  async getEntityById(entityId) {
+  async getEntityByIds(entityIds) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
         entity: entityTable,
         components: componentTable
-      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(eq(entityTable.id, entityId)).limit(1);
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(inArray(entityTable.id, entityIds));
       if (result.length === 0) return null;
-      const entity = result[0].entity;
-      const components = result.map((r) => r.components).filter((c) => c !== null);
-      return {
-        ...entity,
-        id: entity.id,
-        agentId: entity.agentId,
-        metadata: entity.metadata,
-        components
-      };
+      const entities = {};
+      const entityComponents = {};
+      for (const e of result) {
+        const key = e.entity.id;
+        entities[key] = e.entity;
+        if (entityComponents[key] === void 0) entityComponents[key] = [];
+        if (e.components) {
+          const componentsArray = Array.isArray(e.components) ? e.components : [e.components];
+          entityComponents[key] = [...entityComponents[key], ...componentsArray];
+        }
+      }
+      for (const k of Object.keys(entityComponents)) {
+        entities[k].components = entityComponents[k];
+      }
+      return Object.values(entities);
     });
   }
   /**
@@ -931,25 +937,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Asynchronously creates a new entity in the database.
-   * @param {Entity} entity - The entity object to be created.
+   * Asynchronously creates new entities in the database.
+   * @param {Entity[]} entities - The entity objects to be created.
    * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
    */
-  async createEntity(entity) {
+  async createEntities(entities) {
     return this.withDatabase(async () => {
       try {
         return await this.db.transaction(async (tx) => {
-          await tx.insert(entityTable).values(entity);
-          logger.debug("Entity created successfully:", {
-            entity
-          });
+          await tx.insert(entityTable).values(entities);
+          logger.debug(entities.length, "Entities created successfully");
           return true;
         });
       } catch (error) {
         logger.error("Error creating entity:", {
           error: error instanceof Error ? error.message : String(error),
-          entityId: entity.id,
-          name: entity.metadata?.name
+          entityId: entities[0].id,
+          name: entities[0].metadata?.name
         });
         logger.trace(error);
         return false;
@@ -967,9 +971,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return false;
     }
     try {
-      const existingEntity = await this.getEntityById(entity.id);
-      if (!existingEntity) {
-        return await this.createEntity(entity);
+      const existingEntities = await this.getEntityByIds([entity.id]);
+      if (!existingEntities || !existingEntities.length) {
+        return await this.createEntities([entity]);
       }
       return true;
     } catch (error) {
@@ -1721,11 +1725,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Asynchronously retrieves a room from the database based on the provided parameters.
-   * @param {UUID} roomId - The ID of the room to retrieve.
-   * @returns {Promise<Room | null>} A Promise that resolves to the room if found, null otherwise.
+   * Asynchronously retrieves rooms from the database based on the provided parameters.
+   * @param {UUID[]} roomIds - The IDs of the rooms to retrieve.
+   * @returns {Promise<Room[] | null>} A Promise that resolves to the rooms if found, null otherwise.
    */
-  async getRoom(roomId) {
+  async getRoomsByIds(roomIds) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
         id: roomTable.id,
@@ -1739,22 +1743,19 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         source: roomTable.source,
         metadata: roomTable.metadata
         // Added metadata
-      }).from(roomTable).where(and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))).limit(1);
-      if (result.length === 0) return null;
-      const room = result[0];
-      return {
+      }).from(roomTable).where(and(inArray(roomTable.id, roomIds), eq(roomTable.agentId, this.agentId)));
+      const rooms = result.map((room) => ({
         ...room,
         id: room.id,
         name: room.name ?? void 0,
-        // Corrected to handle null
         agentId: room.agentId,
         serverId: room.serverId,
         worldId: room.worldId,
         channelId: room.channelId,
         type: room.type,
         metadata: room.metadata
-        // Added metadata
-      };
+      }));
+      return rooms;
     });
   }
   /**
@@ -1762,7 +1763,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {UUID} worldId - The ID of the world to retrieve rooms from.
    * @returns {Promise<Room[]>} A Promise that resolves to an array of rooms.
    */
-  async getRooms(worldId) {
+  async getRoomsByWorld(worldId) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
       const rooms = result.map((room) => ({
@@ -1776,7 +1777,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         type: room.type,
         metadata: room.metadata
       }));
-      if (rooms.length === 0) return [];
       return rooms;
     });
   }
@@ -1795,32 +1795,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {Room} room - The room object to create.
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created room.
    */
-  async createRoom({
-    id,
-    name,
-    agentId,
-    source,
-    type,
-    channelId,
-    serverId,
-    worldId,
-    metadata
-  }) {
-    if (!worldId) throw new Error("worldId is required");
+  async createRooms(rooms) {
     return this.withDatabase(async () => {
-      const newRoomId = id || v4();
-      await this.db.insert(roomTable).values({
-        id: newRoomId,
-        name,
-        agentId,
-        source,
-        type,
-        channelId,
-        serverId,
-        worldId,
-        metadata
-      }).onConflictDoNothing({ target: roomTable.id });
-      return newRoomId;
+      const roomsWithIds = rooms.map((room) => ({
+        ...room,
+        id: room.id || v4()
+        // ensure each room has a unique ID
+      }));
+      const insertedRooms = await this.db.insert(roomTable).values(roomsWithIds).onConflictDoNothing().returning();
+      const insertedIds = insertedRooms.map((r) => r.id);
+      return insertedIds;
     });
   }
   /**
@@ -1886,6 +1870,28 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  async addParticipantsRoom(entityIds, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        const values = entityIds.map((id) => ({
+          entityId: id,
+          roomId,
+          agentId: this.agentId
+        }));
+        await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
+        logger.debug(entityIds.length, "Entities linked successfully");
+        return true;
+      } catch (error) {
+        logger.error("Error adding participants", {
+          error: error instanceof Error ? error.message : String(error),
+          entityIdSample: entityIds[0],
+          roomId,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
   /**
    * Asynchronously removes a participant from a room in the database based on the provided parameters.
    * @param {UUID} entityId - The ID of the entity to remove from the room.
@@ -1929,13 +1935,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entityId: participantTable.entityId,
         roomId: participantTable.roomId
       }).from(participantTable).where(eq(participantTable.entityId, entityId));
-      const entity = await this.getEntityById(entityId);
-      if (!entity) {
+      const entities = await this.getEntityByIds([entityId]);
+      if (!entities || !entities.length) {
         return [];
       }
       return result.map((row) => ({
         id: row.id,
-        entity
+        entity: entities[0]
       }));
     });
   }
@@ -2401,70 +2407,53 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns Promise resolving when the deletion is complete
    */
   async deleteTask(id) {
-    await this.withRetry(async () => {
-      await this.withDatabase(async () => {
-        await this.db.delete(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
-      });
+    return this.withDatabase(async () => {
+      await this.db.delete(taskTable).where(eq(taskTable.id, id));
     });
   }
-  /**
-   * Asynchronously retrieves group chat memories from all rooms under a given server.
-   * It fetches all room IDs associated with the `serverId`, then retrieves memories
-   * from those rooms in descending order (latest to oldest), with an optional count limit.
-   *
-   * @param {Object} params - Parameters for fetching memories.
-   * @param {UUID} params.serverId - The server ID to fetch memories for.
-   * @param {number} [params.count] - The maximum number of memories to retrieve.
-   * @returns {Promise<Memory[]>} - A promise that resolves to an array of memory objects.
-   */
-  async getMemoriesByServerId(params) {
+  async getMemoriesByWorldId(params) {
     return this.withDatabase(async () => {
-      const roomIdsResult = await this.db.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, params.serverId));
-      if (roomIdsResult.length === 0) return [];
-      const roomIds = roomIdsResult.map((row) => row.roomId);
-      const query = this.db.select({
-        memory: memoryTable,
-        embedding: embeddingTable[this.embeddingDimension]
-      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(inArray(memoryTable.roomId, roomIds)).orderBy(desc(memoryTable.createdAt));
-      const rows = params.count ? await query.limit(params.count) : await query;
-      return rows.map((row) => ({
-        id: row.memory.id,
-        type: row.memory.type,
-        createdAt: row.memory.createdAt,
-        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
-        entityId: row.memory.entityId,
-        agentId: row.memory.agentId,
-        roomId: row.memory.roomId,
-        unique: row.memory.unique,
-        embedding: row.embedding ?? void 0
-      }));
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, params.worldId), eq(roomTable.agentId, this.agentId)));
+      if (rooms.length === 0) {
+        return [];
+      }
+      const roomIds = rooms.map((room) => room.id);
+      const memories = await this.getMemoriesByRoomIds({
+        roomIds,
+        tableName: params.tableName || "messages",
+        limit: params.count
+      });
+      return memories;
     });
   }
-  /**
-   * Asynchronously deletes all rooms associated with a specific serverId.
-   * @param {UUID} serverId - The server ID to delete rooms for.
-   * @returns {Promise<void>} A Promise that resolves when the rooms are deleted.
-   */
-  async deleteRoomsByServerId(serverId) {
+  async deleteRoomsByWorldId(worldId) {
     return this.withDatabase(async () => {
-      await this.db.transaction(async (tx) => {
-        const roomIdsResult = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, serverId));
-        if (roomIdsResult.length === 0) return;
-        const roomIds = roomIdsResult.map((row) => row.roomId);
-        await tx.delete(embeddingTable).where(
-          inArray(
-            embeddingTable.memoryId,
-            tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds))
-          )
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, worldId), eq(roomTable.agentId, this.agentId)));
+      if (rooms.length === 0) {
+        logger.debug(
+          `No rooms found for worldId ${worldId} and agentId ${this.agentId} to delete.`
         );
-        await tx.delete(memoryTable).where(inArray(memoryTable.roomId, roomIds));
-        await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-        await tx.delete(logTable).where(inArray(logTable.roomId, roomIds));
-        await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
-      });
-      logger.debug("Rooms and related logs deleted successfully for server:", {
-        serverId
-      });
+        return;
+      }
+      const roomIds = rooms.map((room) => room.id);
+      if (roomIds.length > 0) {
+        await this.db.delete(logTable).where(inArray(logTable.roomId, roomIds));
+        logger.debug(`Deleted logs for ${roomIds.length} rooms in world ${worldId}.`);
+        await this.db.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+        logger.debug(`Deleted participants for ${roomIds.length} rooms in world ${worldId}.`);
+        const memoriesInRooms = await this.db.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+        const memoryIdsInRooms = memoriesInRooms.map((m) => m.id);
+        if (memoryIdsInRooms.length > 0) {
+          await this.db.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIdsInRooms));
+          logger.debug(
+            `Deleted embeddings for ${memoryIdsInRooms.length} memories in world ${worldId}.`
+          );
+          await this.db.delete(memoryTable).where(inArray(memoryTable.id, memoryIdsInRooms));
+          logger.debug(`Deleted ${memoryIdsInRooms.length} memories in world ${worldId}.`);
+        }
+        await this.db.delete(roomTable).where(inArray(roomTable.id, roomIds));
+        logger.debug(`Deleted ${roomIds.length} rooms for worldId ${worldId}.`);
+      }
     });
   }
 };