@elizaos/plugin-sql 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/browser/index.browser.js

@@ -3789,6 +3789,76 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     });
     return result || [];
   }
+  async getAgentsByIds(agentIds) {
+    if (agentIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const rows = await this.db.select().from(agentTable).where(inArray(agentTable.id, agentIds));
+      return rows.map((row) => {
+        const bioValue = !row.bio ? "" : Array.isArray(row.bio) ? row.bio : row.bio;
+        return {
+          ...row,
+          username: row.username || "",
+          id: row.id,
+          system: !row.system ? undefined : row.system,
+          bio: bioValue,
+          createdAt: row.createdAt.getTime(),
+          updatedAt: row.updatedAt.getTime()
+        };
+      });
+    });
+  }
+  async createAgents(agents) {
+    if (agents.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const ids = [];
+      for (const agent of agents) {
+        if (agent.id) {
+          const success = await this.createAgent(agent);
+          if (success)
+            ids.push(agent.id);
+        }
+      }
+      return ids;
+    });
+  }
+  async updateAgents(updates) {
+    for (const { agentId, agent } of updates) {
+      const success = await this.updateAgent(agentId, agent);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async upsertAgents(agents) {
+    for (const agent of agents) {
+      if (!agent.id)
+        continue;
+      const existing = await this.getAgent(agent.id);
+      if (existing) {
+        await this.updateAgent(agent.id, agent);
+      } else {
+        await this.createAgent(agent);
+      }
+    }
+  }
+  async deleteAgents(agentIds) {
+    if (agentIds.length === 0)
+      return true;
+    return this.withDatabase(async () => {
+      try {
+        await this.db.delete(agentTable).where(inArray(agentTable.id, agentIds));
+        return true;
+      } catch (error) {
+        logger9.error({
+          src: "plugin:sql",
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to delete agents");
+        return false;
+      }
+    });
+  }
   async createAgent(agent) {
     const _isDuplicateKeyError = (error) => {
       if (!error || typeof error !== "object")
@@ -5866,6 +5936,546 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.delete(pairingAllowlistTable).where(eq2(pairingAllowlistTable.id, id));
     });
   }
+  async isReady() {
+    try {
+      await this.db.execute(sql27`SELECT 1`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getConnection() {
+    return this.db;
+  }
+  async transaction(callback, _options) {
+    return callback(this);
+  }
+  async getComponentsByNaturalKeys(keys) {
+    if (keys.length === 0)
+      return [];
+    const results = [];
+    for (const key of keys) {
+      const component = await this.getComponent(key.entityId, key.type, key.worldId, key.sourceEntityId);
+      results.push(component);
+    }
+    return results;
+  }
+  async getComponentsForEntities(entityIds, worldId, sourceEntityId) {
+    if (entityIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const conditions = [inArray(componentTable.entityId, entityIds)];
+      if (worldId) {
+        conditions.push(eq2(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq2(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select().from(componentTable).where(and(...conditions));
+      return result.map((component) => ({
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data,
+        createdAt: component.createdAt.getTime()
+      }));
+    });
+  }
+  async createComponents(components) {
+    if (components.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const ids = [];
+      for (const component of components) {
+        const success = await this.createComponent(component);
+        if (success)
+          ids.push(component.id);
+      }
+      return ids;
+    });
+  }
+  async getComponentsByIds(componentIds) {
+    if (componentIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(componentTable).where(inArray(componentTable.id, componentIds));
+      return result.map((component) => ({
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data,
+        createdAt: component.createdAt.getTime()
+      }));
+    });
+  }
+  async updateComponents(components) {
+    for (const component of components) {
+      await this.updateComponent(component);
+    }
+  }
+  async deleteComponents(componentIds) {
+    if (componentIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(componentTable).where(inArray(componentTable.id, componentIds));
+    });
+  }
+  async upsertComponents(components, _options) {
+    for (const component of components) {
+      const existing = await this.getComponent(component.entityId, component.type, component.worldId, component.sourceEntityId);
+      if (existing) {
+        await this.updateComponent({ ...component, id: existing.id });
+      } else {
+        await this.createComponent(component);
+      }
+    }
+  }
+  async patchComponents(_updates, _options) {}
+  async upsertEntities(entities) {
+    for (const entity of entities) {
+      const existing = await this.getEntitiesByIds([entity.id]);
+      if (existing && existing.length > 0) {
+        await this.updateEntity(entity);
+      } else {
+        await this.createEntities([entity]);
+      }
+    }
+  }
+  async queryEntities(params) {
+    if (params.entityIds?.length) {
+      const entities = await this.getEntitiesByIds(params.entityIds);
+      return entities || [];
+    }
+    return this.withDatabase(async () => {
+      const conditions = [];
+      if (params.agentId) {
+        conditions.push(eq2(entityTable.agentId, params.agentId));
+      }
+      if (params.componentType) {
+        const subquery = sql27`EXISTS (
+          SELECT 1 FROM ${componentTable}
+          WHERE ${componentTable.entityId} = ${entityTable.id}
+          AND ${componentTable.type} = ${params.componentType}
+        )`;
+        conditions.push(subquery);
+      }
+      let query = this.db.select().from(entityTable).where(conditions.length > 0 ? and(...conditions) : undefined);
+      if (params.limit) {
+        query = query.limit(params.limit);
+      }
+      if (params.offset) {
+        query = query.offset(params.offset);
+      }
+      const result = await query;
+      return result.map((row) => ({
+        ...row,
+        id: row.id,
+        agentId: row.agentId,
+        names: row.names || [],
+        metadata: row.metadata || {}
+      }));
+    });
+  }
+  async updateEntities(entities) {
+    for (const entity of entities) {
+      await this.updateEntity(entity);
+    }
+  }
+  async deleteEntities(entityIds) {
+    for (const entityId of entityIds) {
+      await this.deleteEntity(entityId);
+    }
+  }
+  async getEntitiesForRooms(roomIds, includeComponents) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const entities = await this.getEntitiesForRoom(roomId, includeComponents);
+      result.push({ roomId, entities });
+    }
+    return result;
+  }
+  async createLogs(params) {
+    for (const param of params) {
+      await this.log(param);
+    }
+  }
+  async getLogsByIds(logIds) {
+    if (logIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(logTable).where(inArray(logTable.id, logIds));
+      return result.map((log) => ({
+        ...log,
+        id: log.id,
+        entityId: log.entityId,
+        roomId: log.roomId,
+        type: log.type,
+        body: log.body,
+        createdAt: new Date(log.createdAt)
+      }));
+    });
+  }
+  async updateLogs(logs) {
+    return this.withDatabase(async () => {
+      for (const { id, updates } of logs) {
+        const setValues = {};
+        if (updates.body !== undefined)
+          setValues.body = updates.body;
+        if (updates.type !== undefined)
+          setValues.type = updates.type;
+        if (Object.keys(setValues).length > 0) {
+          await this.db.update(logTable).set(setValues).where(eq2(logTable.id, id));
+        }
+      }
+    });
+  }
+  async deleteLogs(logIds) {
+    if (logIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(logTable).where(inArray(logTable.id, logIds));
+    });
+  }
+  async createMemories(memories) {
+    const ids = [];
+    for (const { memory, tableName, unique: unique3 } of memories) {
+      const memoryWithUnique = unique3 !== undefined ? { ...memory, unique: unique3 } : memory;
+      const id = await this.createMemory(memoryWithUnique, tableName);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updateMemories(memories) {
+    for (const memory of memories) {
+      await this.updateMemory(memory);
+    }
+  }
+  async upsertMemories(memories, _options) {
+    for (const { memory, tableName } of memories) {
+      if (memory.id) {
+        const existing = await this.getMemoryById(memory.id);
+        if (existing) {
+          await this.updateMemory(memory);
+          continue;
+        }
+      }
+      await this.createMemory(memory, tableName);
+    }
+  }
+  async deleteMemories(memoryIds) {
+    await this.deleteManyMemories(memoryIds);
+  }
+  async getWorldsByIds(worldIds) {
+    if (worldIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(inArray(worldTable.id, worldIds));
+      return result.map((world) => this.mapWorldResult(world));
+    });
+  }
+  async createWorlds(worlds) {
+    const ids = [];
+    for (const world of worlds) {
+      const id = await this.createWorld(world);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async deleteWorlds(worldIds) {
+    for (const id of worldIds) {
+      await this.removeWorld(id);
+    }
+  }
+  async updateWorlds(worlds) {
+    for (const world of worlds) {
+      await this.updateWorld(world);
+    }
+  }
+  async upsertWorlds(worlds) {
+    for (const world of worlds) {
+      const existing = await this.getWorld(world.id);
+      if (existing) {
+        await this.updateWorld(world);
+      } else {
+        await this.createWorld(world);
+      }
+    }
+  }
+  async deleteRoomsByWorldIds(worldIds) {
+    for (const worldId of worldIds) {
+      await this.deleteRoomsByWorldId(worldId);
+    }
+  }
+  async getRoomsByWorlds(worldIds, limit, offset) {
+    if (worldIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const conditions = [
+        inArray(roomTable.worldId, worldIds),
+        eq2(roomTable.agentId, this.agentId)
+      ];
+      let query = this.db.select().from(roomTable).where(and(...conditions));
+      if (offset) {
+        query = query.offset(offset);
+      }
+      if (limit) {
+        query = query.limit(limit);
+      }
+      const result = await query;
+      return result.map((room) => ({
+        ...room,
+        id: room.id,
+        name: room.name ?? undefined,
+        agentId: room.agentId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type,
+        metadata: room.metadata
+      }));
+    });
+  }
+  async upsertRooms(rooms) {
+    for (const room of rooms) {
+      const existing = await this.getRoomsByIds([room.id]);
+      if (existing && existing.length > 0) {
+        await this.updateRoom(room);
+      } else {
+        await this.createRooms([room]);
+      }
+    }
+  }
+  async createRoomParticipants(entityIds, roomId) {
+    const ids = [];
+    for (const entityId of entityIds) {
+      const success = await this.addParticipant(entityId, roomId);
+      if (success) {
+        ids.push(`${roomId}:${entityId}`);
+      }
+    }
+    return ids;
+  }
+  async deleteParticipants(participants) {
+    for (const { entityId, roomId } of participants) {
+      const success = await this.removeParticipant(entityId, roomId);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async updateParticipants(participants) {
+    for (const { entityId, roomId, updates } of participants) {
+      if (updates.roomState !== undefined) {
+        await this.setParticipantUserState(roomId, entityId, updates.roomState);
+      }
+    }
+  }
+  async updateRooms(rooms) {
+    for (const room of rooms) {
+      await this.updateRoom(room);
+    }
+  }
+  async deleteRooms(roomIds) {
+    for (const roomId of roomIds) {
+      await this.deleteRoom(roomId);
+    }
+  }
+  async getParticipantsForEntities(entityIds) {
+    const result = [];
+    for (const entityId of entityIds) {
+      const participants = await this.getParticipantsForEntity(entityId);
+      result.push(...participants);
+    }
+    return result;
+  }
+  async getParticipantsForRooms(roomIds) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const entityIds = await this.getParticipantsForRoom(roomId);
+      result.push({ roomId, entityIds });
+    }
+    return result;
+  }
+  async areRoomParticipants(pairs) {
+    const results = [];
+    for (const { roomId, entityId } of pairs) {
+      const isParticipant = await this.isRoomParticipant(roomId, entityId);
+      results.push(isParticipant);
+    }
+    return results;
+  }
+  async getParticipantUserStates(pairs) {
+    const results = [];
+    for (const { roomId, entityId } of pairs) {
+      const state = await this.getParticipantUserState(roomId, entityId);
+      results.push(state);
+    }
+    return results;
+  }
+  async updateParticipantUserStates(updates) {
+    for (const { roomId, entityId, state } of updates) {
+      await this.setParticipantUserState(roomId, entityId, state);
+    }
+  }
+  async getRelationshipsByPairs(pairs) {
+    const results = [];
+    for (const pair of pairs) {
+      const rel = await this.getRelationship(pair);
+      results.push(rel);
+    }
+    return results;
+  }
+  async createRelationships(relationships) {
+    const ids = [];
+    for (const rel of relationships) {
+      const id = v4_default();
+      const success = await this.createRelationship(rel);
+      if (success)
+        ids.push(id);
+    }
+    return ids;
+  }
+  async getRelationshipsByIds(relationshipIds) {
+    if (relationshipIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(relationshipTable).where(inArray(relationshipTable.id, relationshipIds));
+      return result.map((relationship) => ({
+        ...relationship,
+        id: relationship.id,
+        sourceEntityId: relationship.sourceEntityId,
+        targetEntityId: relationship.targetEntityId,
+        agentId: relationship.agentId,
+        tags: relationship.tags ?? [],
+        metadata: relationship.metadata ?? {},
+        createdAt: relationship.createdAt.toISOString()
+      }));
+    });
+  }
+  async updateRelationships(relationships) {
+    for (const relationship of relationships) {
+      await this.updateRelationship(relationship);
+    }
+  }
+  async deleteRelationships(relationshipIds) {
+    if (relationshipIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(relationshipTable).where(inArray(relationshipTable.id, relationshipIds));
+    });
+  }
+  async getCaches(keys) {
+    const result = new Map;
+    for (const key of keys) {
+      const value = await this.getCache(key);
+      if (value !== undefined) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+  async setCaches(entries) {
+    for (const { key, value } of entries) {
+      const success = await this.setCache(key, value);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async deleteCaches(keys) {
+    for (const key of keys) {
+      const success = await this.deleteCache(key);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async createTasks(tasks) {
+    const ids = [];
+    for (const task of tasks) {
+      const id = await this.createTask(task);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async getTasksByIds(taskIds) {
+    const tasks = [];
+    for (const taskId of taskIds) {
+      const task = await this.getTask(taskId);
+      if (task)
+        tasks.push(task);
+    }
+    return tasks;
+  }
+  async updateTasks(updates) {
+    for (const { id, task } of updates) {
+      await this.updateTask(id, task);
+    }
+  }
+  async deleteTasks(taskIds) {
+    for (const taskId of taskIds) {
+      await this.deleteTask(taskId);
+    }
+  }
+  async getPairingAllowlists(queries) {
+    const result = [];
+    for (const { channel, agentId } of queries) {
+      const entries = await this.getPairingAllowlist(channel, agentId);
+      result.push({ channel, agentId, entries });
+    }
+    return result;
+  }
+  async createPairingRequests(requests) {
+    const ids = [];
+    for (const request of requests) {
+      const id = await this.createPairingRequest(request);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updatePairingRequests(requests) {
+    for (const request of requests) {
+      await this.updatePairingRequest(request);
+    }
+  }
+  async deletePairingRequests(ids) {
+    for (const id of ids) {
+      await this.deletePairingRequest(id);
+    }
+  }
+  async createPairingAllowlistEntries(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      const id = await this.createPairingAllowlistEntry(entry);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updatePairingAllowlistEntries(entries) {
+    return this.withDatabase(async () => {
+      for (const entry of entries) {
+        if (!entry.id)
+          continue;
+        await this.db.update(pairingAllowlistTable).set({
+          metadata: entry.metadata || {}
+        }).where(eq2(pairingAllowlistTable.id, entry.id));
+      }
+    });
+  }
+  async deletePairingAllowlistEntries(ids) {
+    for (const id of ids) {
+      await this.deletePairingAllowlistEntry(id);
+    }
+  }
 }
 
 // pglite/adapter.ts
@@ -6095,5 +6705,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=8FA1400A2757EA4764756E2164756E21
+//# debugId=2BF5F5F274B3DB0364756E2164756E21
 //# sourceMappingURL=index.browser.js.map