New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More
Socket
Sign inDemoInstall
Socket

@elizaos/adapter-supabase

Package Overview
Dependencies
Maintainers
0
Versions
7
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@elizaos/adapter-supabase - npm Package Compare versions

Comparing version 0.1.7 to 0.1.8

31

dist/index.d.ts
import { SupabaseClient } from '@supabase/supabase-js';
import { DatabaseAdapter, UUID, Participant, Memory, Account, Actor, GoalStatus, Goal, Relationship } from '@elizaos/core';
import { DatabaseAdapter, UUID, Participant, Memory, Account, Actor, GoalStatus, Goal, Relationship, RAGKnowledgeItem } from '@elizaos/core';

@@ -104,4 +104,33 @@ declare class SupabaseDatabaseAdapter extends DatabaseAdapter {

}): Promise<Relationship[]>;
getCache(params: {
key: string;
agentId: UUID;
}): Promise<string | undefined>;
setCache(params: {
key: string;
agentId: UUID;
value: string;
}): Promise<boolean>;
deleteCache(params: {
key: string;
agentId: UUID;
}): Promise<boolean>;
getKnowledge(params: {
id?: UUID;
agentId: UUID;
limit?: number;
query?: string;
}): Promise<RAGKnowledgeItem[]>;
searchKnowledge(params: {
agentId: UUID;
embedding: Float32Array;
match_threshold: number;
match_count: number;
searchText?: string;
}): Promise<RAGKnowledgeItem[]>;
createKnowledge(knowledge: RAGKnowledgeItem): Promise<void>;
removeKnowledge(id: UUID): Promise<void>;
clearKnowledge(agentId: UUID, shared?: boolean): Promise<void>;
}
export { SupabaseDatabaseAdapter };
// src/index.ts
import { createClient } from "@supabase/supabase-js";
import {
elizaLogger
} from "@elizaos/core";
import { DatabaseAdapter } from "@elizaos/core";

@@ -7,5 +10,6 @@ import { v4 as uuid } from "uuid";

async getRoom(roomId) {
const { data, error } = await this.supabase.from("rooms").select("id").eq("id", roomId).single();
const { data, error } = await this.supabase.from("rooms").select("id").eq("id", roomId).maybeSingle();
if (error) {
throw new Error(`Error getting room: ${error.message}`);
elizaLogger.error(`Error getting room: ${error.message}`);
return null;
}

@@ -26,3 +30,3 @@ return data ? data.id : null;

if (error) {
console.error("Error getting participant user state:", error);
elizaLogger.error("Error getting participant user state:", error);
return null;

@@ -35,3 +39,3 @@ }

if (error) {
console.error("Error setting participant user state:", error);
elizaLogger.error("Error setting participant user state:", error);
throw new Error("Failed to set participant user state");

@@ -65,3 +69,3 @@ }

if (error) {
console.error("Error retrieving memories by room IDs:", error);
elizaLogger.error("Error retrieving memories by room IDs:", error);
return [];

@@ -84,3 +88,3 @@ }

if (error) {
console.error(error.message);
elizaLogger.error(error.message);
return false;

@@ -100,3 +104,3 @@ }

if (response.error) {
console.error("Error!" + response.error);
elizaLogger.error("Error!" + response.error);
return [];

@@ -117,3 +121,3 @@ }

} catch (error) {
console.error("error", error);
elizaLogger.error("error", error);
throw error;

@@ -156,3 +160,3 @@ }

if (error) {
console.error("Error inserting log:", error);
elizaLogger.error("Error inserting log:", error);
throw new Error(error.message);

@@ -208,3 +212,3 @@ }

if (error) {
console.error("Error retrieving memory by ID:", error);
elizaLogger.error("Error retrieving memory by ID:", error);
return null;

@@ -353,3 +357,3 @@ }

if (error) {
console.error(`Error adding participant: ${error.message}`);
elizaLogger.error(`Error adding participant: ${error.message}`);
return false;

@@ -362,3 +366,3 @@ }

