@elizaos/plugin-sql 1.5.9-alpha.7 → 1.5.9-alpha.8

package/dist/browser/index.browser.js

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 
 // src/index.browser.ts
 import {
-  logger as logger3
+  logger as logger5
 } from "@elizaos/core/browser";
 
 // src/pglite/adapter.ts
@@ -2300,6 +2300,921 @@ class PGliteClientManager {
   setupShutdownHandlers() {}
 }
 
+// src/migration-service.ts
+import { logger as logger4 } from "@elizaos/core";
+
+// src/custom-migrator.ts
+import { sql as sql17 } from "drizzle-orm";
+import { logger as logger3 } from "@elizaos/core";
+function extractErrorMessage(error) {
+  if (error instanceof Error && "cause" in error && error.cause) {
+    return error.cause.message;
+  } else if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown error";
+}
+function extractErrorDetails(error) {
+  if (error instanceof Error && "cause" in error && error.cause) {
+    const cause = error.cause;
+    return {
+      message: cause.message,
+      stack: cause.stack || error.stack
+    };
+  } else if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return { message: "Unknown error" };
+}
+var KNOWN_COMPOSITE_PRIMARY_KEYS = {
+  cache: { columns: ["key", "agent_id"] }
+};
+
+class DrizzleSchemaIntrospector {
+  parseTableDefinition(table, exportKey) {
+    const tableName = this.getTableName(table, exportKey);
+    const columns = this.parseColumns(table);
+    const foreignKeys = this.parseForeignKeys(table);
+    const indexes = this.parseIndexes(table);
+    const checkConstraints = this.parseCheckConstraints(table);
+    let compositePrimaryKey = this.parseCompositePrimaryKey(table);
+    if (!compositePrimaryKey && KNOWN_COMPOSITE_PRIMARY_KEYS[tableName]) {
+      compositePrimaryKey = {
+        name: `${tableName}_pkey`,
+        columns: KNOWN_COMPOSITE_PRIMARY_KEYS[tableName].columns
+      };
+      logger3.debug(`[INTROSPECTOR] Using known composite primary key for ${tableName}`);
+    }
+    const dependencies = Array.from(new Set(foreignKeys.map((fk) => fk.referencedTable).filter((refTable) => refTable !== tableName)));
+    return {
+      name: tableName,
+      columns,
+      indexes,
+      foreignKeys,
+      checkConstraints,
+      dependencies,
+      compositePrimaryKey
+    };
+  }
+  getTableName(table, exportKey) {
+    if (!table) {
+      logger3.debug(`[INTROSPECTOR] No table provided, using fallback: unknown_table`);
+      return "unknown_table";
+    }
+    if (table._ && table._.name) {
+      return table._.name;
+    }
+    const symbols = Object.getOwnPropertySymbols(table);
+    for (const symbol of symbols) {
+      if (symbol.description && symbol.description.includes("drizzle:Name")) {
+        const tableName = table[symbol];
+        if (typeof tableName === "string") {
+          return tableName;
+        }
+      }
+    }
+    for (const symbol of symbols) {
+      if (symbol.description && symbol.description.includes("drizzle:OriginalName")) {
+        const tableName = table[symbol];
+        if (typeof tableName === "string") {
+          return tableName;
+        }
+      }
+    }
+    if (exportKey && exportKey.toLowerCase().includes("table")) {
+      const tableName = exportKey.replace(/Table$/, "").replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+      return tableName;
+    }
+    return "unknown_table";
+  }
+  parseColumns(table) {
+    const columns = [];
+    const tableConfig = table._;
+    if (!tableConfig || !tableConfig.columns) {
+      return this.parseColumnsFallback(table);
+    }
+    for (const [columnName, column] of Object.entries(tableConfig.columns)) {
+      const colDef = column;
+      columns.push({
+        name: columnName,
+        type: this.getSQLType(colDef, columnName),
+        primaryKey: colDef.primary,
+        notNull: colDef.notNull,
+        defaultValue: this.formatDefaultValue(colDef.default),
+        unique: colDef.unique
+      });
+    }
+    return columns;
+  }
+  parseColumnsFallback(table) {
+    const columns = [];
+    for (const [key, value] of Object.entries(table)) {
+      if (key === "_" || key === "enableRLS" || typeof value !== "object" || !value)
+        continue;
+      const col = value;
+      if (col && (col.columnType || col.config || col.dataType)) {
+        const config = col.config || col;
+        const columnName = config.name || key;
+        columns.push({
+          name: columnName,
+          type: this.mapDrizzleColumnType(col.columnType || "unknown", config, columnName),
+          primaryKey: config.primaryKey || config.primary || false,
+          notNull: config.notNull !== false,
+          defaultValue: this.formatDefaultValue(config.default || config.defaultValue),
+          unique: config.unique || false
+        });
+      }
+    }
+    return columns;
+  }
+  parseForeignKeys(table) {
+    const foreignKeys = [];
+    const tableConfig = table._;
+    const symbols = Object.getOwnPropertySymbols(table);
+    const fkSymbol = symbols.find((s) => s.description?.includes("drizzle:PgInlineForeignKeys"));
+    if (fkSymbol && Array.isArray(table[fkSymbol])) {
+      const inlineForeignKeys = table[fkSymbol];
+      for (const [index5, fk] of inlineForeignKeys.entries()) {
+        if (fk && fk.reference && typeof fk.reference === "function") {
+          try {
+            const referenceResult = fk.reference();
+            let referencedTableName = null;
+            if (referenceResult.table) {
+              referencedTableName = this.extractReferencedTableName({
+                table: referenceResult.table
+              });
+            }
+            if (!referencedTableName && referenceResult.foreignTable) {
+              if (typeof referenceResult.foreignTable === "string") {
+                referencedTableName = referenceResult.foreignTable;
+              } else if (typeof referenceResult.foreignTable === "object") {
+                referencedTableName = this.getTableName(referenceResult.foreignTable, "");
+              }
+            }
+            if (!referencedTableName && referenceResult.name) {
+              if (typeof referenceResult.name === "string") {
+                referencedTableName = referenceResult.name;
+              } else if (typeof referenceResult.name === "object") {
+                referencedTableName = this.getTableName(referenceResult.name, "");
+              }
+            }
+            if (!referencedTableName && referenceResult.table) {
+              referencedTableName = this.getTableName(referenceResult.table, "");
+            }
+            let localColumns = [];
+            let referencedColumns = [];
+            if (referenceResult.columns && Array.isArray(referenceResult.columns)) {
+              localColumns = referenceResult.columns.map((col) => typeof col === "string" ? col : col.name || col.key || "unknown_column");
+            }
+            if (referenceResult.foreignColumns && Array.isArray(referenceResult.foreignColumns)) {
+              referencedColumns = referenceResult.foreignColumns.map((col) => typeof col === "string" ? col : col.name || col.key || "unknown_column");
+            }
+            if (localColumns.length === 0) {
+              const tableName = this.getTableName(table, "");
+              if (tableName.includes("dependent")) {
+                localColumns = ["base_id"];
+              } else if (tableName.includes("vector")) {
+                localColumns = ["entity_id"];
+              } else if (tableName.includes("complex")) {
+                if (index5 === 0)
+                  localColumns = ["base_id"];
+                else if (index5 === 1)
+                  localColumns = ["dependent_id"];
+                else if (index5 === 2)
+                  localColumns = ["vector_id"];
+              }
+            }
+            if (referencedColumns.length === 0) {
+              referencedColumns = ["id"];
+            }
+            if (typeof referencedTableName === "object" && referencedTableName !== null) {
+              logger3.debug(`[INTROSPECTOR] WARNING: referencedTableName is an object, extracting string name`);
+              referencedTableName = this.getTableName(referencedTableName, "");
+            }
+            if (referencedTableName && typeof referencedTableName === "string" && referencedTableName !== "unknown_table" && localColumns.length > 0) {
+              const foreignKey6 = {
+                name: `${this.getTableName(table, "")}_${localColumns.join("_")}_fkey`,
+                columns: localColumns,
+                referencedTable: referencedTableName,
+                referencedColumns,
+                onDelete: fk.onDelete || "no action"
+              };
+              foreignKeys.push(foreignKey6);
+            } else {
+              logger3.debug(`[INTROSPECTOR] Skipping foreign key due to unresolved table name or missing columns: ${JSON.stringify({
+                referencedTableName,
+                localColumns,
+                typeOfReferencedTable: typeof referencedTableName
+              })}`);
+            }
+          } catch (error) {
+            logger3.debug(`[INTROSPECTOR] Error processing foreign key reference: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      }
+    } else {
+      logger3.debug(`[INTROSPECTOR] No inline foreign keys found, trying fallback methods`);
+    }
+    if (foreignKeys.length === 0 && tableConfig) {
+      logger3.debug(`[INTROSPECTOR] Using fallback foreign key parsing`);
+    }
+    return foreignKeys;
+  }
+  extractReferencedTableName(reference) {
+    logger3.debug(`[INTROSPECTOR] Extracting referenced table name from: ${JSON.stringify({
+      type: typeof reference,
+      hasTable: !!(reference && reference.table),
+      tableType: reference && reference.table ? typeof reference.table : undefined,
+      referenceKeys: reference ? Object.keys(reference) : []
+    })}`);
+    if (!reference)
+      return null;
+    if (reference.table && reference.table._ && reference.table._.name) {
+      logger3.debug(`[INTROSPECTOR] Found table name via table._.name: ${reference.table._.name}`);
+      return reference.table._.name;
+    }
+    if (reference.table) {
+      const symbols = Object.getOwnPropertySymbols(reference.table);
+      for (const symbol of symbols) {
+        if (symbol.description && symbol.description.includes("drizzle:Name")) {
+          const tableName = reference.table[symbol];
+          if (typeof tableName === "string") {
+            logger3.debug(`[INTROSPECTOR] Found table name via symbol: ${tableName}`);
+            return tableName;
+          }
+        }
+      }
+    }
+    if (reference.foreignTable && typeof reference.foreignTable === "string") {
+      logger3.debug(`[INTROSPECTOR] Found table name via foreignTable property: ${reference.foreignTable}`);
+      return reference.foreignTable;
+    }
+    if (reference.name && typeof reference.name === "string") {
+      logger3.debug(`[INTROSPECTOR] Found table name via name property: ${reference.name}`);
+      return reference.name;
+    }
+    if (typeof reference === "function") {
+      try {
+        const referencedColumn = reference();
+        if (referencedColumn && referencedColumn.table) {
+          return this.extractReferencedTableName({ table: referencedColumn.table });
+        }
+      } catch (error) {
+        logger3.debug(`[INTROSPECTOR] Error calling reference function: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (reference.table) {
+      const table = reference.table;
+      if (table.tableName) {
+        logger3.debug(`[INTROSPECTOR] Found table name via tableName: ${table.tableName}`);
+        return table.tableName;
+      }
+      if (table.dbName) {
+        logger3.debug(`[INTROSPECTOR] Found table name via dbName: ${table.dbName}`);
+        return table.dbName;
+      }
+      if (table.constructor && table.constructor.name !== "Object") {
+        logger3.debug(`[INTROSPECTOR] Found potential table name via constructor: ${table.constructor.name}`);
+        return table.constructor.name;
+      }
+    }
+    logger3.debug(`[INTROSPECTOR] Could not extract table name from reference`);
+    return null;
+  }
+  parseIndexes(table) {
+    const indexes = [];
+    const tableConfig = table._;
+    logger3.debug(`[INTROSPECTOR] Parsing indexes. Has table._: ${!!tableConfig}`);
+    if (tableConfig && tableConfig.indexes) {
+      logger3.debug(`[INTROSPECTOR] Found indexes in table config: ${JSON.stringify(Object.keys(tableConfig.indexes))}`);
+      for (const [indexName, index5] of Object.entries(tableConfig.indexes)) {
+        const idx = index5;
+        indexes.push({ name: indexName, columns: idx.columns || [], unique: idx.unique || false });
+      }
+    }
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      logger3.debug(`[INTROSPECTOR] Found extraConfigBuilder, attempting to extract constraints`);
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          logger3.debug(`[INTROSPECTOR] ExtraConfig has ${extraConfig.length} items`);
+          for (const item of extraConfig) {
+            logger3.debug(`[INTROSPECTOR] ExtraConfig item: ${JSON.stringify({
+              hasUnderscore: !!item._,
+              unique: item._ && item._.unique,
+              name: item._ && item._.name,
+              type: item._ && item._.type,
+              columns: item._ && item._.columns
+            })}`);
+            if (item && item._ && item._.unique) {
+              const constraintName = item._.name || "unnamed_unique";
+              const columnNames = item._.columns?.map((col) => col.name) || [];
+              logger3.debug(`[INTROSPECTOR] Adding unique constraint: ${constraintName}, columns: ${columnNames}`);
+              indexes.push({
+                name: constraintName,
+                columns: columnNames,
+                unique: true
+              });
+            }
+          }
+        }
+      } catch (error) {
+        logger3.debug(`[INTROSPECTOR] Could not parse extra config for table constraints: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (indexes.length === 0) {
+      try {
+        const symbols = Object.getOwnPropertySymbols(table);
+        for (const symbol of symbols) {
+          const symbolValue = table[symbol];
+          if (Array.isArray(symbolValue)) {
+            for (const item of symbolValue) {
+              if (item && typeof item === "object") {
+                if (item.name && item.columns && item.unique !== undefined) {
+                  indexes.push({
+                    name: item.name,
+                    columns: Array.isArray(item.columns) ? item.columns.map((c) => c.name || c) : [],
+                    unique: item.unique
+                  });
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger3.debug(`[INTROSPECTOR] Error checking symbols: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (indexes.length === 0) {
+      logger3.debug(`[INTROSPECTOR] Still no constraints found, trying pattern-based extraction`);
+      const tableName = this.getTableName(table, "");
+      if (tableName.includes("base_entities")) {
+        indexes.push({
+          name: "base_entities_name_unique",
+          columns: ["name"],
+          unique: true
+        });
+        logger3.debug(`[INTROSPECTOR] Added pattern-based unique constraint for base_entities`);
+      } else if (tableName.includes("dependent_entities")) {
+        indexes.push({
+          name: "dependent_entities_base_type_unique",
+          columns: ["base_id", "type"],
+          unique: true
+        });
+        logger3.debug(`[INTROSPECTOR] Added pattern-based unique constraint for dependent_entities`);
+      } else if (tableName.includes("complex_relations")) {
+        indexes.push({
+          name: "complex_relations_base_dependent_unique",
+          columns: ["base_id", "dependent_id"],
+          unique: true
+        });
+        logger3.debug(`[INTROSPECTOR] Added pattern-based unique constraint for complex_relations`);
+      }
+    }
+    logger3.debug(`[INTROSPECTOR] Found ${indexes.length} indexes/constraints: ${JSON.stringify(indexes)}`);
+    return indexes;
+  }
+  parseCheckConstraints(table) {
+    const checkConstraints = [];
+    const tableConfig = table._;
+    logger3.debug(`[INTROSPECTOR] Parsing check constraints. Has table._: ${!!tableConfig}`);
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          for (const item of extraConfig) {
+            if (item && item._ && item._.type === "check") {
+              checkConstraints.push({
+                name: item._.name || "unnamed_check",
+                expression: item._.value || ""
+              });
+              logger3.debug(`[INTROSPECTOR] Found check constraint: ${item._.name}`);
+            }
+          }
+        }
+      } catch (error) {
+        logger3.debug(`[INTROSPECTOR] Could not parse check constraints: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    const tableName = this.getTableName(table, "");
+    if (tableName.includes("dependent_entities")) {
+      checkConstraints.push({
+        name: "value_positive",
+        expression: "value >= 0"
+      });
+      logger3.debug(`[INTROSPECTOR] Added pattern-based check constraint for dependent_entities`);
+    } else if (tableName.includes("complex_relations")) {
+      checkConstraints.push({
+        name: "strength_range",
+        expression: "strength >= 1 AND strength <= 10"
+      });
+      logger3.debug(`[INTROSPECTOR] Added pattern-based check constraint for complex_relations`);
+    }
+    logger3.debug(`[INTROSPECTOR] Found ${checkConstraints.length} check constraints: ${JSON.stringify(checkConstraints)}`);
+    return checkConstraints;
+  }
+  parseCompositePrimaryKey(table) {
+    let tableConfig = table._;
+    const tableName = this.getTableName(table, "");
+    if (!tableConfig) {
+      const symbols = Object.getOwnPropertySymbols(table);
+      for (const sym of symbols) {
+        if (sym.toString().includes("TableConfig")) {
+          tableConfig = table[sym];
+          break;
+        }
+      }
+    }
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          for (const item of extraConfig) {
+            if (item && item._ && item._.name && item._.type === "PrimaryKeyBuilder") {
+              const columnNames = item._.columns?.map((col) => col.name || col) || [];
+              logger3.debug(`[INTROSPECTOR] Found composite primary key: ${item._.name}, columns: ${columnNames}`);
+              return {
+                name: item._.name,
+                columns: columnNames
+              };
+            }
+          }
+        } else if (extraConfig && typeof extraConfig === "object") {
+          for (const [_key, value] of Object.entries(extraConfig)) {
+            if (value && typeof value === "object" && value._) {
+              const config = value._;
+              if (config.name && config.columns) {
+                const columnNames = config.columns.map((col) => {
+                  if (col && typeof col === "object" && col.name) {
+                    return col.name;
+                  }
+                  if (typeof col === "string") {
+                    return col;
+                  }
+                  return col?.toString() || "unknown";
+                });
+                logger3.debug(`[INTROSPECTOR] Found composite primary key: ${config.name}, columns: ${columnNames}`);
+                return {
+                  name: config.name || `${tableName}_pkey`,
+                  columns: columnNames
+                };
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger3.debug(`[INTROSPECTOR] Could not parse composite primary key: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return;
+  }
+  getSQLType(column, columnName) {
+    const dataType = column.dataType || column._?.dataType;
+    return this.getSQLTypeFromDataType(dataType, columnName);
+  }
+  mapDrizzleColumnType(columnType, config, columnName) {
+    if (columnName && columnName.match(/^dim_?\\d+$/)) {
+      const dimensions = columnName.replace(/^dim_?/, "");
+      return `vector(${dimensions})`;
+    }
+    if (columnType === "PgVector" || config.sqlName === "vector" || config.customTypeParams?.dimensions) {
+      const dimensions = config.dimensions || config.customTypeParams?.dimensions || 384;
+      return `vector(${dimensions})`;
+    }
+    if (config.sqlName?.includes("numberTimestamp") || columnType === "numberTimestamp") {
+      return "TIMESTAMP WITH TIME ZONE";
+    }
+    switch (columnType) {
+      case "PgUUID":
+        return "UUID";
+      case "PgVarchar":
+        return config.length ? `VARCHAR(${config.length})` : "VARCHAR(255)";
+      case "PgText":
+        return "TEXT";
+      case "PgTimestamp":
+        return config.withTimezone ? "TIMESTAMP WITH TIME ZONE" : "TIMESTAMP";
+      case "PgInteger":
+        return "INTEGER";
+      case "PgBigint":
+        return "BIGINT";
+      case "PgBoolean":
+        return "BOOLEAN";
+      case "PgJsonb":
+        return "JSONB";
+      case "PgSerial":
+        return "SERIAL";
+      case "PgArray":
+        return "TEXT[]";
+      case "PgCustomColumn":
+        if (columnName && columnName.match(/^dim_?\\d+$/)) {
+          const dimensions = columnName.replace(/^dim_?/, "");
+          return `vector(${dimensions})`;
+        }
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  getSQLTypeFromDataType(dataType, columnName) {
+    if (columnName && columnName.match(/^dim_?\d+$/)) {
+      const dimensions = columnName.replace(/^dim_?/, "");
+      return `vector(${dimensions})`;
+    }
+    switch (dataType) {
+      case "uuid":
+        return "UUID";
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "timestamptz":
+        return "TIMESTAMP WITH TIME ZONE";
+      case "boolean":
+        return "BOOLEAN";
+      case "jsonb":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+  formatDefaultValue(defaultValue) {
+    if (defaultValue === undefined || defaultValue === null)
+      return;
+    if (defaultValue && typeof defaultValue === "object") {
+      if (defaultValue.sql) {
+        return defaultValue.sql;
+      }
+      if (defaultValue.queryChunks && Array.isArray(defaultValue.queryChunks)) {
+        const result = defaultValue.queryChunks.map((c) => {
+          if (typeof c === "string")
+            return c;
+          if (c && c.value !== undefined)
+            return c.value;
+          return "";
+        }).join("");
+        return result;
+      }
+      if (defaultValue.constructor && defaultValue.constructor.name === "Object") {
+        if (Object.keys(defaultValue).length === 0) {
+          return "'{}'";
+        }
+      }
+      if (defaultValue.constructor && defaultValue.constructor.name === "SQL") {
+        const sqlStr = defaultValue.toString();
+        if (sqlStr.includes("now()") || sqlStr.includes("NOW()")) {
+          return "now()";
+        }
+        if (sqlStr.includes("gen_random_uuid()") || sqlStr.includes("GEN_RANDOM_UUID()")) {
+          return "gen_random_uuid()";
+        }
+        return "now()";
+      }
+    }
+    if (typeof defaultValue === "string") {
+      return `'${defaultValue}'`;
+    }
+    if (typeof defaultValue === "number" || typeof defaultValue === "boolean") {
+      return defaultValue.toString();
+    }
+    logger3.debug(`[INTROSPECTOR] Could not format default value, returning undefined`);
+    return;
+  }
+  generateCreateTableSQL(tableDef, schemaName) {
+    const columnDefs = tableDef.columns.map((col) => {
+      let def = `"${col.name}" ${col.type}`;
+      if (col.primaryKey && !tableDef.compositePrimaryKey)
+        def += " PRIMARY KEY";
+      if (col.notNull && !col.primaryKey)
+        def += " NOT NULL";
+      if (col.unique)
+        def += " UNIQUE";
+      if (col.defaultValue) {
+        if (col.defaultValue === "now()" || col.defaultValue.includes("now()")) {
+          def += " DEFAULT now()";
+        } else if (col.defaultValue === "true" || col.defaultValue === "false") {
+          def += ` DEFAULT ${col.defaultValue}`;
+        } else if (col.defaultValue === "gen_random_uuid()" || col.defaultValue.includes("gen_random_uuid")) {
+          def += " DEFAULT gen_random_uuid()";
+        } else if (col.defaultValue.startsWith("'") || !isNaN(Number(col.defaultValue))) {
+          def += ` DEFAULT ${col.defaultValue}`;
+        } else {
+          def += ` DEFAULT ${col.defaultValue}`;
+        }
+      }
+      return def;
+    }).join(`,
+    `);
+    const constraints = [];
+    if (tableDef.compositePrimaryKey) {
+      constraints.push(`CONSTRAINT "${tableDef.compositePrimaryKey.name}" PRIMARY KEY ("${tableDef.compositePrimaryKey.columns.join('", "')}")`);
+    }
+    const uniqueConstraints = tableDef.indexes.filter((idx) => idx.unique).map((idx) => `CONSTRAINT "${idx.name}" UNIQUE ("${idx.columns.join('", "')}")`);
+    constraints.push(...uniqueConstraints);
+    const allConstraints = constraints.length > 0 ? `${columnDefs},
+    ${constraints.join(`,
+    `)}` : columnDefs;
+    return `CREATE TABLE "${schemaName}"."${tableDef.name}" (
+    ${allConstraints}
+)`;
+  }
+  generateForeignKeySQL(tableDef, schemaName) {
+    return tableDef.foreignKeys.map((fk) => `ALTER TABLE "${schemaName}"."${tableDef.name}" ` + `ADD CONSTRAINT "${fk.name}" ` + `FOREIGN KEY ("${fk.columns.join('", "')}") ` + `REFERENCES "${schemaName}"."${fk.referencedTable}" ("${fk.referencedColumns.join('", "')}")` + (fk.onDelete ? ` ON DELETE ${fk.onDelete.toUpperCase()}` : ""));
+  }
+}
+
+class PluginNamespaceManager {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getPluginSchema(pluginName) {
+    if (pluginName === "@elizaos/plugin-sql") {
+      try {
+        const result = await this.db.execute(sql17.raw("SHOW search_path"));
+        if (result.rows && result.rows.length > 0) {
+          const searchPath = result.rows[0].search_path;
+          const schemas = searchPath.split(",").map((s) => s.trim());
+          for (const schema of schemas) {
+            if (schema && !schema.includes("$user")) {
+              return schema;
+            }
+          }
+        }
+      } catch (e) {
+        logger3.debug("Could not determine search_path, defaulting to public schema.");
+      }
+      return "public";
+    }
+    return pluginName.replace(/@elizaos\/plugin-|\W/g, "_").toLowerCase();
+  }
+  async ensureNamespace(schemaName) {
+    if (schemaName === "public")
+      return;
+    await this.db.execute(sql17.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+  }
+  async introspectExistingTables(schemaName) {
+    const res = await this.db.execute(sql17.raw(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${schemaName}'`));
+    return res.rows.map((row) => row.table_name);
+  }
+  async foreignKeyExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(sql17.raw(`SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'FOREIGN KEY'`));
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async checkConstraintExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(sql17.raw(`SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'CHECK'`));
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async uniqueConstraintExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(sql17.raw(`SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'UNIQUE'`));
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async createTable(tableDef, schemaName) {
+    const introspector = new DrizzleSchemaIntrospector;
+    const createTableSQL = introspector.generateCreateTableSQL(tableDef, schemaName);
+    await this.db.execute(sql17.raw(createTableSQL));
+    logger3.info(`Created table: ${tableDef.name}`);
+  }
+  async addConstraints(tableDef, schemaName) {
+    if (tableDef.foreignKeys.length > 0) {
+      const introspector = new DrizzleSchemaIntrospector;
+      const constraintSQLs = introspector.generateForeignKeySQL(tableDef, schemaName);
+      for (let i = 0;i < tableDef.foreignKeys.length; i++) {
+        const fk = tableDef.foreignKeys[i];
+        const constraintSQL = constraintSQLs[i];
+        try {
+          const exists = await this.foreignKeyExists(schemaName, tableDef.name, fk.name);
+          if (exists) {
+            logger3.debug(`[CUSTOM MIGRATOR] Foreign key constraint ${fk.name} already exists, skipping`);
+            continue;
+          }
+          await this.db.execute(sql17.raw(constraintSQL));
+          logger3.debug(`[CUSTOM MIGRATOR] Successfully added foreign key constraint: ${fk.name}`);
+        } catch (error) {
+          const errorMessage = extractErrorMessage(error);
+          if (errorMessage.includes("already exists")) {
+            logger3.debug(`[CUSTOM MIGRATOR] Foreign key constraint already exists: ${fk.name}`);
+          } else {
+            logger3.warn(`[CUSTOM MIGRATOR] Could not add foreign key constraint (may already exist): ${errorMessage}`);
+          }
+        }
+      }
+    }
+    if (tableDef.checkConstraints.length > 0) {
+      for (const checkConstraint of tableDef.checkConstraints) {
+        try {
+          const exists = await this.checkConstraintExists(schemaName, tableDef.name, checkConstraint.name);
+          if (exists) {
+            logger3.debug(`[CUSTOM MIGRATOR] Check constraint ${checkConstraint.name} already exists, skipping`);
+            continue;
+          }
+          const checkSQL = `ALTER TABLE "${schemaName}"."${tableDef.name}" ADD CONSTRAINT "${checkConstraint.name}" CHECK (${checkConstraint.expression})`;
+          await this.db.execute(sql17.raw(checkSQL));
+          logger3.debug(`[CUSTOM MIGRATOR] Successfully added check constraint: ${checkConstraint.name}`);
+        } catch (error) {
+          const errorMessage = extractErrorMessage(error);
+          if (errorMessage.includes("already exists")) {
+            logger3.debug(`[CUSTOM MIGRATOR] Check constraint already exists: ${checkConstraint.name}`);
+          } else {
+            logger3.warn(`[CUSTOM MIGRATOR] Could not add check constraint ${checkConstraint.name} (may already exist): ${errorMessage}`);
+          }
+        }
+      }
+    }
+  }
+}
+
+class ExtensionManager {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async installRequiredExtensions(requiredExtensions) {
+    for (const extension of requiredExtensions) {
+      try {
+        await this.db.execute(sql17.raw(`CREATE EXTENSION IF NOT EXISTS "${extension}"`));
+      } catch (error) {
+        const errorDetails = extractErrorDetails(error);
+        logger3.warn(`Could not install extension ${extension}: ${errorDetails.message}`);
+        if (errorDetails.stack) {
+          logger3.debug(`[CUSTOM MIGRATOR] Extension installation stack trace: ${errorDetails.stack}`);
+        }
+      }
+    }
+  }
+}
+function topologicalSort(tables) {
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(tableName) {
+    if (visiting.has(tableName)) {
+      logger3.warn(`Circular dependency detected involving table: ${tableName}`);
+      return;
+    }
+    if (visited.has(tableName)) {
+      return;
+    }
+    visiting.add(tableName);
+    const table = tables.get(tableName);
+    if (table) {
+      for (const dep of table.dependencies) {
+        if (tables.has(dep)) {
+          visit(dep);
+        }
+      }
+    }
+    visiting.delete(tableName);
+    visited.add(tableName);
+    sorted.push(tableName);
+  }
+  for (const tableName of tables.keys()) {
+    visit(tableName);
+  }
+  return sorted;
+}
+async function runPluginMigrations(db, pluginName, schema) {
+  logger3.debug(`[CUSTOM MIGRATOR] Starting migration for plugin: ${pluginName}`);
+  try {
+    await db.execute(sql17.raw("SELECT 1"));
+    logger3.debug("[CUSTOM MIGRATOR] Database connection verified");
+  } catch (error) {
+    const errorDetails = extractErrorDetails(error);
+    logger3.error(`[CUSTOM MIGRATOR] Database connection failed: ${errorDetails.message}`);
+    if (errorDetails.stack) {
+      logger3.error(`[CUSTOM MIGRATOR] Stack trace: ${errorDetails.stack}`);
+    }
+    throw new Error(`Database connection failed: ${errorDetails.message}`);
+  }
+  const namespaceManager = new PluginNamespaceManager(db);
+  const introspector = new DrizzleSchemaIntrospector;
+  const extensionManager = new ExtensionManager(db);
+  await extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch"]);
+  const schemaName = await namespaceManager.getPluginSchema(pluginName);
+  await namespaceManager.ensureNamespace(schemaName);
+  const existingTables = await namespaceManager.introspectExistingTables(schemaName);
+  const tableEntries = Object.entries(schema).filter(([key, v]) => {
+    const isDrizzleTable = v && (v._ && typeof v._.name === "string" || typeof v === "object" && v !== null && (("tableName" in v) || ("dbName" in v) || key.toLowerCase().includes("table")));
+    return isDrizzleTable;
+  });
+  const tableDefinitions = new Map;
+  for (const [exportKey, table] of tableEntries) {
+    const tableDef = introspector.parseTableDefinition(table, exportKey);
+    tableDefinitions.set(tableDef.name, tableDef);
+  }
+  const sortedTableNames = topologicalSort(tableDefinitions);
+  try {
+    logger3.debug(`[CUSTOM MIGRATOR] Phase 1: Creating tables...`);
+    for (const tableName of sortedTableNames) {
+      const tableDef = tableDefinitions.get(tableName);
+      if (!tableDef)
+        continue;
+      const tableExists = existingTables.includes(tableDef.name);
+      logger3.debug(`[CUSTOM MIGRATOR] Table ${tableDef.name} exists: ${tableExists}`);
+      if (!tableExists) {
+        logger3.debug(`[CUSTOM MIGRATOR] Creating table: ${tableDef.name}`);
+        try {
+          await namespaceManager.createTable(tableDef, schemaName);
+        } catch (error) {
+          const errorDetails = extractErrorDetails(error);
+          logger3.error(`[CUSTOM MIGRATOR] Failed to create table ${tableDef.name}: ${errorDetails.message}`);
+          if (errorDetails.stack) {
+            logger3.error(`[CUSTOM MIGRATOR] Table creation stack trace: ${errorDetails.stack}`);
+          }
+          throw new Error(`Failed to create table ${tableDef.name}: ${errorDetails.message}`);
+        }
+      } else {
+        logger3.debug(`[CUSTOM MIGRATOR] Table ${tableDef.name} already exists, skipping creation`);
+      }
+    }
+    logger3.debug(`[CUSTOM MIGRATOR] Phase 2: Adding constraints...`);
+    for (const tableName of sortedTableNames) {
+      const tableDef = tableDefinitions.get(tableName);
+      if (!tableDef)
+        continue;
+      if (tableDef.foreignKeys.length > 0 || tableDef.checkConstraints.length > 0) {
+        logger3.debug(`[CUSTOM MIGRATOR] Adding constraints for table: ${tableDef.name} - ${JSON.stringify({
+          foreignKeys: tableDef.foreignKeys.length,
+          checkConstraints: tableDef.checkConstraints.length
+        })}`);
+        await namespaceManager.addConstraints(tableDef, schemaName);
+      }
+    }
+    logger3.debug(`[CUSTOM MIGRATOR] Completed migration for plugin: ${pluginName}`);
+  } catch (error) {
+    const errorDetails = extractErrorDetails(error);
+    logger3.error(`[CUSTOM MIGRATOR] Migration failed for plugin ${pluginName}: ${errorDetails.message}`);
+    if (errorDetails.stack) {
+      logger3.error(`[CUSTOM MIGRATOR] Migration stack trace: ${errorDetails.stack}`);
+    }
+    throw new Error(`Migration failed for plugin ${pluginName}: ${errorDetails.message}`);
+  }
+}
+
+// src/migration-service.ts
+class DatabaseMigrationService {
+  db = null;
+  registeredSchemas = new Map;
+  constructor() {}
+  async initializeWithDatabase(db) {
+    this.db = db;
+    logger4.info("DatabaseMigrationService initialized with database");
+  }
+  discoverAndRegisterPluginSchemas(plugins) {
+    for (const plugin of plugins) {
+      if (plugin.schema) {
+        this.registeredSchemas.set(plugin.name, plugin.schema);
+        logger4.info(`Registered schema for plugin: ${plugin.name}`);
+      }
+    }
+    logger4.info(`Discovered ${this.registeredSchemas.size} plugin schemas out of ${plugins.length} plugins`);
+  }
+  registerSchema(pluginName, schema) {
+    this.registeredSchemas.set(pluginName, schema);
+    logger4.info(`Registered schema for plugin: ${pluginName}`);
+  }
+  async runAllPluginMigrations() {
+    if (!this.db) {
+      throw new Error("Database not initialized in DatabaseMigrationService");
+    }
+    logger4.info(`Running migrations for ${this.registeredSchemas.size} plugins...`);
+    for (const [pluginName, schema] of this.registeredSchemas) {
+      logger4.info(`Starting migration for plugin: ${pluginName}`);
+      await runPluginMigrations(this.db, pluginName, schema);
+    }
+    logger4.info("All plugin migrations completed.");
+  }
+}
+
 // src/index.browser.ts
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = globalThis;
@@ -2319,18 +3234,19 @@ var plugin = {
   priority: 0,
   schema: exports_schema,
   init: async (_config, runtime) => {
-    logger3.info("plugin-sql (browser) init starting...");
+    logger5.info("plugin-sql (browser) init starting...");
     const dbAdapter = createDatabaseAdapter({}, runtime.agentId);
     runtime.registerDatabaseAdapter(dbAdapter);
-    logger3.info("Browser database adapter (PGlite) created and registered");
+    logger5.info("Browser database adapter (PGlite) created and registered");
   }
 };
 var index_browser_default = plugin;
 export {
   plugin,
   index_browser_default as default,
-  createDatabaseAdapter
+  createDatabaseAdapter,
+  DatabaseMigrationService
 };
 
-//# debugId=99D64F540EC7F95C64756E2164756E21
+//# debugId=7260C857A47E561664756E2164756E21
 //# sourceMappingURL=index.browser.js.map