agrs-sequelize-sdk 1.4.45 → 1.4.46

package/.worktrees/tt-snp-campaign-tables/run.sh

@@ -0,0 +1,214 @@
+# #!/bin/bash
+
+# # Check if root is only required for jq installation
+# require_root_for_jq=0
+
+# # Check if jq is installed
+# if ! command -v jq &> /dev/null; then
+#     echo "jq not found. Installing jq..."
+#     require_root_for_jq=1
+#     if command -v apt-get &> /dev/null; then
+#         sudo apt-get update && sudo apt-get install -y jq
+#     elif command -v brew &> /dev/null; then
+#         brew install jq
+#     else
+#         echo "Please install jq manually."
+#         exit 1
+#     fi
+# fi
+
+# # Only require root if jq installation was needed
+# if [[ $require_root_for_jq -eq 1 && $EUID -ne 0 ]]; then
+#     echo "This script must be run as root for jq installation. Please use sudo."
+#     exit 1
+# fi
+
+# # Step 1: Check if logged in to NPM
+# npmUsername=$(npm whoami 2>&1)
+# if [[ $npmUsername == *"ERR"* ]]; then
+#     echo "Not logged in. Please log in to NPM."
+#     npm login
+#     if [[ $? -ne 0 ]]; then
+#         echo "NPM login failed. Exiting..."
+#         exit 1
+#     fi
+# else
+#     echo "Already logged in to NPM as $npmUsername"
+# fi
+
+# # Step 2: Increment version in package.json
+# if [[ ! -f package.json ]]; then
+#     echo "package.json not found. Exiting..."
+#     exit 1
+# fi
+
+# currentVersion=$(jq -r '.version' package.json)
+
+# if [[ -z "$currentVersion" ]]; then
+#     echo "Could not find version in package.json"
+#     exit 1
+# fi
+
+# # Split version into major, minor, patch
+# IFS='.' read -r major minor patch <<< "$currentVersion"
+
+# # Increment version numbers with three-digit logic
+# if [[ $patch -eq 99 ]]; then
+#     patch=0
+#     if [[ $minor -eq 99 ]]; then
+#         minor=0
+#         ((major++))
+#     else
+#         ((minor++))
+#     fi
+# else
+#     ((patch++))
+# fi
+
+# newVersion="$major.$minor.$patch"
+
+# # Update the version in package.json while maintaining formatting
+# jq --arg version "$newVersion" '.version = $version' package.json > tmp.json && mv tmp.json package.json
+# echo "Version updated from $currentVersion to $newVersion"
+
+# # Step 3: Publish the package to NPM
+# npm publish
+# if [[ $? -ne 0 ]]; then
+#     echo "NPM publish failed. Exiting..."
+#     exit 1
+# fi
+
+# # Step 4: Commit the changes and push to GitHub
+# git add .
+# git commit -m "Bump version to $newVersion"
+# git push origin main
+
+# if [[ $? -ne 0 ]]; then
+#     echo "Failed to push changes to GitHub. Exiting..."
+#     exit 1
+# fi
+
+# echo "Version $newVersion published and changes pushed to GitHub successfully!"
+
+
+#!/bin/bash
+
+# Check if root is only required for jq installation
+require_root_for_jq=0
+
+# Check if jq is installed
+if ! command -v jq &> /dev/null; then
+    echo "jq not found. Installing jq..."
+    require_root_for_jq=1
+    if command -v apt-get &> /dev/null; then
+        sudo apt-get update && sudo apt-get install -y jq
+    elif command -v brew &> /dev/null; then
+        brew install jq
+    else
+        echo "Please install jq manually."
+        exit 1
+    fi
+fi
+
+# Only require root if jq installation was needed
+if [[ $require_root_for_jq -eq 1 && $EUID -ne 0 ]]; then
+    echo "This script must be run as root for jq installation. Please use sudo."
+    exit 1
+fi
+
+# Step 1: Check if logged in to NPM
+npmUsername=$(npm whoami 2>/dev/null)
+if [[ $? -ne 0 || -z "$npmUsername" ]]; then
+    echo "Not logged in. Please log in to NPM."
+    npm login
+    if [[ $? -ne 0 ]]; then
+        echo "NPM login failed. Exiting..."
+        exit 1
+    fi
+else
+    echo "Already logged in to NPM as $npmUsername"
+fi
+
+# Step 2: Check the latest published version from NPM
+packageName=$(jq -r '.name' package.json)
+if [[ -z "$packageName" ]]; then
+    echo "Could not find package name in package.json"
+    exit 1
+fi
+
+latestPublishedVersion=$(npm view "$packageName" version)
+if [[ $? -ne 0 ]]; then
+    echo "Failed to fetch the latest published version. Exiting..."
+    exit 1
+fi
+
+echo "Latest published version on NPM: $latestPublishedVersion"
+
+# Step 3: Increment version in package.json
+if [[ ! -f package.json ]]; then
+    echo "package.json not found. Exiting..."
+    exit 1
+fi
+
+currentVersion=$(jq -r '.version' package.json)
+
+if [[ -z "$currentVersion" ]]; then
+    echo "Could not find version in package.json"
+    exit 1
+fi
+
+# Split version into major, minor, patch
+IFS='.' read -r major minor patch <<< "$currentVersion"
+
+# Increment version numbers with three-digit logic
+if [[ $patch -eq 99 ]]; then
+    patch=0
+    if [[ $minor -eq 99 ]]; then
+        minor=0
+        ((major++))
+    else
+        ((minor++))
+    fi
+else
+    ((patch++))
+fi
+
+newVersion="$major.$minor.$patch"
+
+# Ensure the new version is greater than the latest published version
+if [[ "$(printf '%s\n' "$newVersion" "$latestPublishedVersion" | sort -V | tail -1)" != "$newVersion" ]]; then
+    echo "Error: New version ($newVersion) is not greater than the latest published version ($latestPublishedVersion)."
+    echo "Please manually update the version in package.json or adjust the script logic."
+    exit 1
+fi
+
+# Update the version in package.json while maintaining formatting
+jq --arg version "$newVersion" '.version = $version' package.json > tmp.json && mv tmp.json package.json
+echo "Version updated from $currentVersion to $newVersion"
+
+# Step 4: Publish the package to NPM
+npm publish
+if [[ $? -ne 0 ]]; then
+    echo "NPM publish failed. Exiting..."
+    exit 1
+fi
+
+# Step 5: Commit the changes and push to GitHub
+git add .
+git commit -m "Bump version to $newVersion"
+
+# Pull latest changes to ensure there are no conflicts
+git pull origin main --rebase
+if [[ $? -ne 0 ]]; then
+    echo "Git pull failed. Please resolve conflicts manually. Exiting..."
+    exit 1
+fi
+
+# Push changes to remote
+git push origin main
+if [[ $? -ne 0 ]]; then
+    echo "Failed to push changes to GitHub. Exiting..."
+    exit 1
+fi
+
+echo "Version $newVersion published and changes pushed to GitHub successfully!"

package/.worktrees/tt-snp-campaign-tables/services/sequelizeService.js

@@ -0,0 +1,110 @@
+// services/sequelizeService.js
+const DBModels = require("../index");
+const { env } = require("../../agrs-dashboard/env");
+
+async function syncDatabase() {
+  console.log("Starting database synchronization...");
+
+  try {
+    // Load environment variables
+    await require("../../agrs-dashboard/env").loadSecrets();
+
+    // Configuration
+    const config = {
+      username: env.DB_USERNAME,
+      password: env.DB_PASSWORD,
+      database: env.DB_NAME,
+      host: env.DB_HOST,
+      port: env.DB_PORT,
+      dialect: "postgres",
+    };
+
+    // Initialize DB
+    const dbModelInstance = new DBModels(config);
+    const db = dbModelInstance.db;
+
+    // Test connection
+    await db.sequelize.authenticate();
+    console.log("Database connection established successfully.");
+
+    // List all models
+    console.log("\n=== MODELS TO BE SYNCED ===");
+    const modelNames = Object.keys(db).filter(
+      (key) =>
+        typeof db[key] === "function" &&
+        db[key].prototype &&
+        db[key].prototype.constructor.name === "Model"
+    );
+
+    modelNames.forEach((modelName) => {
+      console.log(`- ${modelName}`);
+    });
+    console.log("==============================\n");
+
+    // Sync with alter: true to update schema
+    // NOTE: This is SAFE for VARCHAR->TEXT conversions (expanding type, no data loss)
+    // Sequelize will use ALTER COLUMN TYPE which preserves all existing data
+
+    // Safety check: Count existing AdSets before sync
+    let adSetCountBefore = null;
+    try {
+      const [result] = await db.sequelize.query(
+        'SELECT COUNT(*) as count FROM "AdSet"',
+        { type: db.sequelize.QueryTypes.SELECT }
+      );
+      adSetCountBefore = result.count;
+      console.log(`📊 Current AdSet count in database: ${adSetCountBefore}`);
+    } catch (error) {
+      console.log("⚠️  Could not count AdSets (table might not exist yet)");
+    }
+
+    console.log("Syncing database schema...");
+    console.log(
+      "⚠️  Using alter: true - this will update column types to match models"
+    );
+    console.log(
+      "   Safe operations: VARCHAR->TEXT (expanding), adding columns"
+    );
+    console.log(
+      "   Unsafe operations: TEXT->VARCHAR (truncating), dropping columns"
+    );
+
+    await db.sequelize.sync({ alter: true });
+
+    // Safety check: Verify AdSet count after sync
+    if (adSetCountBefore !== null) {
+      try {
+        const [result] = await db.sequelize.query(
+          'SELECT COUNT(*) as count FROM "AdSet"',
+          { type: db.sequelize.QueryTypes.SELECT }
+        );
+        const adSetCountAfter = result.count;
+        console.log(`📊 AdSet count after sync: ${adSetCountAfter}`);
+        if (adSetCountBefore !== adSetCountAfter) {
+          console.error(
+            `❌ WARNING: AdSet count changed from ${adSetCountBefore} to ${adSetCountAfter}!`
+          );
+        } else {
+          console.log("✅ AdSet count unchanged - no data loss confirmed");
+        }
+      } catch (error) {
+        console.log("⚠️  Could not verify AdSet count after sync");
+      }
+    }
+
+    console.log("✅ Database synchronized successfully!");
+    console.log("Schema has been updated to match model definitions.");
+
+    process.exit(0);
+  } catch (error) {
+    console.error("❌ Error during database synchronization:", error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  syncDatabase();
+}
+
+module.exports = { syncDatabase };

package/models/PublicApiBatch.js

@@ -0,0 +1,155 @@
+module.exports = (sequelize, DataTypes) => {
+  // public_api_batches — the envelope for one POST /public/v1/campaigns/bulk
+  // request. One batch owns N public_api_batch_items (one per campaign). The
+  // batch id is the `batchId` returned to the client at 202 and looked up via
+  // GET /public/v1/processes/{batchId}. Reconciler rolls item terminal states
+  // up into the *_count columns and flips `status` when pending_count hits 0.
+  //
+  // Idempotency note: HTTP-level replay dedup is OWNED by PublicApiIdempotencyCache
+  // (scoped by (user_id, key), caches the 202 response). This table does NOT
+  // re-implement that — `idempotency_key` here is descriptive/correlation only,
+  // deliberately NOT unique (a global-unique key would collide across buyers).
+  const PublicApiBatch = sequelize.define(
+    "PublicApiBatch",
+    {
+      id: {
+        // UUID (not autoincrement) so the batchId is unguessable / non-enumerable
+        // across buyers and stable as an external reference.
+        type: DataTypes.UUID,
+        primaryKey: true,
+        defaultValue: DataTypes.UUIDV4,
+      },
+      user_id: {
+        // Owning buyer (a buyer = a Users row, may hold several ApiTokens).
+        // GET /processes is scoped by this, matching PublicApiIdempotencyCache's
+        // (user_id, key) grain. Nullable to leave room for a future internal /
+        // dashboard-initiated bulk with no buyer user.
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: "user_id",
+      },
+      api_token_id: {
+        // Which ApiToken issued the batch (ApiToken.id is UUID). Debug/support
+        // only — not part of scoping (a buyer rotating tokens still owns it via
+        // user_id).
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: "api_token_id",
+      },
+      idempotency_key: {
+        // Descriptive: the Idempotency-Key the buyer sent for this batch, stored
+        // for correlation/debug. NOT a dedup key here (see header note).
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        field: "idempotency_key",
+      },
+      buyer: {
+        // Buyer marker carried from the request root `buyer` key (mirrors the
+        // campaign-logs Source classification). Purely descriptive.
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        field: "buyer",
+      },
+      source: {
+        // Origin front-door. 'public_api' today; leaves room for a future
+        // dashboard-initiated bulk without another table.
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        defaultValue: "public_api",
+        field: "source",
+      },
+      status: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        defaultValue: "PENDING",
+        validate: {
+          isIn: [
+            [
+              "PENDING",
+              "PROCESSING",
+              "COMPLETED",
+              "PARTIALLY_COMPLETED",
+              "FAILED",
+            ],
+          ],
+        },
+      },
+      total_items: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "total_items",
+      },
+      pending_count: {
+        // Reconciler decrements as items reach a terminal state; batch is
+        // terminal when this hits 0.
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "pending_count",
+      },
+      processing_count: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "processing_count",
+      },
+      completed_count: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "completed_count",
+      },
+      failed_count: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "failed_count",
+      },
+      request_meta: {
+        // Optional provenance (source IP, token label, client-declared count).
+        type: DataTypes.JSONB,
+        allowNull: true,
+        field: "request_meta",
+      },
+      created_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+        field: "created_at",
+      },
+      updated_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "updated_at",
+      },
+      completed_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "completed_at",
+      },
+    },
+    {
+      tableName: "public_api_batches",
+      timestamps: false, // created_at/updated_at managed manually (matches ai_campaign_queue)
+      // Indexes are named explicitly: prod sync runs alter:false, so an index
+      // added later to this (by-then existing) table must be backfilled by a
+      // migration that targets the same name.
+      indexes: [
+        { name: "public_api_batches_user_id_idx", fields: ["user_id"] },
+        { name: "public_api_batches_status_idx", fields: ["status"] },
+        { name: "public_api_batches_created_at_idx", fields: ["created_at"] },
+      ],
+    }
+  );
+
+  PublicApiBatch.associate = (models) => {
+    PublicApiBatch.hasMany(models.PublicApiBatchItem, {
+      foreignKey: "batch_id",
+      sourceKey: "id",
+      as: "items",
+    });
+  };
+
+  return PublicApiBatch;
+};

package/models/PublicApiBatchItem.js

@@ -0,0 +1,166 @@
+module.exports = (sequelize, DataTypes) => {
+  // public_api_batch_items — one durable work row per campaign inside a bulk
+  // batch. This is the queue the bounded-concurrency poller claims from:
+  //   UPDATE public_api_batch_items
+  //      SET status='PROCESSING', lease_until = now() + interval 'N minutes'
+  //    WHERE id IN (SELECT id FROM public_api_batch_items
+  //                  WHERE status='PENDING' ORDER BY created_at
+  //                  LIMIT :n FOR UPDATE SKIP LOCKED)
+  //   RETURNING id;
+  // The claim is admission control (exactly-once START across N instances), NOT
+  // mutual exclusion across the multi-minute FB round-trip — that is what
+  // `lease_until` + the in-core 0-ad / 0-campaign rechecks guard (R1/R2).
+  const PublicApiBatchItem = sequelize.define(
+    "PublicApiBatchItem",
+    {
+      id: {
+        type: DataTypes.UUID,
+        primaryKey: true,
+        defaultValue: DataTypes.UUIDV4,
+      },
+      batch_id: {
+        // Parent public_api_batches.id (UUID). No hard DB FK constraint by
+        // design — matches the ai_campaign_queue precedent: this is a
+        // high-throughput work queue where per-row FK checks and sync-time
+        // create-ordering add cost/risk for no integrity we don't already get
+        // from the atomic batch+items TXN. Association below is for querying.
+        type: DataTypes.UUID,
+        allowNull: false,
+        field: "batch_id",
+      },
+      item_index: {
+        // Position of this campaign within the submitted batch, for ordered
+        // reporting in GET /processes/{batchId}.
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        field: "item_index",
+      },
+      status: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        defaultValue: "PENDING",
+        validate: {
+          isIn: [["PENDING", "PROCESSING", "COMPLETED", "FAILED"]],
+        },
+      },
+      payload: {
+        // The single-campaign creation payload consumed by
+        // createSingleCampaign(payload, { batchItemId }). Self-contained.
+        type: DataTypes.JSONB,
+        allowNull: false,
+      },
+      process_id: {
+        // Bridge to CampaignCreationLogV2.process_id (D5). Assigned when the
+        // core starts; GET /processes joins item -> V2 log via this.
+        type: DataTypes.UUID,
+        allowNull: true,
+        field: "process_id",
+      },
+      agrs_cid: {
+        // AGRS Campaign ID — used by LOOP1 dedup and as the reclaim idempotency
+        // anchor (R2). Indexed for the campaign-level existence recheck.
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        field: "agrs_cid",
+      },
+      idempotency_token: {
+        // Campaign-level idempotency anchor keyed by AGRS_CID + country group
+        // (R2). Lets a reclaimed re-entry prove "this campaign was already
+        // POSTed to FB" without a from-scratch re-create. Forward-compat now,
+        // populated when the S3 recheck lands.
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        field: "idempotency_token",
+      },
+      lease_until: {
+        // R1: the REAL lease. A claimed item is owned until this instant. The
+        // reclaim sweep only re-dispatches when lease_until < now() (window set
+        // STRICTLY greater than worst-case single-creation wall time, incl.
+        // 80004 backoffs). A worker that loses its lease must abort, not write.
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "lease_until",
+      },
+      heartbeat_at: {
+        // R1 (optional gate): last liveness ping from the owning worker, so a
+        // long-but-alive creation isn't reclaimed on bare wall-clock alone.
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "heartbeat_at",
+      },
+      retry_count: {
+        // D-FAILURE: capped requeue count. Poison (exceeds cap) -> terminal
+        // FAILED, never re-looped.
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        field: "retry_count",
+      },
+      error_message: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "error_message",
+      },
+      error_code: {
+        // Machine-readable terminal cause (FB subcode / PG code / classifier
+        // verdict) surfaced via GET /processes.
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        field: "error_code",
+      },
+      facebook_campaign_id: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+        field: "facebook_campaign_id",
+      },
+      claimed_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "claimed_at",
+      },
+      created_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+        field: "created_at",
+      },
+      updated_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "updated_at",
+      },
+      completed_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "completed_at",
+      },
+    },
+    {
+      tableName: "public_api_batch_items",
+      timestamps: false,
+      // Named explicitly: prod sync runs alter:false, so any index added later
+      // to this (by-then existing) table needs a migration targeting the name.
+      indexes: [
+        { name: "pabi_batch_id_idx", fields: ["batch_id"] },
+        { name: "pabi_status_idx", fields: ["status"] },
+        // Composite: the reconciler roll-up filters by (batch_id, status).
+        { name: "pabi_batch_id_status_idx", fields: ["batch_id", "status"] },
+        // The poller claim scans PENDING oldest-first: (status, created_at).
+        { name: "pabi_status_created_at_idx", fields: ["status", "created_at"] },
+        { name: "pabi_process_id_idx", fields: ["process_id"] },
+        { name: "pabi_agrs_cid_idx", fields: ["agrs_cid"] },
+        { name: "pabi_lease_until_idx", fields: ["lease_until"] },
+      ],
+    }
+  );
+
+  PublicApiBatchItem.associate = (models) => {
+    PublicApiBatchItem.belongsTo(models.PublicApiBatch, {
+      foreignKey: "batch_id",
+      targetKey: "id",
+      as: "batch",
+    });
+  };
+
+  return PublicApiBatchItem;
+};

package/package.json

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