@elizaos/plugin-sql 2.0.0-alpha.17 → 2.0.0-alpha.18

package/dist/browser/index.browser.js

@@ -885,174 +885,534 @@ async function applyEntityRLSToAllTables(adapter) {
     logger2.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
   }
 }
-var init_rls = __esm(() => {
-  init_agent();
-  init_server();
-});
+var init_rls = () => {};
 
-// runtime-migrator/drizzle-adapters/diff-calculator.ts
-var exports_diff_calculator = {};
-__export(exports_diff_calculator, {
-  hasDiffChanges: () => hasDiffChanges,
-  calculateDiff: () => calculateDiff
-});
-function normalizeType(type) {
-  if (!type)
-    return "";
-  const normalized = type.toLowerCase().trim();
-  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone") {
-    return "timestamp";
-  }
-  if (normalized === "serial") {
-    return "integer";
-  }
-  if (normalized === "bigserial") {
-    return "bigint";
-  }
-  if (normalized === "smallserial") {
-    return "smallint";
-  }
-  if (normalized.startsWith("numeric") || normalized.startsWith("decimal")) {
-    const match = normalized.match(/\((\d+)(?:,\s*(\d+))?\)/);
-    if (match) {
-      return `numeric(${match[1]}${match[2] ? `,${match[2]}` : ""})`;
-    }
-    return "numeric";
-  }
-  if (normalized.startsWith("character varying")) {
-    return normalized.replace("character varying", "varchar");
-  }
-  if (normalized === "text[]" || normalized === "_text") {
-    return "text[]";
+// runtime-migrator/crypto-utils.ts
+function extendedHash(str) {
+  const h1 = hashWithSeed(str, 5381);
+  const h2 = hashWithSeed(str, 7919);
+  const h3 = hashWithSeed(str, 104729);
+  const h4 = hashWithSeed(str, 224737);
+  return h1 + h2 + h3 + h4;
+}
+function hashWithSeed(str, seed) {
+  let hash = seed;
+  for (let i = 0;i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
   }
-  return normalized;
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function isIndexChanged(prevIndex, currIndex) {
-  if (prevIndex.isUnique !== currIndex.isUnique)
-    return true;
-  if (prevIndex.method !== currIndex.method)
-    return true;
-  if (prevIndex.where !== currIndex.where)
-    return true;
-  if (prevIndex.concurrently !== currIndex.concurrently)
-    return true;
-  const prevColumns = prevIndex.columns || [];
-  const currColumns = currIndex.columns || [];
-  if (prevColumns.length !== currColumns.length)
-    return true;
-  for (let i = 0;i < prevColumns.length; i++) {
-    const prevCol = prevColumns[i];
-    const currCol = currColumns[i];
-    if (typeof prevCol === "string" && typeof currCol === "string") {
-      if (prevCol !== currCol)
-        return true;
-    } else if (typeof prevCol === "object" && typeof currCol === "object") {
-      if (prevCol.expression !== currCol.expression)
-        return true;
-      if (prevCol.isExpression !== currCol.isExpression)
-        return true;
-      if (prevCol.asc !== currCol.asc)
-        return true;
-      if (prevCol.nulls !== currCol.nulls)
-        return true;
-    } else {
-      return true;
-    }
+function stringToBigInt(str) {
+  const hash = extendedHash(str);
+  let lockId = BigInt(`0x${hash.slice(0, 16)}`);
+  const mask63Bits = 0x7fffffffffffffffn;
+  lockId = lockId & mask63Bits;
+  if (lockId === 0n) {
+    lockId = 1n;
   }
-  return false;
+  return lockId;
 }
-async function calculateDiff(previousSnapshot, currentSnapshot) {
-  const diff = {
-    tables: {
-      created: [],
-      deleted: [],
-      modified: []
-    },
-    columns: {
-      added: [],
-      deleted: [],
-      modified: []
-    },
-    indexes: {
-      created: [],
-      deleted: [],
-      altered: []
-    },
-    foreignKeys: {
-      created: [],
-      deleted: [],
-      altered: []
-    },
-    uniqueConstraints: {
-      created: [],
-      deleted: []
-    },
-    checkConstraints: {
-      created: [],
-      deleted: []
-    }
-  };
-  if (!previousSnapshot) {
-    diff.tables.created = Object.keys(currentSnapshot.tables);
-    for (const tableName in currentSnapshot.tables) {
-      const table = currentSnapshot.tables[tableName];
-      if (table.indexes) {
-        for (const indexName in table.indexes) {
-          diff.indexes.created.push({
-            ...table.indexes[indexName],
-            table: tableName
-          });
-        }
+
+// runtime-migrator/drizzle-adapters/database-introspector.ts
+import { logger as logger3 } from "@elizaos/core";
+import { sql as sql21 } from "drizzle-orm";
+function getRows2(result) {
+  return result.rows;
+}
+
+class DatabaseIntrospector {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async introspectSchema(schemaName = "public") {
+    logger3.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
+    const tables = {};
+    const schemas = {};
+    const enums = {};
+    const allTables = await this.getTables(schemaName);
+    for (const tableInfo of allTables) {
+      const tableName = tableInfo.table_name;
+      const tableSchema = tableInfo.table_schema || "public";
+      logger3.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
+      const columns = await this.getColumns(tableSchema, tableName);
+      const columnsObject = {};
+      const uniqueConstraintObject = {};
+      for (const col of columns) {
+        columnsObject[col.column_name] = {
+          name: col.column_name,
+          type: col.data_type,
+          primaryKey: col.is_primary || false,
+          notNull: col.is_nullable === "NO",
+          default: col.column_default ? this.parseDefault(col.column_default, col.data_type) : undefined
+        };
       }
-      if (table.foreignKeys) {
-        for (const fkName in table.foreignKeys) {
-          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+      const indexes = await this.getIndexes(tableSchema, tableName);
+      const indexesObject = {};
+      for (const idx of indexes) {
+        if (!idx.is_primary && !idx.is_unique_constraint) {
+          if (idx.columns && Array.isArray(idx.columns) && idx.columns.length > 0) {
+            indexesObject[idx.name] = {
+              name: idx.name,
+              columns: idx.columns.map((col) => ({
+                expression: col,
+                isExpression: false
+              })),
+              isUnique: idx.is_unique,
+              method: idx.method || "btree"
+            };
+          }
         }
       }
-    }
-    return diff;
-  }
-  const prevTables = previousSnapshot.tables || {};
-  const currTables = currentSnapshot.tables || {};
-  for (const tableName in currTables) {
-    if (!(tableName in prevTables)) {
-      diff.tables.created.push(tableName);
-      const table = currTables[tableName];
-      if (table.indexes) {
-        for (const indexName in table.indexes) {
-          diff.indexes.created.push({
-            ...table.indexes[indexName],
-            table: tableName
-          });
-        }
+      const foreignKeys = await this.getForeignKeys(tableSchema, tableName);
+      const foreignKeysObject = {};
+      for (const fk of foreignKeys) {
+        foreignKeysObject[fk.name] = {
+          name: fk.name,
+          tableFrom: tableName,
+          schemaFrom: tableSchema,
+          tableTo: fk.foreign_table_name,
+          schemaTo: fk.foreign_table_schema || "public",
+          columnsFrom: [fk.column_name],
+          columnsTo: [fk.foreign_column_name],
+          onDelete: fk.delete_rule?.toLowerCase() || "no action",
+          onUpdate: fk.update_rule?.toLowerCase() || "no action"
+        };
       }
-      if (table.uniqueConstraints) {
-        for (const uqName in table.uniqueConstraints) {
-          diff.uniqueConstraints.created.push({
-            ...table.uniqueConstraints[uqName],
-            table: tableName
-          });
-        }
+      const primaryKeys = await this.getPrimaryKeys(tableSchema, tableName);
+      const primaryKeysObject = {};
+      for (const pk of primaryKeys) {
+        primaryKeysObject[pk.name] = {
+          name: pk.name,
+          columns: pk.columns
+        };
       }
-      if (table.checkConstraints) {
-        for (const checkName in table.checkConstraints) {
-          diff.checkConstraints.created.push({
-            ...table.checkConstraints[checkName],
-            table: tableName
-          });
-        }
+      const uniqueConstraints = await this.getUniqueConstraints(tableSchema, tableName);
+      for (const unq of uniqueConstraints) {
+        uniqueConstraintObject[unq.name] = {
+          name: unq.name,
+          columns: unq.columns,
+          nullsNotDistinct: false
+        };
       }
-      if (table.foreignKeys) {
-        for (const fkName in table.foreignKeys) {
-          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
-        }
+      const checkConstraints = await this.getCheckConstraints(tableSchema, tableName);
+      const checksObject = {};
+      for (const check3 of checkConstraints) {
+        checksObject[check3.name] = {
+          name: check3.name,
+          value: check3.definition
+        };
       }
-    }
-  }
-  for (const tableName in prevTables) {
-    if (!(tableName in currTables)) {
-      diff.tables.deleted.push(tableName);
-    }
+      tables[`${tableSchema}.${tableName}`] = {
+        name: tableName,
+        schema: tableSchema,
+        columns: columnsObject,
+        indexes: indexesObject,
+        foreignKeys: foreignKeysObject,
+        compositePrimaryKeys: primaryKeysObject,
+        uniqueConstraints: uniqueConstraintObject,
+        checkConstraints: checksObject
+      };
+      if (tableSchema && tableSchema !== "public") {
+        schemas[tableSchema] = tableSchema;
+      }
+    }
+    const enumsResult = await this.getEnums(schemaName);
+    for (const enumInfo of enumsResult) {
+      const key = `${enumInfo.schema}.${enumInfo.name}`;
+      if (!enums[key]) {
+        enums[key] = {
+          name: enumInfo.name,
+          schema: enumInfo.schema,
+          values: []
+        };
+      }
+      enums[key].values.push(enumInfo.value);
+    }
+    logger3.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
+    return {
+      version: "7",
+      dialect: "postgresql",
+      tables,
+      schemas,
+      enums,
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
+    };
+  }
+  async getTables(schemaName) {
+    const result = await this.db.execute(sql21`SELECT 
+            table_schema,
+            table_name
+          FROM information_schema.tables
+          WHERE table_schema = ${schemaName}
+            AND table_type = 'BASE TABLE'
+          ORDER BY table_name`);
+    return getRows2(result);
+  }
+  async getColumns(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            a.attname AS column_name,
+            CASE 
+              WHEN a.attnotnull THEN 'NO'
+              ELSE 'YES'
+            END AS is_nullable,
+            CASE 
+              WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
+              AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE ad.adrelid = a.attrelid 
+                AND ad.adnum = a.attnum 
+                AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
+                    || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
+              )
+              THEN CASE a.atttypid
+                WHEN 'int'::regtype THEN 'serial'
+                WHEN 'int8'::regtype THEN 'bigserial'
+                WHEN 'int2'::regtype THEN 'smallserial'
+              END
+              ELSE format_type(a.atttypid, a.atttypmod)
+            END AS data_type,
+            pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+            CASE 
+              WHEN con.contype = 'p' THEN true
+              ELSE false
+            END AS is_primary
+          FROM pg_attribute a
+          JOIN pg_class cls ON cls.oid = a.attrelid
+          JOIN pg_namespace ns ON ns.oid = cls.relnamespace
+          LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+          LEFT JOIN pg_constraint con ON con.conrelid = a.attrelid 
+            AND a.attnum = ANY(con.conkey) 
+            AND con.contype = 'p'
+          WHERE 
+            a.attnum > 0
+            AND NOT a.attisdropped
+            AND ns.nspname = ${schemaName}
+            AND cls.relname = ${tableName}
+          ORDER BY a.attnum`);
+    return getRows2(result);
+  }
+  async getIndexes(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            i.relname AS name,
+            idx.indisunique AS is_unique,
+            idx.indisprimary AS is_primary,
+            con.contype = 'u' AS is_unique_constraint,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = idx.indrelid
+                AND a.attnum = ANY(idx.indkey::int[])
+              ORDER BY a.attnum
+            ) AS columns,
+            am.amname AS method
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class c ON c.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_am am ON am.oid = i.relam
+          LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
+          WHERE n.nspname = ${schemaName}
+            AND c.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getForeignKeys(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT
+            con.conname AS name,
+            att.attname AS column_name,
+            fnsp.nspname AS foreign_table_schema,
+            frel.relname AS foreign_table_name,
+            fatt.attname AS foreign_column_name,
+            CASE con.confupdtype
+              WHEN 'a' THEN 'NO ACTION'
+              WHEN 'r' THEN 'RESTRICT'
+              WHEN 'n' THEN 'SET NULL'
+              WHEN 'c' THEN 'CASCADE'
+              WHEN 'd' THEN 'SET DEFAULT'
+            END AS update_rule,
+            CASE con.confdeltype
+              WHEN 'a' THEN 'NO ACTION'
+              WHEN 'r' THEN 'RESTRICT'
+              WHEN 'n' THEN 'SET NULL'
+              WHEN 'c' THEN 'CASCADE'
+              WHEN 'd' THEN 'SET DEFAULT'
+            END AS delete_rule
+          FROM pg_catalog.pg_constraint con
+          JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
+          LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
+            AND att.attrelid = con.conrelid
+          LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
+          LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
+          LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
+            AND fatt.attrelid = con.confrelid
+          WHERE con.contype = 'f'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getPrimaryKeys(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = con.conrelid
+                AND a.attnum = ANY(con.conkey)
+              ORDER BY a.attnum
+            ) AS columns
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'p'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getUniqueConstraints(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = con.conrelid
+                AND a.attnum = ANY(con.conkey)
+              ORDER BY a.attnum
+            ) AS columns
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'u'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getCheckConstraints(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            pg_get_constraintdef(con.oid) AS definition
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'c'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getEnums(schemaName) {
+    const result = await this.db.execute(sql21`SELECT 
+            n.nspname AS schema,
+            t.typname AS name,
+            e.enumlabel AS value,
+            e.enumsortorder AS sort_order
+          FROM pg_type t
+          JOIN pg_enum e ON t.oid = e.enumtypid
+          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          WHERE n.nspname = ${schemaName}
+          ORDER BY schema, name, sort_order`);
+    return getRows2(result);
+  }
+  parseDefault(defaultValue, dataType) {
+    if (!defaultValue)
+      return;
+    const match = defaultValue.match(/^'(.*)'::/);
+    if (match) {
+      return `'${match[1]}'`;
+    }
+    if (defaultValue.includes("nextval(")) {
+      return;
+    }
+    if (dataType === "boolean") {
+      if (defaultValue === "true")
+        return "true";
+      if (defaultValue === "false")
+        return "false";
+    }
+    return defaultValue;
+  }
+  async hasExistingTables(pluginName) {
+    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
+    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
+          FROM information_schema.tables
+          WHERE table_schema = ${schemaName}
+            AND table_type = 'BASE TABLE'`);
+    const firstRow = result.rows?.[0];
+    const count = parseInt(firstRow && firstRow.count || "0", 10);
+    return count > 0;
+  }
+  deriveSchemaName(pluginName) {
+    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
+  }
+}
+var init_database_introspector = () => {};
+
+// runtime-migrator/drizzle-adapters/diff-calculator.ts
+var exports_diff_calculator = {};
+__export(exports_diff_calculator, {
+  hasDiffChanges: () => hasDiffChanges,
+  calculateDiff: () => calculateDiff
+});
+function normalizeType(type) {
+  if (!type)
+    return "";
+  const normalized = type.toLowerCase().trim();
+  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone") {
+    return "timestamp";
+  }
+  if (normalized === "serial") {
+    return "integer";
+  }
+  if (normalized === "bigserial") {
+    return "bigint";
+  }
+  if (normalized === "smallserial") {
+    return "smallint";
+  }
+  if (normalized.startsWith("numeric") || normalized.startsWith("decimal")) {
+    const match = normalized.match(/\((\d+)(?:,\s*(\d+))?\)/);
+    if (match) {
+      return `numeric(${match[1]}${match[2] ? `,${match[2]}` : ""})`;
+    }
+    return "numeric";
+  }
+  if (normalized.startsWith("character varying")) {
+    return normalized.replace("character varying", "varchar");
+  }
+  if (normalized === "text[]" || normalized === "_text") {
+    return "text[]";
+  }
+  return normalized;
+}
+function isIndexChanged(prevIndex, currIndex) {
+  if (prevIndex.isUnique !== currIndex.isUnique)
+    return true;
+  if (prevIndex.method !== currIndex.method)
+    return true;
+  if (prevIndex.where !== currIndex.where)
+    return true;
+  if (prevIndex.concurrently !== currIndex.concurrently)
+    return true;
+  const prevColumns = prevIndex.columns || [];
+  const currColumns = currIndex.columns || [];
+  if (prevColumns.length !== currColumns.length)
+    return true;
+  for (let i = 0;i < prevColumns.length; i++) {
+    const prevCol = prevColumns[i];
+    const currCol = currColumns[i];
+    if (typeof prevCol === "string" && typeof currCol === "string") {
+      if (prevCol !== currCol)
+        return true;
+    } else if (typeof prevCol === "object" && typeof currCol === "object") {
+      if (prevCol.expression !== currCol.expression)
+        return true;
+      if (prevCol.isExpression !== currCol.isExpression)
+        return true;
+      if (prevCol.asc !== currCol.asc)
+        return true;
+      if (prevCol.nulls !== currCol.nulls)
+        return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+async function calculateDiff(previousSnapshot, currentSnapshot) {
+  const diff = {
+    tables: {
+      created: [],
+      deleted: [],
+      modified: []
+    },
+    columns: {
+      added: [],
+      deleted: [],
+      modified: []
+    },
+    indexes: {
+      created: [],
+      deleted: [],
+      altered: []
+    },
+    foreignKeys: {
+      created: [],
+      deleted: [],
+      altered: []
+    },
+    uniqueConstraints: {
+      created: [],
+      deleted: []
+    },
+    checkConstraints: {
+      created: [],
+      deleted: []
+    }
+  };
+  if (!previousSnapshot) {
+    diff.tables.created = Object.keys(currentSnapshot.tables);
+    for (const tableName in currentSnapshot.tables) {
+      const table = currentSnapshot.tables[tableName];
+      if (table.indexes) {
+        for (const indexName in table.indexes) {
+          diff.indexes.created.push({
+            ...table.indexes[indexName],
+            table: tableName
+          });
+        }
+      }
+      if (table.foreignKeys) {
+        for (const fkName in table.foreignKeys) {
+          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+        }
+      }
+    }
+    return diff;
+  }
+  const prevTables = previousSnapshot.tables || {};
+  const currTables = currentSnapshot.tables || {};
+  for (const tableName in currTables) {
+    if (!(tableName in prevTables)) {
+      diff.tables.created.push(tableName);
+      const table = currTables[tableName];
+      if (table.indexes) {
+        for (const indexName in table.indexes) {
+          diff.indexes.created.push({
+            ...table.indexes[indexName],
+            table: tableName
+          });
+        }
+      }
+      if (table.uniqueConstraints) {
+        for (const uqName in table.uniqueConstraints) {
+          diff.uniqueConstraints.created.push({
+            ...table.uniqueConstraints[uqName],
+            table: tableName
+          });
+        }
+      }
+      if (table.checkConstraints) {
+        for (const checkName in table.checkConstraints) {
+          diff.checkConstraints.created.push({
+            ...table.checkConstraints[checkName],
+            table: tableName
+          });
+        }
+      }
+      if (table.foreignKeys) {
+        for (const fkName in table.foreignKeys) {
+          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+        }
+      }
+    }
+  }
+  for (const tableName in prevTables) {
+    if (!(tableName in currTables)) {
+      diff.tables.deleted.push(tableName);
+    }
   }
   for (const tableName in currTables) {
     if (tableName in prevTables) {
@@ -1221,32 +1581,6 @@ function hasDiffChanges(diff) {
   return diff.tables.created.length > 0 || diff.tables.deleted.length > 0 || diff.tables.modified.length > 0 || diff.columns.added.length > 0 || diff.columns.deleted.length > 0 || diff.columns.modified.length > 0 || diff.indexes.created.length > 0 || diff.indexes.deleted.length > 0 || diff.indexes.altered.length > 0 || diff.foreignKeys.created.length > 0 || diff.foreignKeys.deleted.length > 0 || diff.foreignKeys.altered.length > 0 || diff.uniqueConstraints.created.length > 0 || diff.uniqueConstraints.deleted.length > 0 || diff.checkConstraints.created.length > 0 || diff.checkConstraints.deleted.length > 0;
 }
 
-// runtime-migrator/crypto-utils.ts
-function extendedHash(str) {
-  const h1 = hashWithSeed(str, 5381);
-  const h2 = hashWithSeed(str, 7919);
-  const h3 = hashWithSeed(str, 104729);
-  const h4 = hashWithSeed(str, 224737);
-  return h1 + h2 + h3 + h4;
-}
-function hashWithSeed(str, seed) {
-  let hash = seed;
-  for (let i = 0;i < str.length; i++) {
-    hash = hash * 33 ^ str.charCodeAt(i);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function stringToBigInt(str) {
-  const hash = extendedHash(str);
-  let lockId = BigInt(`0x${hash.slice(0, 16)}`);
-  const mask63Bits = 0x7fffffffffffffffn;
-  lockId = lockId & mask63Bits;
-  if (lockId === 0n) {
-    lockId = 1n;
-  }
-  return lockId;
-}
-
 // runtime-migrator/drizzle-adapters/snapshot-generator.ts
 import { is, SQL } from "drizzle-orm";
 import { getTableConfig, PgDialect, PgTable } from "drizzle-orm/pg-core";
@@ -1475,7 +1809,7 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql21, _casing) => {
+var sqlToStr = (sql22, _casing) => {
   const config = {
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
@@ -1488,12 +1822,12 @@ var sqlToStr = (sql21, _casing) => {
     },
     casing: undefined
   };
-  return sql21.toQuery(config).sql;
+  return sql22.toQuery(config).sql;
 };
 var init_snapshot_generator = () => {};
 
 // runtime-migrator/drizzle-adapters/sql-generator.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 function checkForDataLoss(diff) {
   const result = {
     hasDataLoss: false,
@@ -1623,7 +1957,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger3.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
+    logger4.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -1776,24 +2110,29 @@ function generateCreateTableSQL(fullTableName, table) {
   const foreignKeys = table.foreignKeys || {};
   for (const [fkName, fkDef] of Object.entries(foreignKeys)) {
     const fk = fkDef;
-    const fkSQL = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${fkName}" FOREIGN KEY (${fk.columnsFrom.map((c) => `"${c}"`).join(", ")}) REFERENCES "${fk.schemaTo || "public"}"."${fk.tableTo}" (${fk.columnsTo.map((c) => `"${c}"`).join(", ")})${fk.onDelete ? ` ON DELETE ${fk.onDelete}` : ""}${fk.onUpdate ? ` ON UPDATE ${fk.onUpdate}` : ""};`;
+    const fkSQL = wrapConstraintCreationGuard(fkName, buildCreateForeignKeyBodySQL({
+      ...fk,
+      name: fkName,
+      schemaFrom: schema,
+      tableFrom: tableName
+    }));
     fkSQLs.push(fkSQL);
   }
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql21 = `"${name}" ${def.type}`;
+  let sql22 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql21 += " PRIMARY KEY";
+    sql22 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql21 += " NOT NULL";
+    sql22 += " NOT NULL";
   }
   if (def.default !== undefined) {
     const defaultValue = formatDefaultValue(def.default, def.type);
-    sql21 += ` DEFAULT ${defaultValue}`;
+    sql22 += ` DEFAULT ${defaultValue}`;
   }
-  return sql21;
+  return sql22;
 }
 function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
@@ -1803,543 +2142,213 @@ function generateAddColumnSQL(table, column, definition) {
   if (definition.primaryKey) {
     parts.push("PRIMARY KEY");
   }
-  if (definition.default !== undefined) {
-    const defaultValue = formatDefaultValue(definition.default, definition.type);
-    if (defaultValue) {
-      parts.push(`DEFAULT ${defaultValue}`);
-    }
-  }
-  const definitionWithGenerated = definition;
-  if (definitionWithGenerated.generated) {
-    parts.push(`GENERATED ALWAYS AS (${definitionWithGenerated.generated}) STORED`);
-  }
-  if (definition.notNull) {
-    parts.push("NOT NULL");
-  }
-  return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN ${parts.join(" ")};`;
-}
-function generateDropColumnSQL(table, column) {
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const tableNameWithSchema = `"${schema}"."${tableName}"`;
-  return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${column}" CASCADE;`;
-}
-function generateAlterColumnSQL(table, column, changes) {
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const tableNameWithSchema = `"${schema}"."${tableName}"`;
-  const statements = [];
-  const changesTo = changes.to;
-  const changesFrom = changes.from;
-  const changesToType = changesTo?.type;
-  const changesFromType = changesFrom?.type;
-  if (changesToType !== changesFromType) {
-    const newType = changesToType || "TEXT";
-    const needsUsing = checkIfNeedsUsingClause(changesFromType || "", newType);
-    if (needsUsing) {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" TYPE ${newType} USING "${column}"::text::${newType};`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DATA TYPE ${newType};`);
-    }
-  }
-  const changesToNotNull = changesTo?.notNull;
-  const changesFromNotNull = changesFrom?.notNull;
-  if (changesToNotNull !== changesFromNotNull) {
-    if (changesToNotNull) {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET NOT NULL;`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP NOT NULL;`);
-    }
-  }
-  const changesToDefault = changesTo?.default;
-  const changesFromDefault = changesFrom?.default;
-  if (changesToDefault !== changesFromDefault) {
-    if (changesToDefault !== undefined) {
-      const defaultValue = formatDefaultValue(changesToDefault, changesToType || "");
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DEFAULT ${defaultValue};`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP DEFAULT;`);
-    }
-  }
-  return statements;
-}
-function checkIfNeedsUsingClause(fromType, toType) {
-  if (!fromType || !toType)
-    return false;
-  if (fromType.includes("enum") || toType.includes("enum")) {
-    return true;
-  }
-  const fromBase = fromType.split("(")[0].toLowerCase();
-  const toBase = toType.split("(")[0].toLowerCase();
-  if ((fromBase === "text" || fromBase === "varchar" || fromBase === "character varying") && (toBase === "jsonb" || toBase === "json")) {
-    return true;
-  }
-  const needsUsingPairs = [
-    ["integer", "boolean"],
-    ["boolean", "integer"],
-    ["text", "integer"],
-    ["text", "numeric"],
-    ["text", "boolean"],
-    ["text", "uuid"],
-    ["text", "jsonb"],
-    ["text", "json"],
-    ["varchar", "integer"],
-    ["varchar", "numeric"],
-    ["varchar", "boolean"],
-    ["varchar", "uuid"],
-    ["varchar", "jsonb"],
-    ["varchar", "json"],
-    ["character varying", "jsonb"],
-    ["character varying", "json"]
-  ];
-  for (const [from, to] of needsUsingPairs) {
-    if (fromBase === from && toBase === to || fromBase === to && toBase === from) {
-      return true;
-    }
-  }
-  return false;
-}
-function formatDefaultValue(value, type) {
-  if (value === null || value === "NULL") {
-    return "NULL";
-  }
-  if (type && (type.toLowerCase().includes("boolean") || type.toLowerCase() === "bool")) {
-    if (value === true || value === "true" || value === "t" || value === 1) {
-      return "true";
-    }
-    if (value === false || value === "false" || value === "f" || value === 0) {
-      return "false";
-    }
-  }
-  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (value.includes("::")) {
-      return value;
-    }
-    if (value.startsWith("'") && value.endsWith("'")) {
-      return value;
-    }
-    if (value.match(/^\w+\(\)/i) || value.includes("(") && value.includes(")")) {
-      return value;
-    }
-    if (value.toUpperCase().startsWith("CURRENT_")) {
-      return value;
-    }
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  return String(value);
-}
-function generateCreateIndexSQL(index7) {
-  const unique3 = index7.isUnique ? "UNIQUE " : "";
-  const method = index7.method || "btree";
-  const columns = index7.columns.map((c) => {
-    if (c.isExpression) {
-      return c.expression;
-    }
-    return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
-  }).join(", ");
-  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
-  let tableRef;
-  const indexTable = index7.table;
-  if (indexTable?.includes(".")) {
-    const [schema, table] = indexTable.split(".");
-    tableRef = `"${schema}"."${table}"`;
-  } else {
-    tableRef = `"${indexTable || ""}"`;
-  }
-  return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
-}
-function generateDropIndexSQL(index7) {
-  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
-  const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
-  return `DROP INDEX IF EXISTS "${indexName}";`;
-}
-function generateCreateForeignKeySQL(fk) {
-  const schemaFrom = fk.schemaFrom || "public";
-  const schemaTo = fk.schemaTo || "public";
-  const tableFrom = fk.tableFrom;
-  const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
-  const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
-  let sql21 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
-  if (fk.onDelete) {
-    sql21 += ` ON DELETE ${fk.onDelete}`;
-  }
-  if (fk.onUpdate) {
-    sql21 += ` ON UPDATE ${fk.onUpdate}`;
-  }
-  return `${sql21};`;
-}
-function generateDropForeignKeySQL(fk) {
-  const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${fk.name}";`;
-}
-function generateCreateUniqueConstraintSQL(constraint) {
-  const table = constraint.table || "";
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const name = constraint.name;
-  const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
-  let sql21 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
-  if (constraint.nullsNotDistinct) {
-    sql21 += ` NULLS NOT DISTINCT`;
+  if (definition.default !== undefined) {
+    const defaultValue = formatDefaultValue(definition.default, definition.type);
+    if (defaultValue) {
+      parts.push(`DEFAULT ${defaultValue}`);
+    }
   }
-  sql21 += ` (${columns});`;
-  return sql21;
-}
-function generateDropUniqueConstraintSQL(constraint) {
-  const table = constraint.table || "";
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+  const definitionWithGenerated = definition;
+  if (definitionWithGenerated.generated) {
+    parts.push(`GENERATED ALWAYS AS (${definitionWithGenerated.generated}) STORED`);
+  }
+  if (definition.notNull) {
+    parts.push("NOT NULL");
+  }
+  return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN ${parts.join(" ")};`;
 }
-function generateCreateCheckConstraintSQL(constraint) {
-  const table = constraint.table || "";
+function generateDropColumnSQL(table, column) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const name = constraint.name;
-  const value = constraint.value;
-  return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" CHECK (${value});`;
+  const tableNameWithSchema = `"${schema}"."${tableName}"`;
+  return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${column}" CASCADE;`;
 }
-function generateDropCheckConstraintSQL(constraint) {
-  const table = constraint.table || "";
+function generateAlterColumnSQL(table, column, changes) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
-}
-var init_sql_generator = () => {};
-
-// runtime-migrator/drizzle-adapters/database-introspector.ts
-import { logger as logger4 } from "@elizaos/core";
-import { sql as sql21 } from "drizzle-orm";
-function getRows2(result) {
-  return result.rows;
-}
-
-class DatabaseIntrospector {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async introspectSchema(schemaName = "public") {
-    logger4.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
-    const tables = {};
-    const schemas = {};
-    const enums = {};
-    const allTables = await this.getTables(schemaName);
-    for (const tableInfo of allTables) {
-      const tableName = tableInfo.table_name;
-      const tableSchema = tableInfo.table_schema || "public";
-      logger4.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
-      const columns = await this.getColumns(tableSchema, tableName);
-      const columnsObject = {};
-      const uniqueConstraintObject = {};
-      for (const col of columns) {
-        columnsObject[col.column_name] = {
-          name: col.column_name,
-          type: col.data_type,
-          primaryKey: col.is_primary || false,
-          notNull: col.is_nullable === "NO",
-          default: col.column_default ? this.parseDefault(col.column_default, col.data_type) : undefined
-        };
-      }
-      const indexes = await this.getIndexes(tableSchema, tableName);
-      const indexesObject = {};
-      for (const idx of indexes) {
-        if (!idx.is_primary && !idx.is_unique_constraint) {
-          if (idx.columns && Array.isArray(idx.columns) && idx.columns.length > 0) {
-            indexesObject[idx.name] = {
-              name: idx.name,
-              columns: idx.columns.map((col) => ({
-                expression: col,
-                isExpression: false
-              })),
-              isUnique: idx.is_unique,
-              method: idx.method || "btree"
-            };
-          }
-        }
-      }
-      const foreignKeys = await this.getForeignKeys(tableSchema, tableName);
-      const foreignKeysObject = {};
-      for (const fk of foreignKeys) {
-        foreignKeysObject[fk.name] = {
-          name: fk.name,
-          tableFrom: tableName,
-          schemaFrom: tableSchema,
-          tableTo: fk.foreign_table_name,
-          schemaTo: fk.foreign_table_schema || "public",
-          columnsFrom: [fk.column_name],
-          columnsTo: [fk.foreign_column_name],
-          onDelete: fk.delete_rule?.toLowerCase() || "no action",
-          onUpdate: fk.update_rule?.toLowerCase() || "no action"
-        };
-      }
-      const primaryKeys = await this.getPrimaryKeys(tableSchema, tableName);
-      const primaryKeysObject = {};
-      for (const pk of primaryKeys) {
-        primaryKeysObject[pk.name] = {
-          name: pk.name,
-          columns: pk.columns
-        };
-      }
-      const uniqueConstraints = await this.getUniqueConstraints(tableSchema, tableName);
-      for (const unq of uniqueConstraints) {
-        uniqueConstraintObject[unq.name] = {
-          name: unq.name,
-          columns: unq.columns,
-          nullsNotDistinct: false
-        };
-      }
-      const checkConstraints = await this.getCheckConstraints(tableSchema, tableName);
-      const checksObject = {};
-      for (const check3 of checkConstraints) {
-        checksObject[check3.name] = {
-          name: check3.name,
-          value: check3.definition
-        };
-      }
-      tables[`${tableSchema}.${tableName}`] = {
-        name: tableName,
-        schema: tableSchema,
-        columns: columnsObject,
-        indexes: indexesObject,
-        foreignKeys: foreignKeysObject,
-        compositePrimaryKeys: primaryKeysObject,
-        uniqueConstraints: uniqueConstraintObject,
-        checkConstraints: checksObject
-      };
-      if (tableSchema && tableSchema !== "public") {
-        schemas[tableSchema] = tableSchema;
-      }
-    }
-    const enumsResult = await this.getEnums(schemaName);
-    for (const enumInfo of enumsResult) {
-      const key = `${enumInfo.schema}.${enumInfo.name}`;
-      if (!enums[key]) {
-        enums[key] = {
-          name: enumInfo.name,
-          schema: enumInfo.schema,
-          values: []
-        };
-      }
-      enums[key].values.push(enumInfo.value);
+  const tableNameWithSchema = `"${schema}"."${tableName}"`;
+  const statements = [];
+  const changesTo = changes.to;
+  const changesFrom = changes.from;
+  const changesToType = changesTo?.type;
+  const changesFromType = changesFrom?.type;
+  if (changesToType !== changesFromType) {
+    const newType = changesToType || "TEXT";
+    const needsUsing = checkIfNeedsUsingClause(changesFromType || "", newType);
+    if (needsUsing) {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" TYPE ${newType} USING "${column}"::text::${newType};`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DATA TYPE ${newType};`);
     }
-    logger4.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
-    return {
-      version: "7",
-      dialect: "postgresql",
-      tables,
-      schemas,
-      enums,
-      _meta: {
-        schemas: {},
-        tables: {},
-        columns: {}
-      }
-    };
-  }
-  async getTables(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
-            table_schema,
-            table_name
-          FROM information_schema.tables
-          WHERE table_schema = ${schemaName}
-            AND table_type = 'BASE TABLE'
-          ORDER BY table_name`);
-    return getRows2(result);
   }
-  async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            a.attname AS column_name,
-            CASE 
-              WHEN a.attnotnull THEN 'NO'
-              ELSE 'YES'
-            END AS is_nullable,
-            CASE 
-              WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
-              AND EXISTS (
-                SELECT FROM pg_attrdef ad
-                WHERE ad.adrelid = a.attrelid 
-                AND ad.adnum = a.attnum 
-                AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
-                    || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
-              )
-              THEN CASE a.atttypid
-                WHEN 'int'::regtype THEN 'serial'
-                WHEN 'int8'::regtype THEN 'bigserial'
-                WHEN 'int2'::regtype THEN 'smallserial'
-              END
-              ELSE format_type(a.atttypid, a.atttypmod)
-            END AS data_type,
-            pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-            CASE 
-              WHEN con.contype = 'p' THEN true
-              ELSE false
-            END AS is_primary
-          FROM pg_attribute a
-          JOIN pg_class cls ON cls.oid = a.attrelid
-          JOIN pg_namespace ns ON ns.oid = cls.relnamespace
-          LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
-          LEFT JOIN pg_constraint con ON con.conrelid = a.attrelid 
-            AND a.attnum = ANY(con.conkey) 
-            AND con.contype = 'p'
-          WHERE 
-            a.attnum > 0
-            AND NOT a.attisdropped
-            AND ns.nspname = ${schemaName}
-            AND cls.relname = ${tableName}
-          ORDER BY a.attnum`);
-    return getRows2(result);
+  const changesToNotNull = changesTo?.notNull;
+  const changesFromNotNull = changesFrom?.notNull;
+  if (changesToNotNull !== changesFromNotNull) {
+    if (changesToNotNull) {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET NOT NULL;`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP NOT NULL;`);
+    }
   }
-  async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            i.relname AS name,
-            idx.indisunique AS is_unique,
-            idx.indisprimary AS is_primary,
-            con.contype = 'u' AS is_unique_constraint,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = idx.indrelid
-                AND a.attnum = ANY(idx.indkey::int[])
-              ORDER BY a.attnum
-            ) AS columns,
-            am.amname AS method
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class c ON c.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          JOIN pg_am am ON am.oid = i.relam
-          LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
-          WHERE n.nspname = ${schemaName}
-            AND c.relname = ${tableName}`);
-    return getRows2(result);
+  const changesToDefault = changesTo?.default;
+  const changesFromDefault = changesFrom?.default;
+  if (changesToDefault !== changesFromDefault) {
+    if (changesToDefault !== undefined) {
+      const defaultValue = formatDefaultValue(changesToDefault, changesToType || "");
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DEFAULT ${defaultValue};`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP DEFAULT;`);
+    }
   }
-  async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT
-            con.conname AS name,
-            att.attname AS column_name,
-            fnsp.nspname AS foreign_table_schema,
-            frel.relname AS foreign_table_name,
-            fatt.attname AS foreign_column_name,
-            CASE con.confupdtype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS update_rule,
-            CASE con.confdeltype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS delete_rule
-          FROM pg_catalog.pg_constraint con
-          JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
-          LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
-            AND att.attrelid = con.conrelid
-          LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
-          LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
-          LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
-            AND fatt.attrelid = con.confrelid
-          WHERE con.contype = 'f'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  return statements;
+}
+function checkIfNeedsUsingClause(fromType, toType) {
+  if (!fromType || !toType)
+    return false;
+  if (fromType.includes("enum") || toType.includes("enum")) {
+    return true;
   }
-  async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = con.conrelid
-                AND a.attnum = ANY(con.conkey)
-              ORDER BY a.attnum
-            ) AS columns
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'p'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  const fromBase = fromType.split("(")[0].toLowerCase();
+  const toBase = toType.split("(")[0].toLowerCase();
+  if ((fromBase === "text" || fromBase === "varchar" || fromBase === "character varying") && (toBase === "jsonb" || toBase === "json")) {
+    return true;
   }
-  async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = con.conrelid
-                AND a.attnum = ANY(con.conkey)
-              ORDER BY a.attnum
-            ) AS columns
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'u'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  const needsUsingPairs = [
+    ["integer", "boolean"],
+    ["boolean", "integer"],
+    ["text", "integer"],
+    ["text", "numeric"],
+    ["text", "boolean"],
+    ["text", "uuid"],
+    ["text", "jsonb"],
+    ["text", "json"],
+    ["varchar", "integer"],
+    ["varchar", "numeric"],
+    ["varchar", "boolean"],
+    ["varchar", "uuid"],
+    ["varchar", "jsonb"],
+    ["varchar", "json"],
+    ["character varying", "jsonb"],
+    ["character varying", "json"]
+  ];
+  for (const [from, to] of needsUsingPairs) {
+    if (fromBase === from && toBase === to || fromBase === to && toBase === from) {
+      return true;
+    }
   }
-  async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            pg_get_constraintdef(con.oid) AS definition
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'c'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  return false;
+}
+function formatDefaultValue(value, type) {
+  if (value === null || value === "NULL") {
+    return "NULL";
   }
-  async getEnums(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
-            n.nspname AS schema,
-            t.typname AS name,
-            e.enumlabel AS value,
-            e.enumsortorder AS sort_order
-          FROM pg_type t
-          JOIN pg_enum e ON t.oid = e.enumtypid
-          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-          WHERE n.nspname = ${schemaName}
-          ORDER BY schema, name, sort_order`);
-    return getRows2(result);
+  if (type && (type.toLowerCase().includes("boolean") || type.toLowerCase() === "bool")) {
+    if (value === true || value === "true" || value === "t" || value === 1) {
+      return "true";
+    }
+    if (value === false || value === "false" || value === "f" || value === 0) {
+      return "false";
+    }
   }
-  parseDefault(defaultValue, dataType) {
-    if (!defaultValue)
-      return;
-    const match = defaultValue.match(/^'(.*)'::/);
-    if (match) {
-      return `'${match[1]}'`;
+  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (value.includes("::")) {
+      return value;
     }
-    if (defaultValue.includes("nextval(")) {
-      return;
+    if (value.startsWith("'") && value.endsWith("'")) {
+      return value;
     }
-    if (dataType === "boolean") {
-      if (defaultValue === "true")
-        return "true";
-      if (defaultValue === "false")
-        return "false";
+    if (value.match(/^\w+\(\)/i) || value.includes("(") && value.includes(")")) {
+      return value;
     }
-    return defaultValue;
+    if (value.toUpperCase().startsWith("CURRENT_")) {
+      return value;
+    }
+    return `'${value.replace(/'/g, "''")}'`;
   }
-  async hasExistingTables(pluginName) {
-    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
-          FROM information_schema.tables
-          WHERE table_schema = ${schemaName}
-            AND table_type = 'BASE TABLE'`);
-    const firstRow = result.rows?.[0];
-    const count = parseInt(firstRow && firstRow.count || "0", 10);
-    return count > 0;
+  return String(value);
+}
+function generateCreateIndexSQL(index7) {
+  const unique3 = index7.isUnique ? "UNIQUE " : "";
+  const method = index7.method || "btree";
+  const columns = index7.columns.map((c) => {
+    if (c.isExpression) {
+      return c.expression;
+    }
+    return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
+  }).join(", ");
+  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
+  let tableRef;
+  const indexTable = index7.table;
+  if (indexTable?.includes(".")) {
+    const [schema, table] = indexTable.split(".");
+    tableRef = `"${schema}"."${table}"`;
+  } else {
+    tableRef = `"${indexTable || ""}"`;
   }
-  deriveSchemaName(pluginName) {
-    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
+  return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
+}
+function generateDropIndexSQL(index7) {
+  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
+  const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
+  return `DROP INDEX IF EXISTS "${indexName}";`;
+}
+function generateCreateForeignKeySQL(fk) {
+  return wrapConstraintCreationGuard(fk.name, buildCreateForeignKeyBodySQL(fk));
+}
+function generateDropForeignKeySQL(fk) {
+  const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${fk.name}";`;
+}
+function generateCreateUniqueConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  const name = constraint.name;
+  const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
+  let sql22 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  if (constraint.nullsNotDistinct) {
+    sql22 += ` NULLS NOT DISTINCT`;
   }
+  sql22 += ` (${columns});`;
+  return sql22;
 }
-var init_database_introspector = () => {};
+function generateDropUniqueConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+}
+function generateCreateCheckConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  const name = constraint.name;
+  const value = constraint.value;
+  return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" CHECK (${value});`;
+}
+function generateDropCheckConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+}
+function buildCreateForeignKeyBodySQL(fk) {
+  const schemaFrom = fk.schemaFrom || "public";
+  const schemaTo = fk.schemaTo || "public";
+  const tableFrom = fk.tableFrom;
+  const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
+  const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
+  let sql22 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  if (fk.onDelete) {
+    sql22 += ` ON DELETE ${fk.onDelete}`;
+  }
+  if (fk.onUpdate) {
+    sql22 += ` ON UPDATE ${fk.onUpdate}`;
+  }
+  return sql22;
+}
+function wrapConstraintCreationGuard(constraintName, statement) {
+  const escapedConstraintName = constraintName.replace(/'/g, "''");
+  return `DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = '${escapedConstraintName}') THEN ${statement}; END IF; END $$;`;
+}
+var init_sql_generator = () => {};
 
 // runtime-migrator/extension-manager.ts
 import { logger as logger5 } from "@elizaos/core";
@@ -3015,14 +3024,10 @@ var init_runtime_migrator = __esm(() => {
   init_migration_tracker();
   init_snapshot_storage();
 });
+
 // runtime-migrator/index.ts
 var init_runtime_migrator2 = __esm(() => {
-  init_snapshot_generator();
-  init_sql_generator();
   init_runtime_migrator();
-  init_journal_storage();
-  init_migration_tracker();
-  init_snapshot_storage();
 });
 
 // migration-service.ts
@@ -3162,11 +3167,11 @@ import {
   or,
   sql as sql27
 } from "drizzle-orm";
-// ../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/native.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native_default = { randomUUID };
 
-// ../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/rng.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/rng.js
 var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
@@ -3179,7 +3184,7 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
-// ../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/stringify.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/stringify.js
 var byteToHex = [];
 for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -3188,7 +3193,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// ../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/v4.js
+// ../../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist/v4.js
 function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
@@ -3688,7 +3693,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return [String(names)];
   }
   isValidUUID(value) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
   }
   normalizeWorldData(world) {
     const worldData = {
@@ -6715,5 +6720,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=BA2494BACAF2A1BD64756E2164756E21
+//# debugId=1C0FA995699E599E64756E2164756E21
 //# sourceMappingURL=index.browser.js.map