@mastra/pg 1.13.0 → 1.13.3-alpha.0

package/dist/index.js

@@ -14,6 +14,7 @@ import { createRequire } from 'module';
 import { MessageList } from '@mastra/core/agent';
 import { coreFeatures } from '@mastra/core/features';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
+import { skillSnapshotFieldValuesEqual } from '@mastra/core/storage/domains/skills';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -2139,6 +2140,161 @@ var TransactionClient = class {
     return Promise.all(promises);
   }
 };
+var PinnedClientAdapter = class {
+  constructor($pool, pinnedClient) {
+    this.$pool = $pool;
+    this.pinnedClient = pinnedClient;
+  }
+  $pool;
+  pinnedClient;
+  /**
+   * Serialization tail. Domain init() methods fire via Promise.all in
+   * MastraCompositeStore.#runInit(), so without our own gate every domain's
+   * query() lands on the same PoolClient concurrently. pg@8 queues those
+   * internally and emits a deprecation warning; pg@9 will throw. Chaining
+   * each new query off the previous one's settlement (success or failure)
+   * gives us deterministic FIFO ordering at the adapter layer and removes
+   * the reliance on pg's internal queue.
+   */
+  #tail = Promise.resolve();
+  /**
+   * Run `fn` after any previously enqueued work on this pinned client has
+   * settled. Failures in earlier calls don't poison the queue — we always
+   * resume on the next caller's turn.
+   */
+  #enqueue(fn) {
+    const next = this.#tail.then(fn, fn);
+    this.#tail = next.catch(() => void 0);
+    return next;
+  }
+  connect() {
+    throw new Error(
+      "PinnedClientAdapter.connect() is not supported during PostgresStore.init(). All DDL must flow through the pinned client."
+    );
+  }
+  none(query, values) {
+    return this.#enqueue(async () => {
+      await this.pinnedClient.query(query, values);
+      return null;
+    });
+  }
+  one(query, values) {
+    return this.#enqueue(async () => {
+      const result = await this.pinnedClient.query(query, values);
+      if (result.rows.length === 0) {
+        throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+      }
+      if (result.rows.length > 1) {
+        throw new Error(`Multiple rows returned when one was expected: ${truncateQuery(query)}`);
+      }
+      return result.rows[0];
+    });
+  }
+  oneOrNone(query, values) {
+    return this.#enqueue(async () => {
+      const result = await this.pinnedClient.query(query, values);
+      if (result.rows.length === 0) {
+        return null;
+      }
+      if (result.rows.length > 1) {
+        throw new Error(`Multiple rows returned when one or none was expected: ${truncateQuery(query)}`);
+      }
+      return result.rows[0];
+    });
+  }
+  any(query, values) {
+    return this.#enqueue(async () => {
+      const result = await this.pinnedClient.query(query, values);
+      return result.rows;
+    });
+  }
+  manyOrNone(query, values) {
+    return this.any(query, values);
+  }
+  many(query, values) {
+    return this.#enqueue(async () => {
+      const result = await this.pinnedClient.query(query, values);
+      if (result.rows.length === 0) {
+        throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+      }
+      return result.rows;
+    });
+  }
+  query(query, values) {
+    return this.#enqueue(() => this.pinnedClient.query(query, values));
+  }
+  tx(callback) {
+    return this.#enqueue(async () => {
+      await this.pinnedClient.query("BEGIN");
+      try {
+        const result = await callback(new TransactionClient(this.pinnedClient));
+        await this.pinnedClient.query("COMMIT");
+        return result;
+      } catch (error) {
+        try {
+          await this.pinnedClient.query("ROLLBACK");
+        } catch (rollbackError) {
+          console.error("Transaction rollback failed:", rollbackError);
+        }
+        throw error;
+      }
+    });
+  }
+};
+var RoutingDbClient = class {
+  #base;
+  #pinned = null;
+  constructor(base) {
+    this.#base = base;
+  }
+  /** Returns the currently active client (pinned if set, otherwise base). */
+  get active() {
+    return this.#pinned ?? this.#base;
+  }
+  /**
+   * Pin a DbClient so all subsequent calls route through it until unpinned.
+   * Throws if a client is already pinned to avoid silent overrides.
+   */
+  pin(client) {
+    if (this.#pinned) {
+      throw new Error("RoutingDbClient already has a pinned client");
+    }
+    this.#pinned = client;
+  }
+  unpin() {
+    this.#pinned = null;
+  }
+  get $pool() {
+    return this.#base.$pool;
+  }
+  connect() {
+    return this.active.connect();
+  }
+  none(query, values) {
+    return this.active.none(query, values);
+  }
+  one(query, values) {
+    return this.active.one(query, values);
+  }
+  oneOrNone(query, values) {
+    return this.active.oneOrNone(query, values);
+  }
+  any(query, values) {
+    return this.active.any(query, values);
+  }
+  manyOrNone(query, values) {
+    return this.active.manyOrNone(query, values);
+  }
+  many(query, values) {
+    return this.active.many(query, values);
+  }
+  query(query, values) {
+    return this.active.query(query, values);
+  }
+  tx(callback) {
+    return this.active.tx(callback);
+  }
+};
 
 // src/storage/db/constraint-utils.ts
 var POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
@@ -17037,7 +17193,10 @@ var SkillsPG = class _SkillsPG extends SkillsStorage {
         } = latestVersion;
         const newConfig = { ...latestConfig, ...configFields };
         const changedFields = SNAPSHOT_FIELDS5.filter(
-          (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
+          (field) => field in configFields && !skillSnapshotFieldValuesEqual(
+            configFields[field],
+            latestConfig[field]
+          )
         );
         if (changedFields.length > 0) {
           versionCreated = true;
@@ -18981,6 +19140,8 @@ function exportSchemas(schemaName) {
 }
 var PostgresStore = class extends MastraCompositeStore {
   #pool;
+  // Narrowed to RoutingDbClient so init()'s pin/unpin path is type-checked.
+  // The public `db` getter still exposes it as DbClient.
   #db;
   #ownsPool;
   #poolClosed = false;
@@ -18999,7 +19160,7 @@ var PostgresStore = class extends MastraCompositeStore {
         this.#pool = this.createPool(config);
         this.#ownsPool = true;
       }
-      this.#db = new PoolAdapter(this.#pool);
+      this.#db = new RoutingDbClient(new PoolAdapter(this.#pool));
       const domainConfig = {
         client: this.#db,
         schemaName: this.schema,
@@ -19055,11 +19216,13 @@ var PostgresStore = class extends MastraCompositeStore {
     if (this.isInitialized) {
       return;
     }
+    const pinnedClient = await this.#pool.connect();
+    const pinned = new PinnedClientAdapter(this.#pool, pinnedClient);
     try {
-      this.isInitialized = true;
+      this.#db.pin(pinned);
       await super.init();
+      this.isInitialized = true;
     } catch (error) {
-      this.isInitialized = false;
       if (error instanceof MastraError) {
         throw error;
       }
@@ -19071,6 +19234,9 @@ var PostgresStore = class extends MastraCompositeStore {
         },
         error
       );
+    } finally {
+      this.#db.unpin();
+      pinnedClient.release();
     }
   }
   /**