agrs-sequelize-sdk 1.1.95 → 1.1.97

package/agrs-sequelize/index.js

@@ -1,169 +0,0 @@
-const Sequelize = require("sequelize");
-const path = require("path");
-const fs = require("fs");
-
-// const env = process.env.NODE_ENV || "development";
-class DBModels {
-  constructor(config) {
-    this.config = config;
-    this.db = {};
-
-    // Initialize Sequelize
-    const sequelize = new Sequelize(
-      this.config.database,
-      this.config.username,
-      this.config.password,
-      {
-        host: this.config.host,
-        dialect: this.config.dialect,
-        port: this.config.port,
-        logging: false, // Enable logging to console
-        dialectOptions: {
-          ssl: {
-            require: true, // Require SSL
-            rejectUnauthorized: false, // For self-signed or unverified certificates
-          },
-        },
-        pool: {
-          max: 200, // Increase from 50, but stay under max_connections (200)
-          min: 5, // Increase minimum connections
-          acquire: 60000, // Double acquire timeout
-          idle: 30000, // Align with idle_in_transaction_session_timeout
-        },
-
-        retry: {
-          max: 5,
-          timeout: 60000,
-          match: [
-            /Connection terminated/,
-            /Connection timed out/,
-            /Operation timeout/,
-            /password authentication failed/,
-            /canceling authentication/,
-          ],
-        },
-      }
-    );
-
-    // Load all models
-    fs.readdirSync(path.join(__dirname, "models"))
-      .filter((file) => {
-        return file.indexOf(".") !== 0 && file.slice(-3) === ".js";
-      })
-      .forEach((file) => {
-        const model = require(path.join(__dirname, "models", file))(
-          sequelize,
-          Sequelize.DataTypes
-        );
-        this.db[model.name] = model;
-      });
-
-    // Set up associations
-    Object.keys(this.db).forEach((modelName) => {
-      if (this.db[modelName].associate) {
-        this.db[modelName].associate(this.db);
-      }
-    });
-
-    // Export the db object with Sequelize and models
-    this.db.sequelize = sequelize;
-    this.db.Sequelize = Sequelize;
-  }
-}
-
-module.exports = DBModels;
-
-// const Sequelize = require("sequelize");
-// const path = require("path");
-// const fs = require("fs");
-
-// class DBModels {
-//   constructor(config) {
-//     this.config = config;
-//     this.db = {};
-
-//     const sequelize = new Sequelize(
-//       this.config.database,
-//       this.config.username,
-//       this.config.password,
-//       {
-//         host: this.config.host,
-//         dialect: this.config.dialect,
-//         port: this.config.port,
-//         logging: false,
-//         dialectOptions: {
-//           ssl: {
-//             require: true,
-//             rejectUnauthorized: false,
-//           },
-//           statement_timeout: 30000,
-//           idle_in_transaction_session_timeout: 30000,
-//           connectTimeout: 30000,
-//         },
-//         pool: {
-//           max: 50, // Quarter of max connections (200)
-//           min: 0, // Start from 0 and scale up as needed
-//           acquire: 30000, // Maximum time to wait for a connection
-//           idle: 10000, // How long a connection can remain idle
-//         },
-//         retry: {
-//           max: 3,
-//           timeout: 20000,
-//           match: [
-//             /Connection terminated/,
-//             /Connection timed out/,
-//             /Operation timeout/,
-//             /ECONNRESET/,
-//             /PROTOCOL_CONNECTION_LOST/,
-//           ],
-//         },
-//       }
-//     );
-
-//     // Add connection monitoring listeners
-//     sequelize.connectionManager.on("acquire", function (connection) {
-//       console.log("Connection %d acquired", connection.threadId);
-//     });
-
-//     sequelize.connectionManager.on("release", function (connection) {
-//       console.log("Connection %d released", connection.threadId);
-//     });
-
-//     // Load all models
-//     fs.readdirSync(path.join(__dirname, "models"))
-//       .filter((file) => {
-//         return file.indexOf(".") !== 0 && file.slice(-3) === ".js";
-//       })
-//       .forEach((file) => {
-//         const model = require(path.join(__dirname, "models", file))(
-//           sequelize,
-//           Sequelize.DataTypes
-//         );
-//         this.db[model.name] = model;
-//       });
-
-//     // Set up associations
-//     Object.keys(this.db).forEach((modelName) => {
-//       if (this.db[modelName].associate) {
-//         this.db[modelName].associate(this.db);
-//       }
-//     });
-
-//     // Export the db object with Sequelize and models
-//     this.db.sequelize = sequelize;
-//     this.db.Sequelize = Sequelize;
-//   }
-
-//   // Add method for pool monitoring
-//   async getConnectionPoolStats() {
-//     const pool = this.db.sequelize.connectionManager.pool;
-//     return {
-//       all: pool.size,
-//       available: pool.available,
-//       borrowed: pool.borrowed,
-//       pending: pool.pending,
-//     };
-//   }
-// }
-
-// module.exports = DBModels;

