@elizaos/plugin-sql 2.0.0-alpha.2 → 2.0.0-alpha.20

package/schema/relationship.ts

@@ -0,0 +1,50 @@
+import { sql } from "drizzle-orm";
+import {
+  foreignKey,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  unique,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+import { entityTable } from "./entity";
+
+/**
+ * Defines the relationshipTable containing information about relationships between entities and agents.
+ * @type {import('knex').TableBuilder}
+ */
+export const relationshipTable = pgTable(
+  "relationships",
+  {
+    id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    sourceEntityId: uuid("source_entity_id")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    targetEntityId: uuid("target_entity_id")
+      .notNull()
+      .references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid("agent_id")
+      .notNull()
+      .references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text("tags").array(),
+    metadata: jsonb("metadata"),
+  },
+  (table) => [
+    index("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+    unique("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+    foreignKey({
+      name: "fk_user_a",
+      columns: [table.sourceEntityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user_b",
+      columns: [table.targetEntityId],
+      foreignColumns: [entityTable.id],
+    }).onDelete("cascade"),
+  ]
+);

package/schema/room.ts

@@ -0,0 +1,37 @@
+import type { Metadata } from "@elizaos/core";
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Defines a table schema for 'rooms' in the database.
+ *
+ * @typedef {object} RoomTable
+ * @property {string} id - The unique identifier for the room.
+ * @property {string} agentId - The UUID of the agent associated with the room.
+ * @property {string} source - The source of the room.
+ * @property {string} type - The type of the room.
+ * @property {string} messageServerId - The message server ID of the room.
+ * @property {string} worldId - The UUID of the world associated with the room.
+ * @property {string} name - The name of the room.
+ * @property {object} metadata - Additional metadata for the room in JSON format.
+ * @property {string} channelId - The channel ID of the room.
+ * @property {number} createdAt - The timestamp of when the room was created.
+ */
+export const roomTable = pgTable("rooms", {
+  id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+  agentId: uuid("agent_id").references(() => agentTable.id, {
+    onDelete: "cascade",
+  }),
+  source: text("source").notNull(),
+  type: text("type").notNull(),
+  messageServerId: uuid("message_server_id"),
+  worldId: uuid("world_id"), // no guarantee that world exists, it is optional for now
+  // .references(() => worldTable.id, {
+  //   onDelete: 'cascade',
+  // }),
+  name: text("name"),
+  metadata: jsonb("metadata").$type<Metadata>(),
+  channelId: text("channel_id"),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+});

package/schema/server.ts

@@ -0,0 +1,14 @@
+import { sql } from "drizzle-orm";
+import { pgTable, timestamp, uuid } from "drizzle-orm/pg-core";
+
+/**
+ * Represents a table for storing server data for RLS multi-tenant isolation.
+ * Each server represents one elizaOS instance in a multi-tenant deployment.
+ *
+ * @type {Table}
+ */
+export const serverTable = pgTable("servers", {
+  id: uuid("id").primaryKey(),
+  createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
+});

package/schema/sessionSummaries.ts

@@ -0,0 +1,27 @@
+import { sql } from "drizzle-orm";
+import { index, integer, jsonb, pgTable, real, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const sessionSummaries = pgTable(
+  "session_summaries",
+  {
+    id: uuid("id").primaryKey().notNull(),
+    agentId: uuid("agent_id").notNull(),
+    roomId: uuid("room_id").notNull(),
+    entityId: uuid("entity_id"),
+    summary: text("summary").notNull(),
+    messageCount: integer("message_count").notNull(),
+    lastMessageOffset: integer("last_message_offset").default(0).notNull(),
+    startTime: timestamp("start_time").notNull(),
+    endTime: timestamp("end_time").notNull(),
+    topics: jsonb("topics").$type<string[]>(),
+    metadata: jsonb("metadata"),
+    embedding: real("embedding").array(),
+    createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at").default(sql`now()`).notNull(),
+  },
+  (table) => [
+    index("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
+    index("session_summaries_entity_idx").on(table.entityId),
+    index("session_summaries_start_time_idx").on(table.startTime),
+  ]
+);

package/schema/tasks.ts

@@ -0,0 +1,24 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents a table schema for tasks in the database.
+ *
+ * @type {PgTable}
+ */
+export const taskTable = pgTable("tasks", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  name: text("name").notNull(),
+  description: text("description"),
+  roomId: uuid("room_id"),
+  worldId: uuid("world_id"),
+  entityId: uuid("entity_id"),
+  agentId: uuid("agent_id")
+    .notNull()
+    .references(() => agentTable.id, { onDelete: "cascade" }),
+  tags: text("tags").array().default(sql`'{}'::text[]`),
+  metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow(),
+});

package/schema/types.ts

@@ -0,0 +1,42 @@
+import { customType } from "drizzle-orm/pg-core";
+
+/**
+ * Represents a custom type for converting a string to a JSONB format and vice versa.
+ * @param {Object} options - The options for the custom type.
+ * @param {Function} options.dataType - A function that returns the data type as "jsonb".
+ * @param {Function} options.toDriver - A function that converts a string to a JSON string.
+ * @param {Function} options.fromDriver - A function that converts a JSON string back to a string.
+ * @returns {Object} - The custom type for string to JSONB conversion.
+ */
+
+export const stringJsonb = customType<{ data: string; driverData: string }>({
+  dataType() {
+    return "jsonb";
+  },
+  toDriver(value: string): string {
+    return JSON.stringify(value);
+  },
+  fromDriver(value: string): string {
+    return JSON.stringify(value);
+  },
+});
+
+/**
+ * Represents a custom type for converting a number to a timestamp string and vice versa.
+ * @param {Object} options - The options for the custom type.
+ * @param {Function} options.dataType - A function that returns the data type as "timestamptz".
+ * @param {Function} options.toDriver - A function that converts a number to a timestamp string using the Date object's toISOString method.
+ * @param {Function} options.fromDriver - A function that converts a timestamp string to a number using the Date object's getTime method.
+ * @returns {Object} - The custom type for number to timestamp conversion.
+ */
+export const numberTimestamp = customType<{ data: number; driverData: string }>({
+  dataType() {
+    return "timestamptz";
+  },
+  toDriver(value: number): string {
+    return new Date(value).toISOString();
+  },
+  fromDriver(value: string): number {
+    return new Date(value).getTime();
+  },
+});

package/schema/world.ts

@@ -0,0 +1,20 @@
+import { sql } from "drizzle-orm";
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { agentTable } from "./agent";
+
+/**
+ * Represents a table schema for worlds in the database.
+ *
+ * @type {PgTable}
+ */
+
+export const worldTable = pgTable("worlds", {
+  id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
+  agentId: uuid("agent_id")
+    .notNull()
+    .references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  metadata: jsonb("metadata"),
+  messageServerId: uuid("message_server_id"),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull(),
+});

package/types.ts

@@ -0,0 +1,19 @@
+import type { IDatabaseAdapter } from "@elizaos/core";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { PgliteDatabase } from "drizzle-orm/pglite";
+
+export type DrizzleDatabase = NodePgDatabase | PgliteDatabase;
+
+export interface IDatabaseClientManager<T> {
+  initialize(): Promise<void>;
+  getConnection(): T;
+  close(): Promise<void>;
+}
+
+export function getDb(adapter: IDatabaseAdapter): DrizzleDatabase {
+  return adapter.db as DrizzleDatabase;
+}
+
+export function getRow<T>(result: { rows: unknown[] }, index = 0): T | undefined {
+  return result.rows[index] as T | undefined;
+}