if (error) {
console.error(`Error removing participant: ${error.message}`);
elizaLogger.error(`Error removing participant: ${error.message}`);
return false;

@@ -422,2 +426,149 @@ }

}
async getCache(params) {
const { data, error } = await this.supabase.from("cache").select("value").eq("key", params.key).eq("agentId", params.agentId).single();
if (error) {
elizaLogger.error("Error fetching cache:", error);
return void 0;
}
return data?.value;
}
async setCache(params) {
const { error } = await this.supabase.from("cache").upsert({
key: params.key,
agentId: params.agentId,
value: params.value,
createdAt: /* @__PURE__ */ new Date()
});
if (error) {
elizaLogger.error("Error setting cache:", error);
return false;
}
return true;
}
async deleteCache(params) {
try {
const { error } = await this.supabase.from("cache").delete().eq("key", params.key).eq("agentId", params.agentId);
if (error) {
elizaLogger.error("Error deleting cache", {
error: error.message,
key: params.key,
agentId: params.agentId
});
return false;
}
return true;
} catch (error) {
elizaLogger.error(
"Database connection error in deleteCache",
error instanceof Error ? error.message : String(error)
);
return false;
}
}
async getKnowledge(params) {
let query = this.supabase.from("knowledge").select("*").or(`agentId.eq.${params.agentId},isShared.eq.true`);
if (params.id) {
query = query.eq("id", params.id);
}
if (params.limit) {
query = query.limit(params.limit);
}
const { data, error } = await query;
if (error) {
throw new Error(`Error getting knowledge: ${error.message}`);
}
return data.map((row) => ({
id: row.id,
agentId: row.agentId,
content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
embedding: row.embedding ? new Float32Array(row.embedding) : void 0,
createdAt: new Date(row.createdAt).getTime()
}));
}
async searchKnowledge(params) {
const cacheKey = `embedding_${params.agentId}_${params.searchText}`;
const cachedResult = await this.getCache({
key: cacheKey,
agentId: params.agentId
});
if (cachedResult) {
return JSON.parse(cachedResult);
}
const embedding = Array.from(params.embedding);
const { data, error } = await this.supabase.rpc("search_knowledge", {
query_embedding: embedding,
query_agent_id: params.agentId,
match_threshold: params.match_threshold,
match_count: params.match_count,
search_text: params.searchText || ""
});
if (error) {
throw new Error(`Error searching knowledge: ${error.message}`);
}
const results = data.map((row) => ({
id: row.id,
agentId: row.agentId,
content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
embedding: row.embedding ? new Float32Array(row.embedding) : void 0,
createdAt: new Date(row.createdAt).getTime(),
similarity: row.similarity
}));
await this.setCache({
key: cacheKey,
agentId: params.agentId,
value: JSON.stringify(results)
});
return results;
}
async createKnowledge(knowledge) {
try {
const metadata = knowledge.content.metadata || {};
const { error } = await this.supabase.from("knowledge").insert({
id: knowledge.id,
agentId: metadata.isShared ? null : knowledge.agentId,
content: knowledge.content,
embedding: knowledge.embedding ? Array.from(knowledge.embedding) : null,
createdAt: knowledge.createdAt || /* @__PURE__ */ new Date(),
isMain: metadata.isMain || false,
originalId: metadata.originalId || null,
chunkIndex: metadata.chunkIndex || null,
isShared: metadata.isShared || false
});
if (error) {
if (metadata.isShared && error.code === "23505") {
elizaLogger.info(`Shared knowledge ${knowledge.id} already exists, skipping`);
return;
}
throw error;
}
} catch (error) {
elizaLogger.error(`Error creating knowledge ${knowledge.id}:`, {
error,
embeddingLength: knowledge.embedding?.length,
content: knowledge.content
});
throw error;
}
}
async removeKnowledge(id) {
const { error } = await this.supabase.from("knowledge").delete().eq("id", id);
if (error) {
throw new Error(`Error removing knowledge: ${error.message}`);
}
}
async clearKnowledge(agentId, shared) {
if (shared) {
const { error } = await this.supabase.from("knowledge").delete().filter("agentId", "eq", agentId).filter("isShared", "eq", true);
if (error) {
elizaLogger.error(`Error clearing shared knowledge for agent ${agentId}:`, error);
throw error;
}
} else {
const { error } = await this.supabase.from("knowledge").delete().eq("agentId", agentId);
if (error) {
elizaLogger.error(`Error clearing knowledge for agent ${agentId}:`, error);
throw error;
}
}
}
};

@@ -424,0 +575,0 @@ export {

6

package.json
{
"name": "@elizaos/adapter-supabase",
"version": "0.1.7",
"version": "0.1.8+build.1",
"type": "module",

@@ -22,3 +22,3 @@ "main": "dist/index.js",

"dependencies": {
"@elizaos/core": "0.1.7",
"@elizaos/core": "0.1.8+build.1",
"@supabase/supabase-js": "2.46.2"

@@ -37,3 +37,3 @@ },

},
"gitHead": "e15421524dde4f2778b529effb212eebea8c98b6"
"gitHead": "d55c86c961960b4b34528c358eb34b2ff4b34d87"
}

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc