agrs-sequelize-sdk 1.1.56 → 1.1.58

package/models/Channel.js

@@ -1,230 +1,55 @@
 module.exports = (sequelize, DataTypes) => {
-  const RSOCFeedCampaign = sequelize.define(
-    "RSOCFeedCampaign",
+  const Channel = sequelize.define(
+    "Channel",
     {
-      AGRS_CID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-        primaryKey: true,
-      },
-      AGRSAID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        comment: "Foreign key referencing Article.AGRSAID",
-      },
-      articleName: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        comment: "Name of the associated article",
-      },
       channelId: {
         type: DataTypes.STRING,
         allowNull: false,
-        comment: "Foreign key referencing Channel.channelId",
+        // Not setting as primary key or unique since duplicates are allowed
       },
       styleId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        comment: "Style ID (stid) inherited from Channel",
-      },
-      assignee: {
         type: DataTypes.STRING,
         allowNull: false,
       },
       status: {
         type: DataTypes.STRING,
         allowNull: false,
-        defaultValue: "active",
+        defaultValue: "free",
         validate: {
-          isIn: [["active", "inactive", "archived"]],
+          isIn: [["free", "used", "archived"]],
         },
       },
-      country: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      vertical: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        comment: "Maps to Article.category for dynamic selection",
-      },
-      freeText: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-      },
-      campaignName: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      campaignId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      keywords: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      link: {
-        type: DataTypes.STRING(1024),
-        allowNull: true,
-        comment: "Campaign-specific URL based on article URL with parameters",
-      },
-      redirectLink: {
-        type: DataTypes.STRING(1024),
-        allowNull: true,
-      },
-      pixelId: {
-        type: DataTypes.STRING(1024),
-        allowNull: true,
-      },
-      token: {
-        type: DataTypes.STRING(1024),
-        allowNull: true,
-      },
-      accountId: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      feedName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        defaultValue: "RSOC",
-      },
-      adTitle: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      domain: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      feedProvider: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "RSOC",
-      },
-      createdCampaignAt: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        defaultValue: DataTypes.NOW,
-      },
-      draft: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: false,
-      },
-      createdAt: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-      updatedAt: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-      platform: {
-        type: DataTypes.STRING,
+      connectedCampaigns: {
+        type: DataTypes.JSONB, // Use JSONB for better querying capabilities
         allowNull: false,
-      },
-      mediaBuyer: {
-        type: DataTypes.STRING,
-        allowNull: true,
+        defaultValue: [],
       },
     },
     {
-      tableName: "rsoc_feed_campaigns",
+      tableName: "channels",
       timestamps: true,
+      indexes: [
+        // Add a composite unique index on channelId and styleId if needed
+        {
+          unique: true,
+          fields: ["channelId", "styleId"],
+          name: "unique_channel_style",
+        },
+      ],
     }
   );
 