package/agrs-sequelize/models/ActivityHistory.js

@@ -1,73 +0,0 @@
-// models/ActivityHistory.js
-module.exports = (sequelize, DataTypes) => {
-  const ActivityHistory = sequelize.define(
-    "ActivityHistory",
-    {
-      ActivityHistoryID: {
-        type: DataTypes.INTEGER,
-        primaryKey: true,
-        autoIncrement: true,
-      },
-      AssociatedModelType: {
-        type: DataTypes.STRING,
-        allowNull: false, // Could be 'Ad', 'AdSet', 'Campaign', etc.
-      },
-      AssociatedModelID: {
-        type: DataTypes.STRING,
-        allowNull: false, // ID of the associated model
-      },
-      ActorID: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ActorName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ApplicationName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      DateTimeInTimeZone: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      EventType: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ObjectName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ObjectType: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      TranslatedEventType: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ObjectID: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      ExtraData: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "ActivityHistory",
-      indexes: [
-        {
-          unique: true,
-          name: "unique_index_on_date_object_event", // Custom name
-          fields: ["DateTimeInTimeZone", "ObjectID", "EventType"],
-        },
-      ],
-    }
-  );
-
-  return ActivityHistory;
-};

package/agrs-sequelize/models/Ad.js

@@ -1,209 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Ad = sequelize.define(
-    "Ad",
-    {
-      AdID: {
-        type: DataTypes.STRING,
-        primaryKey: true,
-      },
-      AdName: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      AdSetID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        references: {
-          model: "AdSet",
-          key: "AdSetID",
-        },
-      },
-      creativeId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      pixelId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      startTime: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      endTime: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      format: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "SINGLE",
-      },
-      imageHashes: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      videoIds: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      messages: {
-        type: DataTypes.ARRAY(DataTypes.TEXT),
-        allowNull: true,
-      },
-      headlines: {
-        type: DataTypes.ARRAY(DataTypes.TEXT),
-        allowNull: true,
-      },
-      websiteUrl: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-      },
-      pageId: {
-        type: DataTypes.STRING(256),
-        allowNull: true,
-      },
-      actionTypes: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        defaultValue: "offsite_conversion",
-      },
-      Status: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      publish: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: true,
-      },
-      createdTime: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      AGRS_CID: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      Draft: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: false,
-      },
-      UserCreated: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      effectiveStatus: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      issuesInfo: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      adReviewFeedback: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      waiting: {
-        type: DataTypes.BOOLEAN,
-        defaultValue: false,
-      },
-    },
-    {
-      tableName: "Ad",
-      indexes: [
-        {
-          fields: ["AdSetID"],
-        },
-      ],
-    }
-  );
-
-  Ad.associate = (models) => {
-    Ad.belongsTo(models.AdSet, { foreignKey: "AdSetID" });
-
-    Ad.belongsTo(models.CodefuelCampaign, {
-      foreignKey: "AGRS_CID",
-      targetKey: "AGRSCID",
-      as: "CodefuelCampaign",
-      constraints: false,
-    });
-
-    Ad.belongsTo(models.RSOCFeedCampaign, {
-      foreignKey: "AGRS_CID",
-      targetKey: "AGRS_CID",
-      as: "RSOCFeedCampaign",
-      constraints: false,
-    });
-
-    Ad.hasMany(models.AdPerformance, {
-      foreignKey: "AdID",
-    });
-  };
-
-  Ad.prototype.getRelatedCampaign = async function () {
-    if (!this.AGRS_CID) return null;
-
-    // Try fetching related CodefuelCampaign
-    const codefuelCampaign = await sequelize.models.CodefuelCampaign.findOne({
-      where: { AGRSCID: this.AGRS_CID },
-    });
-
-    if (codefuelCampaign) {
-      return {
-        type: "CodefuelCampaign",
-        data: codefuelCampaign,
-      };
-    }
-
-    // Try fetching related RSOCFeedCampaign
-    const rsocFeedCampaign = await sequelize.models.RSOCFeedCampaign.findOne({
-      where: { AGRS_CID: this.AGRS_CID },
-    });
-
-    if (rsocFeedCampaign) {
-      return {
-        type: "RSOCFeedCampaign",
-        data: rsocFeedCampaign,
-      };
-    }
-
-    return null;
-  };
-
-  Ad.addHook("afterCreate", async (ad, options) => {
-    if (ad.publish === false) {
-      // If publish is false on creation, save a snapshot to AdHistory
-      await sequelize.models.AdHistory.create({
-        AdID: ad.AdID,
-        DataSnapshot: ad.toJSON(), // Save the full Ad data as JSON
-      });
-    }
-  });
-
-  Ad.addHook("beforeUpdate", async (ad, options) => {
-    if (ad.changed("publish")) {
-      if (ad.previous("publish") === true && ad.publish === false) {
-        // Save current state to AdHistory
-        await sequelize.models.AdHistory.create({
-          AdID: ad.AdID,
-          DataSnapshot: ad._previousDataValues, // Save the full Ad data as JSON
-        });
-      } else if (ad.previous("publish") === false && ad.publish === true) {
-        // Delete the latest history entry
-        const latestHistory = await sequelize.models.AdHistory.findOne({
-          where: { AdID: ad.AdID },
-          order: [["timestamp", "DESC"]], // Get the latest history entry
-        });
-
-        if (latestHistory) {
-          await latestHistory.destroy();
-        }
-      }
-    }
-  });
-
-  return Ad;
-};

