@anuma/sdk 7.6.1 → 8.0.1

package/dist/server/index.mjs

@@ -16919,16 +16919,19 @@ async function updateMessageEmbeddingOp(ctx, uniqueId, vector, embeddingModel) {
   } catch {
     return null;
   }
+  const address = ctx.walletAddress;
   await ctx.database.write(async () => {
+    const key = await resolveMessageEmbeddingKey(address, message.content);
+    const storedVector = await serializeMessageEmbedding(key, vector);
     await message.update((msg) => {
-      msg._setRaw("vector", JSON.stringify(vector));
+      msg._setRaw("vector", storedVector);
       if (msg.origin === "chunks_discarded" && vector.length > 0) {
         msg._setRaw("origin", "message");
       }
       msg._setRaw("embedding_model", embeddingModel);
     });
   });
-  return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return messageToStored(message, ctx.walletAddress);
 }
 async function updateMessageChunksOp(ctx, uniqueId, chunks, embeddingModel) {
   let message;
@@ -16938,16 +16941,123 @@ async function updateMessageChunksOp(ctx, uniqueId, chunks, embeddingModel) {
     return null;
   }
   const storedChunks = chunks.map(({ text: _text, ...rest }) => rest);
+  const address = ctx.walletAddress;
   await ctx.database.write(async () => {
+    const key = await resolveMessageEmbeddingKey(address, message.content);
+    const serializedChunks = await serializeMessageEmbedding(key, storedChunks);
     await message.update((msg) => {
-      msg._setRaw("chunks", JSON.stringify(storedChunks));
+      msg._setRaw("chunks", serializedChunks);
       if (msg.origin === "chunks_discarded" && storedChunks.length > 0 && storedChunks.every((chunk) => chunk.vector.length > 0)) {
         msg._setRaw("origin", "message");
       }
       msg._setRaw("embedding_model", embeddingModel);
     });
   });
-  return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return messageToStored(message, ctx.walletAddress);
+}
+async function resolveMessageEmbeddingKey(address, content) {
+  if (!address || !isEncrypted(content)) return null;
+  const key = await getEncryptionKey(address, "v3");
+  const contentKey = content.startsWith("enc:v2:") ? await getEncryptionKey(address, "v2") : key;
+  try {
+    await decryptDataWithKey(content.slice("enc:vN:".length), contentKey);
+  } catch {
+    throw new Error("Cannot decrypt the message with the cached wallet key");
+  }
+  return key;
+}
+async function serializeMessageEmbedding(key, value) {
+  const json4 = JSON.stringify(value);
+  return key ? `enc:v3:${await encryptDataWithKey(json4, key)}` : json4;
+}
+async function decryptMessageEmbeddingFields(raw, walletAddress) {
+  const result = { ...raw };
+  for (const column of ["vector", "chunks"]) {
+    const value = raw[column];
+    if (typeof value !== "string" || !value.startsWith("enc:")) continue;
+    const decrypted = walletAddress ? await decryptField(value, walletAddress) : value;
+    result[column] = decrypted.startsWith("enc:") ? void 0 : decrypted;
+  }
+  return result;
+}
+async function sealLegacyMessageEmbeddingsOp(ctx) {
+  if (!ctx.walletAddress) return 0;
+  const candidateIds = await ctx.messagesCollection.query(
+    import_watermelondb2.Q.where("content", import_watermelondb2.Q.like("enc:%")),
+    import_watermelondb2.Q.or(
+      ...["vector", "chunks"].map(
+        (column) => import_watermelondb2.Q.and(
+          import_watermelondb2.Q.where(column, import_watermelondb2.Q.notEq(null)),
+          import_watermelondb2.Q.where(column, import_watermelondb2.Q.notEq("")),
+          import_watermelondb2.Q.where(column, import_watermelondb2.Q.notLike("enc:%"))
+        )
+      )
+    )
+  ).fetchIds();
+  let sealed = 0;
+  let undecryptable = 0;
+  for (let start = 0; start < candidateIds.length; start += 50) {
+    const pageIds = candidateIds.slice(start, start + 50);
+    await ctx.database.write(async () => {
+      const pageMessages = await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf(pageIds))).fetch();
+      for (const message of pageMessages) {
+        if (!isEncrypted(message.content)) continue;
+        const content = await decryptFieldDetailed(message.content, ctx.walletAddress);
+        if (content.status === "key_missing") {
+          throw new Error("Cannot decrypt the message with the cached wallet key");
+        }
+        if (content.status !== "ok") {
+          undecryptable++;
+          continue;
+        }
+        const plaintext = content.value;
+        const key = await resolveMessageEmbeddingKey(ctx.walletAddress, message.content);
+        const updates = {};
+        for (const column of ["vector", "chunks"]) {
+          const value = message._getRaw(column);
+          if (typeof value !== "string" || value.startsWith("enc:") || !value) continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(value);
+          } catch {
+            updates[column] = null;
+            continue;
+          }
+          if (!Array.isArray(parsed)) {
+            updates[column] = null;
+            continue;
+          }
+          if (column === "chunks") {
+            const chunks = parsed;
+            if (chunks.some(
+              (chunk) => !chunk || !Number.isInteger(chunk.startOffset) || !Number.isInteger(chunk.endOffset) || chunk.startOffset < 0 || chunk.endOffset <= chunk.startOffset || chunk.endOffset > plaintext.length
+            )) {
+              updates.chunks = null;
+              updates.vector = null;
+              updates.origin = message.origin === "tool_result" ? "tool_result" : "chunks_discarded";
+              break;
+            }
+            parsed = chunks.map(({ text: _text, ...rest }) => rest);
+          }
+          updates[column] = await serializeMessageEmbedding(key, parsed);
+        }
+        if (Object.keys(updates).length === 0) continue;
+        const updatedAt = Number(message._getRaw("updated_at"));
+        const discarded = updates.origin !== void 0;
+        await message.update((msg) => {
+          for (const [column, value] of Object.entries(updates)) msg._setRaw(column, value);
+          msg._setRaw("updated_at", discarded ? Math.max(Date.now(), updatedAt + 1) : updatedAt);
+        });
+        sealed++;
+      }
+    });
+  }
+  if (undecryptable > 0) {
+    getLogger().warn(
+      `Skipped ${undecryptable} message embeddings that the cached wallet key cannot decrypt`
+    );
+  }
+  return sealed;
 }
 var RAW_REPAIR_PAGE_SIZE = 100;
 function chunksWithoutText(raw) {
@@ -37806,6 +37916,7 @@ async function preprocessFiles(files, options = {}) {
 
 // src/server/pg-adapter.ts
 var import_stepsForMigration = __toESM(require_stepsForMigration());
+import { createHash } from "crypto";
 function makeQualify(pgSchema) {
   if (pgSchema === "public") {
     return (table) => `"${table}"`;
@@ -37821,7 +37932,7 @@ function paramList(params, values) {
 }
 var operators = {
   eq: "=",
-  notEq: "!=",
+  notEq: "is distinct from",
   gt: ">",
   gte: ">=",
   weakGt: ">",
@@ -37872,6 +37983,11 @@ function encodeWhere(params, table, associations, clause) {
       throw new Error(`Unknown clause type: ${clause.type}`);
   }
 }
+function hasSql(clauses) {
+  return clauses.some(
+    (clause) => clause.type === "sql" || "conditions" in clause && hasSql(clause.conditions)
+  );
+}
 function encodeQuery(query, qualify, countMode = false, idsOnly = false) {
   const { table, description, associations } = query;
   if (description.sql) {
@@ -37954,7 +38070,7 @@ function schemaToCreateSQL(schema, pgSchema = "public") {
       const def = ` default ${columnDefault(col)}`;
       cols.push(`"${col.name}" ${pgType}${nullable}${def}`);
       if (col.isIndexed) {
-        const indexName = pgSchema === "public" ? `"${tableName}_${col.name}"` : `"${pgSchema}_${tableName}_${col.name}"`;
+        const indexName = `"${tableName}_${col.name}"`;
         indexes.push(
           `create index if not exists ${indexName} on ${qualify(tableName)} ("${col.name}");`
         );
@@ -37981,14 +38097,73 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
     this.dbName = options.dbName;
     this.migrations = options.migrations;
     this.pool = options.pool;
-    this._pgSchema = options.pgSchema ?? "public";
+    this._pgSchema = `anuma_${createHash("sha256").update(JSON.stringify([options.pgSchema ?? "public", this.dbName])).digest("hex").slice(0, 48)}`;
     this.qualify = makeQualify(this._pgSchema);
-    this.initialized = this._initialize();
+    this.initialized = this._initialize(
+      options.pgSchema ?? "public",
+      options.migrateLegacySchema ?? false
+    );
   }
-  async _initialize() {
-    if (this._pgSchema !== "public") {
-      await this.pool.query(`create schema if not exists "${this._pgSchema}"`);
+  async _hasLegacyData(pgSchema, executor) {
+    const legacyStorage = `"${pgSchema.replace(/"/g, '""')}"."local_storage"`;
+    const { rows } = await executor.query(
+      "select to_regclass($1) as legacy, to_regclass($2) as isolated",
+      [legacyStorage, this.qualify("local_storage")]
+    );
+    if (!rows[0]?.legacy) return false;
+    if (rows[0].isolated) {
+      const { rows: version2 } = await executor.query(
+        `select "value" from ${this.qualify("local_storage")} where "key" = $1`,
+        [_PostgreSQLAdapter.SCHEMA_VERSION_KEY]
+      );
+      if (Number(version2[0]?.value) > 0) return false;
     }
+    const { rows: version } = await executor.query(
+      `select "value" from ${legacyStorage} where "key" = $1`,
+      [_PostgreSQLAdapter.SCHEMA_VERSION_KEY]
+    );
+    return Number(version[0]?.value) > 0;
+  }
+  async _upgradeLegacySchema(pgSchema, migrateLegacySchema) {
+    if (!migrateLegacySchema) {
+      if (await this._hasLegacyData(pgSchema, this.pool)) {
+        throw new Error(
+          "PostgreSQLAdapter found legacy data. Set migrateLegacySchema to true only for the database that owns all legacy records."
+        );
+      }
+      return;
+    }
+    if (!this.pool.connect) {
+      throw new Error("PostgreSQLAdapter legacy migration requires pool.connect");
+    }
+    const client2 = await this.pool.connect();
+    try {
+      await client2.query("BEGIN");
+      await client2.query("select pg_advisory_xact_lock(hashtext($1))", [
+        `PostgreSQLAdapter:${pgSchema}`
+      ]);
+      if (await this._hasLegacyData(pgSchema, client2)) {
+        await client2.query(`create schema if not exists "${this._pgSchema}"`);
+        const { rows } = await client2.query(
+          "select tablename from pg_catalog.pg_tables where schemaname = $1 and tablename = any($2::text[])",
+          [pgSchema, [...Object.keys(this.schema.tables), "local_storage"]]
+        );
+        for (const row of rows) {
+          const table = `"${pgSchema.replace(/"/g, '""')}"."${String(row.tablename).replace(/"/g, '""')}"`;
+          await client2.query(`alter table ${table} set schema "${this._pgSchema}"`);
+        }
+      }
+      await client2.query("COMMIT");
+    } catch (error) {
+      await client2.query("ROLLBACK");
+      throw error;
+    } finally {
+      client2.release();
+    }
+  }
+  async _initialize(pgSchema, migrateLegacySchema) {
+    await this._upgradeLegacySchema(pgSchema, migrateLegacySchema);
+    await this.pool.query(`create schema if not exists "${this._pgSchema}"`);
     await this.pool.query(
       `create table if not exists ${this.qualify("local_storage")} ("key" text primary key, "value" text not null);`
     );
@@ -38057,7 +38232,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
         );
         for (const col of ts.columnArray) {
           if (col.isIndexed) {
-            const indexName = this._pgSchema === "public" ? `"${ts.name}_${col.name}"` : `"${this._pgSchema}_${ts.name}_${col.name}"`;
+            const indexName = `"${ts.name}_${col.name}"`;
             await this.pool.query(
               `create index if not exists ${indexName} on ${this.qualify(ts.name)} ("${col.name}");`
             );
@@ -38075,7 +38250,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
             `alter table ${this.qualify(table)} add column if not exists "${col.name}" ${pgType}${nullable}${def};`
           );
           if (col.isIndexed) {
-            const indexName = this._pgSchema === "public" ? `"${table}_${col.name}"` : `"${this._pgSchema}_${table}_${col.name}"`;
+            const indexName = `"${table}_${col.name}"`;
             await this.pool.query(
               `create index if not exists ${indexName} on ${this.qualify(table)} ("${col.name}");`
             );
@@ -38084,26 +38259,34 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
         break;
       }
       case "sql": {
-        if (this._pgSchema !== "public" && this.pool.connect) {
-          const client2 = await this.pool.connect();
-          try {
-            await client2.query("BEGIN");
-            await client2.query(`SET LOCAL search_path TO "${this._pgSchema}", public`);
-            await client2.query(step.sql);
-            await client2.query("COMMIT");
-          } catch (err) {
-            await client2.query("ROLLBACK");
-            throw err;
-          } finally {
-            client2.release();
-          }
-        } else {
-          await this.pool.query(step.sql);
-        }
+        await this._withSchema((client2) => client2.query(step.sql));
         break;
       }
     }
   }
+  async _withSchema(run) {
+    if (!this.pool.connect) {
+      throw new Error("PostgreSQLAdapter raw SQL requires pool.connect for database isolation");
+    }
+    const client2 = await this.pool.connect();
+    try {
+      await client2.query("BEGIN");
+      await client2.query(`SET LOCAL search_path TO "${this._pgSchema}"`);
+      const result = await run(client2);
+      await client2.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client2.query("ROLLBACK");
+      throw err;
+    } finally {
+      client2.release();
+    }
+  }
+  async _query(query, countMode = false, idsOnly = false) {
+    const [sql, values] = encodeQuery(query, this.qualify, countMode, idsOnly);
+    const description = query.description;
+    return description.sql || hasSql(description.where) ? this._withSchema((client2) => client2.query(sql, values)) : this.pool.query(sql, values);
+  }
   async _resetAndRecreate(targetVersion) {
     for (const tableName of Object.keys(this.schema.tables)) {
       await this.pool.query(`drop table if exists ${this.qualify(tableName)} cascade;`);
@@ -38147,8 +38330,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
     this._fromPromise(
       (async () => {
         await this._ready();
-        const [sql, values] = encodeQuery(query, this.qualify);
-        const { rows } = await this.pool.query(sql, values);
+        const { rows } = await this._query(query);
         return rows.map(rowToRaw);
       })(),
       callback
@@ -38158,8 +38340,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
     this._fromPromise(
       (async () => {
         await this._ready();
-        const [sql, values] = encodeQuery(query, this.qualify, false, true);
-        const { rows } = await this.pool.query(sql, values);
+        const { rows } = await this._query(query, false, true);
         return rows.map((r) => r.id);
       })(),
       callback
@@ -38170,8 +38351,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
     this._fromPromise(
       (async () => {
         await this._ready();
-        const [sql, values] = encodeQuery(query, this.qualify);
-        const { rows } = await this.pool.query(sql, values);
+        const { rows } = await this._query(query);
         return rows;
       })(),
       callback
@@ -38181,8 +38361,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
     this._fromPromise(
       (async () => {
         await this._ready();
-        const [sql, values] = encodeQuery(query, this.qualify, true);
-        const { rows } = await this.pool.query(sql, values);
+        const { rows } = await this._query(query, true);
         return Number(rows[0]?.count ?? 0);
       })(),
       callback
@@ -38306,7 +38485,7 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
       this._fromPromise(
         (async () => {
           await this._ready();
-          await this.pool.query(ops.sqlString);
+          await this._withSchema((client2) => client2.query(ops.sqlString));
         })(),
         callback
       );
@@ -38316,9 +38495,11 @@ var _PostgreSQLAdapter = class _PostgreSQLAdapter {
       this._fromPromise(
         (async () => {
           await this._ready();
-          for (const [sql, args] of ops.sqls) {
-            await this.pool.query(sql, args);
-          }
+          await this._withSchema(async (client2) => {
+            for (const [sql, args] of ops.sqls) {
+              await client2.query(sql, args);
+            }
+          });
         })(),
         callback
       );
@@ -38526,6 +38707,7 @@ export {
   decryptDataBytes,
   decryptDataBytesFromBytes,
   decryptDataWithKey,
+  decryptMessageEmbeddingFields,
   defaultServerToolsFilter,
   deleteAllVaultMemoriesForUserOp,
   deleteConversationOp,
@@ -38649,6 +38831,7 @@ export {
   sdkMigrations,
   sdkModelClasses,
   sdkSchema,
+  sealLegacyMessageEmbeddingsOp,
   searchChunksOp,
   searchMediaOp,
   searchMessagesOp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "7.6.1",
+  "version": "8.0.1",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",