-  RSOCFeedCampaign.associate = (models) => {
-    RSOCFeedCampaign.belongsTo(models.Article, {
-      foreignKey: "AGRSAID",
-      targetKey: "AGRSAID",
-      as: "Article",
-      constraints: false, // Disable foreign key constraint
-    });
-
-    RSOCFeedCampaign.belongsTo(models.Channel, {
-      foreignKey: "channelId",
-      targetKey: "channelId",
-      as: "Channel",
-      constraints: false, // Disable foreign key constraint
-    });
-  };
-
-  RSOCFeedCampaign.beforeCreate(async (campaign) => {
-    // Set redirectLink to null as requested
-    campaign.setDataValue("redirectLink", null);
-
-    const channel = await sequelize.models.Channel.findOne({
-      where: { channelId: campaign.channelId, styleId: campaign.styleId },
-    });
-
-    if (channel) {
-      const connectedCampaigns = channel.connectedCampaigns || [];
-      if (!connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)) {
-        connectedCampaigns.push({
-          campaignId: campaign.AGRS_CID,
-          assignedAt: new Date(),
-          releasedAt: null,
-        });
-        await channel.update({ status: "used", connectedCampaigns });
-      }
-    }
-  });
-
-  RSOCFeedCampaign.beforeUpdate(async (campaign) => {
-    // Ensure redirectLink remains null
-    campaign.setDataValue("redirectLink", null);
-
-    if (campaign.changed("channelId") || campaign.changed("styleId")) {
-      const oldChannelId = campaign.previous("channelId");
-      const oldStyleId = campaign.previous("styleId");
-      const newChannelId = campaign.channelId;
-      const newStyleId = campaign.styleId;
-
-      if (oldChannelId) {
-        const oldChannel = await sequelize.models.Channel.findOne({
-          where: { channelId: oldChannelId, styleId: oldStyleId },
-        });
-
-        if (oldChannel) {
-          const connectedCampaigns = oldChannel.connectedCampaigns || [];
-          const updatedCampaigns = connectedCampaigns
-            .map((c) =>
-              c.campaignId === campaign.AGRS_CID
-                ? { ...c, releasedAt: new Date() }
-                : c
-            )
-            .filter((c) => c.releasedAt === null);
-
-          await oldChannel.update({
-            connectedCampaigns: updatedCampaigns,
-            status: updatedCampaigns.length > 0 ? "used" : "free",
-          });
-        }
-      }
-
-      const newChannel = await sequelize.models.Channel.findOne({
-        where: { channelId: newChannelId, styleId: newStyleId },
+  // Define associations without enforcing constraints
+  Channel.associate = (models) => {
+    if (models.RSOCFeedCampaign) {
+      Channel.hasMany(models.RSOCFeedCampaign, {
+        foreignKey: "channelId",
+        sourceKey: "channelId",
+        as: "RSOCFeedCampaigns",
+        constraints: false, // Disable FK constraint
       });
-
-      if (newChannel) {
-        const connectedCampaigns = newChannel.connectedCampaigns || [];
-        if (
-          !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
-        ) {
-          connectedCampaigns.push({
-            campaignId: campaign.AGRS_CID,
-            assignedAt: new Date(),
-            releasedAt: null,
-          });
-          await newChannel.update({ status: "used", connectedCampaigns });
-        }
-      }
     }
-  });
+  };
 
-  return RSOCFeedCampaign;
+  return Channel;
 };

package/models/RSOCFeedCampaign.js

@@ -116,10 +116,12 @@ module.exports = (sequelize, DataTypes) => {
       },
       createdAt: {
         type: DataTypes.DATE,
+        allowNull: false,
         defaultValue: DataTypes.NOW,
       },
       updatedAt: {
         type: DataTypes.DATE,
+        allowNull: false,
         defaultValue: DataTypes.NOW,
       },
       platform: {
@@ -134,158 +136,156 @@ module.exports = (sequelize, DataTypes) => {
     {
       tableName: "rsoc_feed_campaigns",
       timestamps: true,
-      // Entirely disable automatic foreign key creation
-      references: false,
     }
   );
 
-  // Override the standard associate method to use non-constraint associations
-  RSOCFeedCampaign.associate = function (models) {
-    // Define associations without foreign key constraints
-    const queryOptions = { constraints: false };
-
-    // Associate with Article model
+  // Define associations without enforcing foreign key constraints
+  RSOCFeedCampaign.associate = (models) => {
     if (models.Article) {
       RSOCFeedCampaign.belongsTo(models.Article, {
         foreignKey: "AGRSAID",
         targetKey: "AGRSAID",
         as: "Article",
-        ...queryOptions,
+        constraints: false,
       });
     }
 
-    // Associate with Channel model
     if (models.Channel) {
       RSOCFeedCampaign.belongsTo(models.Channel, {
         foreignKey: "channelId",
         targetKey: "channelId",
         as: "Channel",
-        ...queryOptions,
+        constraints: false,
       });
     }
   };
 
+  // BeforeCreate hook: Update Channel status and connectedCampaigns
   RSOCFeedCampaign.beforeCreate(async (campaign, options) => {
-    // Set redirectLink to null as requested
     campaign.setDataValue("redirectLink", null);
 
-    // Only update the channel if not in the middle of a sync operation
-    if (!options.silent) {
-      try {
-        const channel = await sequelize.models.Channel.findOne({
-          where: {
-            channelId: campaign.channelId,
-            styleId: campaign.styleId,
-          },
-        });
+    // Skip channel update if in a silent operation (e.g., during sync)
+    if (options.silent) return;
+
+    try {
+      const channel = await sequelize.models.Channel.findOne({
+        where: {
+          channelId: campaign.channelId,
+          styleId: campaign.styleId || null,
+        },
+      });
 
-        if (channel) {
-          const connectedCampaigns = channel.connectedCampaigns || [];
-          if (
-            !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
-          ) {
-            connectedCampaigns.push({
-              campaignId: campaign.AGRS_CID,
-              assignedAt: new Date(),
-              releasedAt: null,
-            });
-            await channel.update(
-              {
-                status: "used",
-                connectedCampaigns,
-              },
-              { silent: true }
-            );
-          }
+      if (channel) {
+        const connectedCampaigns = channel.connectedCampaigns || [];
+        if (
+          !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
+        ) {
+          connectedCampaigns.push({
+            campaignId: campaign.AGRS_CID,
+            assignedAt: new Date(),
+            releasedAt: null,
+          });
+          await channel.update(
+            {
+              status: "used",
+              connectedCampaigns,
+            },
+            { silent: true }
+          );
         }
-      } catch (error) {
-        console.error(
-          "Error updating channel in beforeCreate hook:",
-          error.message
+      } else {
+        console.warn(
+          `Channel not found for channelId: ${campaign.channelId}, styleId: ${campaign.styleId}`
         );
-        // Continue with campaign creation even if channel update fails
       }
+    } catch (error) {
+      console.error("Error in beforeCreate hook:", error.message);
     }
   });
 
+  // BeforeUpdate hook: Handle channel reassignment
   RSOCFeedCampaign.beforeUpdate(async (campaign, options) => {
-    // Ensure redirectLink remains null
     campaign.setDataValue("redirectLink", null);
 
-    // Only update the channels if not in the middle of a sync operation
+    // Skip channel update if in a silent operation or no relevant changes
     if (
-      !options.silent &&
-      (campaign.changed("channelId") || campaign.changed("styleId"))
+      options.silent ||
+      (!campaign.changed("channelId") && !campaign.changed("styleId"))
     ) {
-      try {
-        const oldChannelId = campaign.previous("channelId");
-        const oldStyleId = campaign.previous("styleId");
-        const newChannelId = campaign.channelId;
-        const newStyleId = campaign.styleId;
-
-        // Update old channel if exists
-        if (oldChannelId) {
-          const oldChannel = await sequelize.models.Channel.findOne({
-            where: {
-              channelId: oldChannelId,
-              styleId: oldStyleId,
-            },
-          });
-
-          if (oldChannel) {
-            const connectedCampaigns = oldChannel.connectedCampaigns || [];
-            const updatedCampaigns = connectedCampaigns
-              .map((c) =>
-                c.campaignId === campaign.AGRS_CID
-                  ? { ...c, releasedAt: new Date() }
-                  : c
-              )
-              .filter((c) => c.releasedAt === null);
+      return;
+    }
 
-            await oldChannel.update(
-              {
-                connectedCampaigns: updatedCampaigns,
-                status: updatedCampaigns.length > 0 ? "used" : "free",
-              },
-              { silent: true }
-            );
-          }
-        }
+    try {
+      const oldChannelId = campaign.previous("channelId");
+      const oldStyleId = campaign.previous("styleId") || null;
+      const newChannelId = campaign.channelId;
+      const newStyleId = campaign.styleId || null;
 
-        // Update new channel if exists
-        const newChannel = await sequelize.models.Channel.findOne({
+      // Release old channel
+      if (
+        oldChannelId &&
+        (oldChannelId !== newChannelId || oldStyleId !== newStyleId)
+      ) {
+        const oldChannel = await sequelize.models.Channel.findOne({
           where: {
-            channelId: newChannelId,
-            styleId: newStyleId,
+            channelId: oldChannelId,
+            styleId: oldStyleId,
           },
         });
 
-        if (newChannel) {
-          const connectedCampaigns = newChannel.connectedCampaigns || [];
-          if (
-            !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
-          ) {
-            connectedCampaigns.push({
-              campaignId: campaign.AGRS_CID,
-              assignedAt: new Date(),
-              releasedAt: null,
-            });
-            await newChannel.update(
-              {
-                status: "used",
-                connectedCampaigns,
-              },
-              { silent: true }
-            );
-          }
+        if (oldChannel) {
+          const connectedCampaigns = oldChannel.connectedCampaigns || [];
+          const updatedCampaigns = connectedCampaigns
+            .map((c) =>
+              c.campaignId === campaign.AGRS_CID
+                ? { ...c, releasedAt: new Date() }
+                : c
+            )
+            .filter((c) => !c.releasedAt);
+
+          await oldChannel.update(
+            {
+              connectedCampaigns: updatedCampaigns,
+              status: updatedCampaigns.length > 0 ? "used" : "free",
+            },
+            { silent: true }
+          );
+        }
+      }
+
+      // Assign new channel
+      const newChannel = await sequelize.models.Channel.findOne({
+        where: {
+          channelId: newChannelId,
+          styleId: newStyleId,
+        },
+      });
+
+      if (newChannel) {
+        const connectedCampaigns = newChannel.connectedCampaigns || [];
+        if (
+          !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
+        ) {
+          connectedCampaigns.push({
+            campaignId: campaign.AGRS_CID,
+            assignedAt: new Date(),
+            releasedAt: null,
+          });
+          await newChannel.update(
+            {
+              status: "used",
+              connectedCampaigns,
+            },
+            { silent: true }
+          );
         }
-      } catch (error) {
-        console.error(
-          "Error updating channels in beforeUpdate hook:",
-          error.message
+      } else {
+        console.warn(
+          `New channel not found for channelId: ${newChannelId}, styleId: ${newStyleId}`
         );
-        // Continue with campaign update even if channel updates fail
       }
+    } catch (error) {
+      console.error("Error in beforeUpdate hook:", error.message);
     }
   });
 

package/package.json

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