package/agrs-sequelize/models/AdAccount.js

@@ -1,91 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdAccount = sequelize.define(
-    "AdAccount",
-    {
-      AdAccountID: {
-        type: DataTypes.STRING,
-        primaryKey: true,
-      },
-      AdAccountName: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      AdAccountTimeZone: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      Currency: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      Rate: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-      },
-      UTCOffset: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-      },
-      Draft: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-      },
-      account_status: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      // includeInUpdate: bool
-      IncludeInUpdate: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-      },
-      BusinessManager: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      Reporting: {
-        type: DataTypes.BOOLEAN,
-        defaultValue: true,
-        allowNull: true,
-      },
-      Users: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: false,
-        defaultValue: [],
-      },
-      feedProvider: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: false,
-        defaultValue: [], // Default value is an empty array
-      },
-      Archived: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-      },
-      disabled_reason: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "AdAccount",
-      indexes: [
-        {
-          fields: ["AdAccountName"],
-        },
-        {
-          fields: ["Currency"],
-        },
-      ],
-    }
-  );
-
-  AdAccount.associate = (models) => {
-    AdAccount.hasMany(models.Campaign, {
-      foreignKey: "AdAccountID",
-      as: "Campaigns",
-    });
-  };
-
-  return AdAccount;
-};

package/agrs-sequelize/models/AdAccountValues.js

@@ -1,26 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const AdAccountValues = sequelize.define(
-      "AdAccountValues",
-      {
-        id: {
-          type: DataTypes.UUID,
-          defaultValue: DataTypes.UUIDV4,
-          primaryKey: true,
-        },
-        name: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        code: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          unique: true, 
-        },
-      },
-      {
-        tableName: "AdAccountValues",
-      }
-    );
-  
-    return AdAccountValues;
-  };

package/agrs-sequelize/models/AdHistory.js

@@ -1,30 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdHistory = sequelize.define(
-    "AdHistory",
-    {
-      HistoryID: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        primaryKey: true,
-      },
-      AdID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      DataSnapshot: {
-        type: DataTypes.JSONB, // Store the full Ad row as a JSON object
-        allowNull: false,
-      },
-      timestamp: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-    },
-    {
-      tableName: "AdHistory",
-      timestamps: false, // Disable Sequelize timestamps
-    }
-  );
-
-  return AdHistory;
-};

package/agrs-sequelize/models/AdPerformance.js

@@ -1,84 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdPerformance = sequelize.define(
-    "AdPerformance",
-    {
-      Date: {
-        type: DataTypes.DATEONLY,
-        primaryKey: true,
-      },
-      AdID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        primaryKey: true,
-      },
-      AmountSpent: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-      Impressions: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      LinkClicks: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Revenue: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-      AdClicks: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Sessions: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      ViewContent: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Search: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Purchase: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      originalSpend: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-      originRevenue: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "AdPerformance",
-      indexes: [
-        {
-          unique: true,
-          fields: ["AdID", "Date"], // Composite unique index
-        },
-        {
-          fields: ["Date"], // Index on Date for faster range queries
-        },
-        {
-          fields: ["AdID"], // Index on AdID for faster join
-        },
-      ],
-    }
-  );
-
-  AdPerformance.associate = (models) => {
-    AdPerformance.belongsTo(models.Ad, { foreignKey: "AdID" });
-  };
-
-  return AdPerformance;
-};