agrs-sequelize-sdk 1.4.1 → 1.4.4

package/models/Tier2_UserAdAccounts.js

@@ -1,83 +1,83 @@
-module.exports = (sequelize, DataTypes) => {
-  const Tier2_UserAdAccounts = sequelize.define(
-    "Tier2_UserAdAccounts",
-    {
-      id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        primaryKey: true,
-      },
-      userId: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        comment: "User ID (can be internal system ID or external ID)",
-      },
-      adAccountId: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        references: {
-          model: "Tier2_AdAccounts",
-          key: "id",
-        },
-        onUpdate: "CASCADE",
-        onDelete: "CASCADE",
-      },
-      facebookAdAccountId: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        comment: "Facebook Ad Account ID (for quick reference)",
-      },
-      permissions: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: false,
-        defaultValue: ["view", "create_campaigns", "view_performance"],
-        comment:
-          "Permissions: view, create_campaigns, edit_campaigns, view_performance, manage_assets",
-      },
-      assignedAt: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        defaultValue: DataTypes.NOW,
-      },
-      assignedBy: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        comment: "User ID who assigned this ad account",
-      },
-      status: {
-        type: DataTypes.ENUM("active", "suspended", "revoked"),
-        allowNull: false,
-        defaultValue: "active",
-      },
-    },
-    {
-      tableName: "Tier2_UserAdAccounts",
-      indexes: [
-        {
-          fields: ["userId"],
-        },
-        {
-          fields: ["adAccountId"],
-        },
-        {
-          fields: ["facebookAdAccountId"],
-        },
-        {
-          unique: true,
-          fields: ["userId", "adAccountId"],
-          name: "unique_user_ad_account",
-        },
-      ],
-    }
-  );
-
-  Tier2_UserAdAccounts.associate = (models) => {
-    // Association with Tier2_AdAccounts
-    Tier2_UserAdAccounts.belongsTo(models.Tier2_AdAccounts, {
-      foreignKey: "adAccountId",
-      as: "adAccount",
-    });
-  };
-
-  return Tier2_UserAdAccounts;
-};
+module.exports = (sequelize, DataTypes) => {
+  const Tier2_UserAdAccounts = sequelize.define(
+    "Tier2_UserAdAccounts",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      userId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "User ID (can be internal system ID or external ID)",
+      },
+      adAccountId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: "Tier2_AdAccounts",
+          key: "id",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      facebookAdAccountId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Facebook Ad Account ID (for quick reference)",
+      },
+      permissions: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: ["view", "create_campaigns", "view_performance"],
+        comment:
+          "Permissions: view, create_campaigns, edit_campaigns, view_performance, manage_assets",
+      },
+      assignedAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+      },
+      assignedBy: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "User ID who assigned this ad account",
+      },
+      status: {
+        type: DataTypes.ENUM("active", "suspended", "revoked"),
+        allowNull: false,
+        defaultValue: "active",
+      },
+    },
+    {
+      tableName: "Tier2_UserAdAccounts",
+      indexes: [
+        {
+          fields: ["userId"],
+        },
+        {
+          fields: ["adAccountId"],
+        },
+        {
+          fields: ["facebookAdAccountId"],
+        },
+        {
+          unique: true,
+          fields: ["userId", "adAccountId"],
+          name: "unique_user_ad_account",
+        },
+      ],
+    }
+  );
+
+  Tier2_UserAdAccounts.associate = (models) => {
+    // Association with Tier2_AdAccounts
+    Tier2_UserAdAccounts.belongsTo(models.Tier2_AdAccounts, {
+      foreignKey: "adAccountId",
+      as: "adAccount",
+    });
+  };
+
+  return Tier2_UserAdAccounts;
+};

package/models/TokenRotationState.js

@@ -1,121 +1,121 @@
-// models/TokenRotationState.js
-module.exports = (sequelize, DataTypes) => {
-  const TokenRotationState = sequelize.define(
-    "TokenRotationState",
-    {
-      id: {
-        type: DataTypes.INTEGER,
-        primaryKey: true,
-        autoIncrement: true,
-      },
-      tokenType: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-        defaultValue: "FACEBOOK_ACCESS_TOKEN",
-        comment: "Type of token being rotated (e.g., FACEBOOK_ACCESS_TOKEN)",
-      },
-      currentIndex: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        defaultValue: 0,
-        comment: "Current index in the token rotation (0-based)",
-      },
-      totalTokens: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        defaultValue: 10,
-        comment: "Total number of tokens in rotation",
-      },
-      lastUsedAt: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        comment: "Timestamp of last token usage",
-      },
-      totalUsageCount: {
-        type: DataTypes.BIGINT,
-        allowNull: false,
-        defaultValue: 0,
-        comment: "Total number of times tokens have been used",
-      },
-      rotationStrategy: {
-        type: DataTypes.ENUM("round_robin", "least_used", "random"),
-        allowNull: false,
-        defaultValue: "round_robin",
-        comment: "Strategy for token rotation",
-      },
-      metadata: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-        comment: "Additional metadata (per-token usage stats, health, etc.)",
-      },
-    },
-    {
-      tableName: "TokenRotationState",
-      timestamps: true, // Adds createdAt and updatedAt
-      indexes: [
-        {
-          fields: ["tokenType"],
-          unique: true,
-          name: "idx_token_rotation_type",
-        },
-        {
-          fields: ["lastUsedAt"],
-          name: "idx_token_rotation_last_used",
-        },
-      ],
-    }
-  );
-
-  // Instance methods
-  TokenRotationState.prototype.incrementUsage = async function () {
-    this.totalUsageCount = (
-      BigInt(this.totalUsageCount) + BigInt(1)
-    ).toString();
-    this.lastUsedAt = new Date();
-    await this.save();
-  };
-
-  TokenRotationState.prototype.rotateToNext = async function () {
-    this.currentIndex = (this.currentIndex + 1) % this.totalTokens;
-    await this.save();
-  };
-
-  TokenRotationState.prototype.getCurrentTokenNumber = function () {
-    return this.currentIndex + 1; // Return 1-based index
-  };
-
-  // Static methods
-  TokenRotationState.getOrCreate = async function (
-    tokenType = "FACEBOOK_ACCESS_TOKEN"
-  ) {
-    const [state, created] = await this.findOrCreate({
-      where: { tokenType },
-      defaults: {
-        tokenType,
-        currentIndex: 0,
-        totalTokens: 10,
-        rotationStrategy: "round_robin",
-      },
-    });
-    return state;
-  };
-
-  TokenRotationState.getStats = async function (
-    tokenType = "FACEBOOK_ACCESS_TOKEN"
-  ) {
-    const state = await this.findOne({ where: { tokenType } });
-    if (!state) return null;
-
-    return {
-      currentTokenNumber: state.getCurrentTokenNumber(),
-      totalTokens: state.totalTokens,
-      totalUsageCount: state.totalUsageCount.toString(),
-      lastUsedAt: state.lastUsedAt,
-      rotationStrategy: state.rotationStrategy,
-      metadata: state.metadata,
-    };
-  };
-
-  return TokenRotationState;
-};
+// models/TokenRotationState.js
+module.exports = (sequelize, DataTypes) => {
+  const TokenRotationState = sequelize.define(
+    "TokenRotationState",
+    {
+      id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      tokenType: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        defaultValue: "FACEBOOK_ACCESS_TOKEN",
+        comment: "Type of token being rotated (e.g., FACEBOOK_ACCESS_TOKEN)",
+      },
+      currentIndex: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 0,
+        comment: "Current index in the token rotation (0-based)",
+      },
+      totalTokens: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 10,
+        comment: "Total number of tokens in rotation",
+      },
+      lastUsedAt: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        comment: "Timestamp of last token usage",
+      },
+      totalUsageCount: {
+        type: DataTypes.BIGINT,
+        allowNull: false,
+        defaultValue: 0,
+        comment: "Total number of times tokens have been used",
+      },
+      rotationStrategy: {
+        type: DataTypes.ENUM("round_robin", "least_used", "random"),
+        allowNull: false,
+        defaultValue: "round_robin",
+        comment: "Strategy for token rotation",
+      },
+      metadata: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+        comment: "Additional metadata (per-token usage stats, health, etc.)",
+      },
+    },
+    {
+      tableName: "TokenRotationState",
+      timestamps: true, // Adds createdAt and updatedAt
+      indexes: [
+        {
+          fields: ["tokenType"],
+          unique: true,
+          name: "idx_token_rotation_type",
+        },
+        {
+          fields: ["lastUsedAt"],
+          name: "idx_token_rotation_last_used",
+        },
+      ],
+    }
+  );
+
+  // Instance methods
+  TokenRotationState.prototype.incrementUsage = async function () {
+    this.totalUsageCount = (
+      BigInt(this.totalUsageCount) + BigInt(1)
+    ).toString();
+    this.lastUsedAt = new Date();
+    await this.save();
+  };
+
+  TokenRotationState.prototype.rotateToNext = async function () {
+    this.currentIndex = (this.currentIndex + 1) % this.totalTokens;
+    await this.save();
+  };
+
+  TokenRotationState.prototype.getCurrentTokenNumber = function () {
+    return this.currentIndex + 1; // Return 1-based index
+  };
+
+  // Static methods
+  TokenRotationState.getOrCreate = async function (
+    tokenType = "FACEBOOK_ACCESS_TOKEN"
+  ) {
+    const [state, created] = await this.findOrCreate({
+      where: { tokenType },
+      defaults: {
+        tokenType,
+        currentIndex: 0,
+        totalTokens: 10,
+        rotationStrategy: "round_robin",
+      },
+    });
+    return state;
+  };
+
+  TokenRotationState.getStats = async function (
+    tokenType = "FACEBOOK_ACCESS_TOKEN"
+  ) {
+    const state = await this.findOne({ where: { tokenType } });
+    if (!state) return null;
+
+    return {
+      currentTokenNumber: state.getCurrentTokenNumber(),
+      totalTokens: state.totalTokens,
+      totalUsageCount: state.totalUsageCount.toString(),
+      lastUsedAt: state.lastUsedAt,
+      rotationStrategy: state.rotationStrategy,
+      metadata: state.metadata,
+    };
+  };
+
+  return TokenRotationState;
+};

