agrs-sequelize-sdk 1.4.38 → 1.4.40

package/models/PublicApiIdempotencyCache.js

@@ -89,15 +89,33 @@ module.exports = (sequelize, DataTypes) => {
     {
       tableName: "PublicApiIdempotencyCache",
       indexes: [
-        // Primary lookup: (user_id, key). UNIQUE so INSERT ... ON CONFLICT
-        // DO NOTHING atomically claims the key for the first caller — the
-        // "9 concurrent retries" burst case where only ONE request should
-        // execute the underlying work.
-        { unique: true, fields: ["user_id", "key"] },
+        // Primary lookup: (user_id, key). UNIQUE so Postgres resolves N
+        // concurrent claims atomically — the loser hits a unique violation,
+        // Sequelize's findOrCreate catches it, re-finds the winner's row, and
+        // returns created=false. That is what makes exactly ONE of the "9
+        // concurrent retries" execute the work while the rest get 409.
+        //
+        // THIS INDEX IS THE ENTIRE FEATURE. Without it every concurrent INSERT
+        // succeeds and every retry re-runs the operation. Verified in prod on
+        // 2026-07-12: index absent -> a 9-way burst gave 5 executions; index
+        // present (local) -> exactly 1.
+        //
+        // Named explicitly so the migration that backfills it on already-created
+        // tables targets the same index. sequelize.sync() runs with alter:false
+        // in prod (server.js gates it on DB_COLUMN_TYPE_UPDATE), so it creates
+        // the table but does NOT add indexes to a table that already exists.
+        {
+          name: "PublicApiIdempotencyCache_user_id_key_uniq",
+          unique: true,
+          fields: ["user_id", "key"],
+        },
         // Sweep index — cron does `DELETE WHERE expires_at < NOW()`. Not
         // partial (would need to update after every insert); regular
         // btree is fine for the sweep pattern.
-        { fields: ["expires_at"] },
+        {
+          name: "PublicApiIdempotencyCache_expires_at_idx",
+          fields: ["expires_at"],
+        },
       ],
     }
   );

package/models/SnapchatPublicProfiles.js

@@ -18,10 +18,19 @@ module.exports = (sequelize, DataTypes) => {
         type: DataTypes.STRING(255),
         allowNull: true,
       },
-      ad_account_id: {
-        type: DataTypes.STRING(64),
+      // 2026-07-12: widened from single STRING → ARRAY(STRING). Snap allows
+      // the SAME Public Profile to be linked to MANY ad accounts (per Snap
+      // Business Center — one profile can serve multiple advertiser
+      // accounts). Storing a single ad_account_id here forced our resolver
+      // into cross-account fallback (which Snap rejects with 403 E3002).
+      // Now: each row lists every ad account this profile is authorized on.
+      ad_account_ids: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
         allowNull: false,
-        comment: "Snapchat ad_account_id this profile belongs to",
+        defaultValue: [],
+        comment:
+          "Snapchat ad_account_ids this profile can serve. Query with " +
+          "'X = ANY(ad_account_ids)'. Empty means unrestricted.",
       },
       status: {
         type: DataTypes.STRING(16),
@@ -46,7 +55,11 @@ module.exports = (sequelize, DataTypes) => {
     },
     {
       tableName: "snapchat_public_profiles",
-      indexes: [{ fields: ["ad_account_id", "status"] }],
+      // No index on ad_account_ids directly — Postgres uses GIN on arrays
+      // and Sequelize's simple `fields` index syntax doesn't emit GIN. If
+      // query performance becomes a concern, add a raw GIN index migration:
+      //   CREATE INDEX ... ON snapchat_public_profiles USING GIN (ad_account_ids);
+      indexes: [{ fields: ["status"] }],
     }
   );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agrs-sequelize-sdk",
-  "version": "1.4.38",
+  "version": "1.4.40",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",