@elizaos/plugin-sql 1.0.0-beta.48 → 1.0.0-beta.49

package/dist/index.js

@@ -18,19 +18,7 @@ import {
   logger,
   stringToUuid
 } from "@elizaos/core";
-import {
-  and,
-  cosineDistance,
-  count,
-  desc,
-  eq,
-  gte,
-  inArray,
-  lte,
-  or,
-  sql as sql12,
-  not
-} from "drizzle-orm";
+import { and, cosineDistance, count, desc, eq, gte, inArray, lte, or, sql as sql12, not } from "drizzle-orm";
 import { v4 } from "uuid";
 
 // src/schema/embedding.ts
@@ -89,18 +77,18 @@ var agentTable = pgTable(
     createdAt: numberTimestamp("createdAt").default(sql`now()`).notNull(),
     updatedAt: numberTimestamp("updatedAt").default(sql`now()`).notNull(),
     // Character
-    name: text("name"),
+    name: text("name").notNull(),
     username: text("username"),
-    system: text("system"),
+    system: text("system").notNull(),
     bio: jsonb("bio").$type().notNull(),
-    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`),
-    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`),
-    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`),
-    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`),
-    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`),
-    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`),
-    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`),
-    style: jsonb("style").$type().default(sql`'{}'::jsonb`)
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
   },
   (table) => {
     return {
@@ -120,8 +108,8 @@ var entityTable = pgTable2(
       onDelete: "cascade"
     }),
     createdAt: numberTimestamp("createdAt").default(sql2`now()`).notNull(),
-    names: text2("names").array().default(sql2`'{}'::text[]`),
-    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`)
+    names: text2("names").array().default(sql2`'{}'::text[]`).notNull(),
+    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`).notNull()
   },
   (table) => {
     return {
@@ -322,7 +310,7 @@ var logTable = pgTable9(
     entityId: uuid9("entityId").notNull().references(() => entityTable.id),
     body: jsonb8("body").notNull(),
     type: text8("type").notNull(),
-    roomId: uuid9("roomId").notNull().references(() => roomTable.id)
+    roomId: uuid9("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" })
   },
   (table) => [
     foreignKey3({
@@ -485,15 +473,17 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       throw new Error("Agent name is required");
     }
     const agents = await this.getAgents();
-    const existingAgent = agents.find(
-      (a) => a.name === agent.name
-    );
-    if (existingAgent) {
+    const existingAgentId = agents.find((a) => a.name === agent.name)?.id;
+    if (existingAgentId) {
+      const existingAgent = await this.getAgent(existingAgentId);
       return existingAgent;
     }
-    agent.id = stringToUuid(agent.name ?? v4());
-    await this.createAgent(agent);
-    return agent;
+    const newAgent = {
+      ...agent,
+      id: stringToUuid(agent.name)
+    };
+    await this.createAgent(newAgent);
+    return newAgent;
   }
   /**
    * Asynchronously ensures that the given embedding dimension is valid for the agent.
@@ -519,20 +509,31 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async getAgent(agentId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
-      if (result.length === 0) return null;
-      return result[0];
+      const rows = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+      if (rows.length === 0) return null;
+      const row = rows[0];
+      return {
+        ...row,
+        id: row.id
+      };
     });
   }
   /**
    * Asynchronously retrieves a list of agents from the database.
    *
-   * @returns {Promise<Agent[]>} A Promise that resolves to an array of Agent objects.
+   * @returns {Promise<Partial<Agent>[]>} A Promise that resolves to an array of Agent objects.
    */
   async getAgents() {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(agentTable);
-      return result;
+      const rows = await this.db.select({
+        id: agentTable.id,
+        name: agentTable.name,
+        bio: agentTable.bio
+      }).from(agentTable);
+      return rows.map((row) => ({
+        ...row,
+        id: row.id
+      }));
     });
   }
   /**
@@ -849,11 +850,17 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const result = await this.db.select({
         entity: entityTable,
         components: componentTable
-      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(eq(entityTable.id, entityId));
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(eq(entityTable.id, entityId)).limit(1);
       if (result.length === 0) return null;
       const entity = result[0].entity;
-      entity.components = result.filter((row) => row.components).map((row) => row.components);
-      return entity;
+      const components = result.map((r) => r.components).filter((c) => c !== null);
+      return {
+        ...entity,
+        id: entity.id,
+        agentId: entity.agentId,
+        metadata: entity.metadata,
+        components
+      };
     });
   }
   /**
@@ -882,6 +889,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (!entitiesByIdMap.has(entityId)) {
           const entity = {
             ...row.entity,
+            id: stringToUuid(entityId),
+            agentId: stringToUuid(row.entity.agentId),
+            metadata: row.entity.metadata,
             components: includeComponents ? [] : void 0
           };
           entitiesByIdMap.set(entityId, entity);
@@ -969,7 +979,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
       }
       const result = await this.db.select().from(componentTable).where(and(...conditions));
-      return result.length > 0 ? result[0] : null;
+      if (result.length === 0) return null;
+      const component = result[0];
+      return {
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data
+      };
     });
   }
   /**
@@ -994,10 +1015,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         type: componentTable.type,
         data: componentTable.data,
         worldId: componentTable.worldId,
+        agentId: componentTable.agentId,
+        roomId: componentTable.roomId,
         sourceEntityId: componentTable.sourceEntityId,
         createdAt: componentTable.createdAt
       }).from(componentTable).where(and(...conditions));
-      return result;
+      if (result.length === 0) return [];
+      const components = 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
+      }));
+      return components;
     });
   }
   /**
@@ -1220,7 +1254,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
                             AND m.content->>${opts.query_field_sub_name} IS NOT NULL
                     ),
                     embedded_text AS (
-                        SELECT 
+                        SELECT
                             ct.content_text,
                             COALESCE(
                                 e.dim_384,
@@ -1310,7 +1344,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           type ? eq(logTable.type, type) : void 0
         )
       ).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
-      return result;
+      const logs = result.map((log) => ({
+        ...log,
+        id: log.id,
+        entityId: log.entityId,
+        roomId: log.roomId,
+        body: log.body,
+        createdAt: new Date(log.createdAt)
+      }));
+      if (logs.length === 0) return [];
+      return logs;
     });
   }
   /**
@@ -1579,7 +1622,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         sql12`${memoryTable.metadata}->>'documentId' = ${documentId}`
       )
     );
-    return fragments;
+    return fragments.map((f) => ({ id: f.id }));
   }
   /**
    * Asynchronously deletes all memories from the database based on the provided parameters.
@@ -1590,21 +1633,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async deleteAllMemories(roomId, tableName) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        const memoryIds = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
-        if (memoryIds.length > 0) {
-          await tx.delete(embeddingTable).where(
-            inArray(
-              embeddingTable.memoryId,
-              memoryIds.map((m) => m.id)
-            )
-          );
-          await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        const ids = rows.map((r) => r.id);
+        logger.debug("[deleteAllMemories] memory IDs to delete:", { roomId, tableName, ids });
+        if (ids.length === 0) {
+          return;
         }
+        await Promise.all(
+          ids.map(async (memoryId) => {
+            await this.deleteMemoryFragments(tx, memoryId);
+            await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
+          })
+        );
+        await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
       });
-      logger.debug("All memories removed successfully:", {
-        roomId,
-        tableName
-      });
+      logger.debug("All memories removed successfully:", { roomId, tableName });
     });
   }
   /**
@@ -1642,7 +1685,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         source: roomTable.source
       }).from(roomTable).where(and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))).limit(1);
       if (result.length === 0) return null;
-      return result[0];
+      const room = result[0];
+      return {
+        ...room,
+        id: room.id,
+        agentId: room.agentId,
+        serverId: room.serverId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type
+      };
     });
   }
   /**
@@ -1653,7 +1705,19 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getRooms(worldId) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
-      return result;
+      const rooms = result.map((room) => ({
+        ...room,
+        id: room.id,
+        name: room.name ?? void 0,
+        agentId: room.agentId,
+        serverId: room.serverId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type,
+        metadata: room.metadata
+      }));
+      if (rooms.length === 0) return [];
+      return rooms;
     });
   }
   /**
@@ -1973,39 +2037,28 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async getRelationships(params) {
     return this.withDatabase(async () => {
-      try {
-        let query = this.db.select().from(relationshipTable).where(
-          and(
-            or(
-              eq(relationshipTable.sourceEntityId, params.entityId),
-              eq(relationshipTable.targetEntityId, params.entityId)
-            ),
-            eq(relationshipTable.agentId, this.agentId)
-          )
-        );
-        if (params.tags && params.tags.length > 0) {
-          const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
-          query = query.where(
-            sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
-          );
-        }
-        const results = await query;
-        return results.map((result) => ({
-          id: result.id,
-          sourceEntityId: result.sourceEntityId,
-          targetEntityId: result.targetEntityId,
-          agentId: result.agentId,
-          tags: result.tags || [],
-          metadata: result.metadata || {},
-          createdAt: result.createdAt?.toString()
-        }));
-      } catch (error) {
-        logger.error("Error getting relationships:", {
-          error: error instanceof Error ? error.message : String(error),
-          params
-        });
-        return [];
-      }
+      const conditions = [
+        or(
+          eq(relationshipTable.sourceEntityId, params.entityId),
+          eq(relationshipTable.targetEntityId, params.entityId)
+        ),
+        eq(relationshipTable.agentId, this.agentId),
+        ...params.tags && params.tags.length > 0 ? [
+          sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(
+            params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ")
+          )}]::text[]`
+        ] : []
+      ];
+      const results = await this.db.select().from(relationshipTable).where(and(...conditions));
+      return results.map((row) => ({
+        id: row.id,
+        sourceEntityId: row.sourceEntityId,
+        targetEntityId: row.targetEntityId,
+        agentId: row.agentId,
+        tags: row.tags || [],
+        metadata: row.metadata || {},
+        createdAt: row.createdAt?.toString()
+      }));
     });
   }
   /**
@@ -2092,7 +2145,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const newWorldId = world.id || v4();
       await this.db.insert(worldTable).values({
         ...world,
-        id: newWorldId
+        id: newWorldId,
+        name: world.name || ""
       });
       return newWorldId;
     });
@@ -2160,7 +2214,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           updatedAt: now,
           agentId: this.agentId
         };
-        const result = await this.db.insert(taskTable).values(values).returning({ id: taskTable.id });
+        const result = await this.db.insert(taskTable).values(values).returning();
         return result[0].id;
       });
     });
@@ -2173,22 +2227,24 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getTasks(params) {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
-        let query = this.db.select().from(taskTable).where(eq(taskTable.agentId, this.agentId));
-        if (params.roomId) {
-          query = query.where(eq(taskTable.roomId, params.roomId));
-        }
-        if (params.tags && params.tags.length > 0) {
-          const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
-          query = query.where(sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`);
-        }
-        const result = await query;
+        const result = await this.db.select().from(taskTable).where(
+          and(
+            eq(taskTable.agentId, this.agentId),
+            ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [],
+            ...params.tags && params.tags.length > 0 ? [
+              sql12`${taskTable.tags} @> ARRAY[${sql12.raw(
+                params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", ")
+              )}]::text[]`
+            ] : []
+          )
+        );
         return result.map((row) => ({
           id: row.id,
           name: row.name,
           description: row.description,
           roomId: row.roomId,
           worldId: row.worldId,
-          tags: row.tags,
+          tags: row.tags || [],
           metadata: row.metadata
         }));
       });