package/models/TonicRSOCKeywordPerformance.js

@@ -1,123 +1,123 @@
-module.exports = (sequelize, DataTypes) => {
-    const TonicRSOCKeywordPerformance = sequelize.define(
-      "TonicRSOCKeywordPerformance",
-      {
-        Date: {
-          type: DataTypes.DATEONLY,
-          primaryKey: true,
-        },
-        adID: {
-          type: DataTypes.STRING,
-          references: {
-            model: "Ad",
-            key: "AdID",
-          },
-          foreignKey: true,
-          primaryKey: true,
-        },
-        Keyword: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          primaryKey: true,
-        },
-        Country: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          primaryKey: true, // ✅ Country is now part of primary key
-        },
-        Revenue: {
-          type: DataTypes.FLOAT,
-          allowNull: false,
-        },
-        Clicks: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-        },
-        TemplatedKeyword: {
-          type: DataTypes.STRING,
-          allowNull: true,
-        },
-        FirstAppearanceDate: {
-          type: DataTypes.DATEONLY,
-          allowNull: true,
-        },
-      },
-      {
-        tableName: "TonicRSOCKeywordPerformance",
-        indexes: [
-          {
-            unique: true,
-            fields: ["Date", "adID", "Keyword", "Country"],
-            name: "tonic_primary_idx" // ✅ Custom short name
-          },
-          {
-            fields: ["Date"],
-            name: "tonic_date_idx"
-          },
-          {
-            fields: ["adID"],
-            name: "tonic_adid_idx"
-          },
-          {
-            fields: ["Keyword"],
-            name: "tonic_keyword_idx"
-          },
-          {
-            fields: ["Country"],
-            name: "tonic_country_idx"
-          },
-          {
-            fields: ["Revenue"],
-            name: "tonic_revenue_idx"
-          },
-          {
-            fields: ["Clicks"],
-            name: "tonic_clicks_idx"
-          },
-          {
-            fields: ["Country", "Date"],
-            name: "tonic_country_date_idx"
-          },
-          {
-            fields: ["Keyword", "Country"],
-            name: "tonic_keyword_country_idx"
-          },
-          {
-            fields: ["Date", "Revenue"],
-            name: "tonic_date_revenue_idx"
-          },
-        ],
-        hooks: {
-          beforeCreate: async (record, options) => {
-            try {
-              const existingKeyword = await sequelize.models.TonicRSOCKeywordPerformance.findOne({
-                where: {
-                  Keyword: sequelize.where(
-                    sequelize.fn("LOWER", sequelize.col("Keyword")),
-                    sequelize.fn("LOWER", record.Keyword)
-                  ),
-                  Country: record.Country,
-                },
-                attributes: ["FirstAppearanceDate"],
-                transaction: options.transaction,
-              });
-  
-              record.FirstAppearanceDate =
-                existingKeyword?.FirstAppearanceDate || record.Date;
-            } catch (error) {
-              console.error("Error in TonicRSOCKeywordPerformance FirstAppearanceDate hook:", error);
-              throw error;
-            }
-          },
-        },
-      }
-    );
-  
-    TonicRSOCKeywordPerformance.associate = (models) => {
-      TonicRSOCKeywordPerformance.belongsTo(models.Ad, {
-        foreignKey: "adID",
-      });
-    };
-  
-    return TonicRSOCKeywordPerformance;
+module.exports = (sequelize, DataTypes) => {
+    const TonicRSOCKeywordPerformance = sequelize.define(
+      "TonicRSOCKeywordPerformance",
+      {
+        Date: {
+          type: DataTypes.DATEONLY,
+          primaryKey: true,
+        },
+        adID: {
+          type: DataTypes.STRING,
+          references: {
+            model: "Ad",
+            key: "AdID",
+          },
+          foreignKey: true,
+          primaryKey: true,
+        },
+        Keyword: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          primaryKey: true,
+        },
+        Country: {
+          type: DataTypes.STRING,
+          allowNull: false,
+          primaryKey: true, // ✅ Country is now part of primary key
+        },
+        Revenue: {
+          type: DataTypes.FLOAT,
+          allowNull: false,
+        },
+        Clicks: {
+          type: DataTypes.INTEGER,
+          allowNull: false,
+        },
+        TemplatedKeyword: {
+          type: DataTypes.STRING,
+          allowNull: true,
+        },
+        FirstAppearanceDate: {
+          type: DataTypes.DATEONLY,
+          allowNull: true,
+        },
+      },
+      {
+        tableName: "TonicRSOCKeywordPerformance",
+        indexes: [
+          {
+            unique: true,
+            fields: ["Date", "adID", "Keyword", "Country"],
+            name: "tonic_primary_idx" // ✅ Custom short name
+          },
+          {
+            fields: ["Date"],
+            name: "tonic_date_idx"
+          },
+          {
+            fields: ["adID"],
+            name: "tonic_adid_idx"
+          },
+          {
+            fields: ["Keyword"],
+            name: "tonic_keyword_idx"
+          },
+          {
+            fields: ["Country"],
+            name: "tonic_country_idx"
+          },
+          {
+            fields: ["Revenue"],
+            name: "tonic_revenue_idx"
+          },
+          {
+            fields: ["Clicks"],
+            name: "tonic_clicks_idx"
+          },
+          {
+            fields: ["Country", "Date"],
+            name: "tonic_country_date_idx"
+          },
+          {
+            fields: ["Keyword", "Country"],
+            name: "tonic_keyword_country_idx"
+          },
+          {
+            fields: ["Date", "Revenue"],
+            name: "tonic_date_revenue_idx"
+          },
+        ],
+        hooks: {
+          beforeCreate: async (record, options) => {
+            try {
+              const existingKeyword = await sequelize.models.TonicRSOCKeywordPerformance.findOne({
+                where: {
+                  Keyword: sequelize.where(
+                    sequelize.fn("LOWER", sequelize.col("Keyword")),
+                    sequelize.fn("LOWER", record.Keyword)
+                  ),
+                  Country: record.Country,
+                },
+                attributes: ["FirstAppearanceDate"],
+                transaction: options.transaction,
+              });
+  
+              record.FirstAppearanceDate =
+                existingKeyword?.FirstAppearanceDate || record.Date;
+            } catch (error) {
+              console.error("Error in TonicRSOCKeywordPerformance FirstAppearanceDate hook:", error);
+              throw error;
+            }
+          },
+        },
+      }
+    );
+  
+    TonicRSOCKeywordPerformance.associate = (models) => {
+      TonicRSOCKeywordPerformance.belongsTo(models.Ad, {
+        foreignKey: "adID",
+      });
+    };
+  
+    return TonicRSOCKeywordPerformance;
   };