agrs-sequelize-sdk 1.4.36 → 1.4.38

package/.worktrees/ad-review-status/models/RuleExecution.js

@@ -1,107 +0,0 @@
-const { DataTypes } = require("sequelize");
-
-module.exports = (sequelize) => {
-  const RuleExecution = sequelize.define(
-    "RuleExecution",
-    {
-      id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        primaryKey: true,
-      },
-      ruleId: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        references: {
-          model: "AutomationRule",
-          key: "id",
-        },
-        comment: "Reference to the executed rule",
-      },
-      executionType: {
-        type: DataTypes.ENUM("SCHEDULED", "MANUAL", "API_TRIGGER"),
-        allowNull: false,
-        comment: "How the rule was triggered",
-      },
-      status: {
-        type: DataTypes.ENUM("RUNNING", "SUCCESS", "FAILED", "PARTIAL_SUCCESS"),
-        allowNull: false,
-        comment: "Execution status",
-      },
-      startTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        comment: "When execution started",
-      },
-      endTime: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        comment: "When execution completed",
-      },
-      duration: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        comment: "Execution duration in milliseconds",
-      },
-      itemsEvaluated: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        allowNull: false,
-        comment: "Number of items (campaigns/adsets/ads) evaluated",
-      },
-      itemsMatched: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        allowNull: false,
-        comment: "Number of items that matched the conditions",
-      },
-      actionsExecuted: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        allowNull: false,
-        comment: "Number of actions successfully executed",
-      },
-      actionsFailed: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        allowNull: false,
-        comment: "Number of actions that failed",
-      },
-      errorMessage: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-        comment: "Error message if execution failed",
-      },
-      executionDetails: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-        comment: "Detailed execution results and logs",
-      },
-      matchedItems: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-        comment: "List of items that matched the rule conditions and had actions applied",
-      },
-      triggeredBy: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-        comment: "User or system that triggered the execution",
-      },
-    },
-    {
-      tableName: "RuleExecutions",
-      timestamps: true,
-      // Remove indexes from model definition - they will be created by migration
-    }
-  );
-
-  RuleExecution.associate = (models) => {
-    // An execution belongs to a rule
-    RuleExecution.belongsTo(models.AutomationRule, {
-      foreignKey: "ruleId",
-      as: "rule",
-    });
-  };
-
-  return RuleExecution;
-};

package/.worktrees/ad-review-status/models/RulesValues.js

@@ -1,56 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const RulesValues = sequelize.define(
-    "RulesValues",
-    {
-      id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        primaryKey: true,
-      },
-      name: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      code: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-      },
-      permissions: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: false,
-        defaultValue: [],
-      },
-      feature: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      parentId: {
-        type: DataTypes.UUID,
-        allowNull: true,
-        references: {
-          model: "RulesValues",
-          key: "id",
-        },
-        onDelete: "CASCADE",
-      },
-    },
-    {
-      tableName: "RulesValues",
-    }
-  );
-
-  // Self-referential association to define sub-rules
-  RulesValues.hasMany(RulesValues, {
-    as: "subRules",
-    foreignKey: "parentId",
-    onDelete: "CASCADE",
-  });
-
-  RulesValues.belongsTo(RulesValues, {
-    as: "parentRule",
-    foreignKey: "parentId",
-  });
-
-  return RulesValues;
-};

package/.worktrees/ad-review-status/models/SupportedLocale.js

@@ -1,24 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const SupportedLocale = sequelize.define('SupportedLocale', {
-      country: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      locale: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      language: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        comment: 'Language code (e.g., en, es, fr)'
-      }
-    });
-  
-    // Define associations if needed in the future
-    // SupportedLocale.associate = (models) => {
-    //   // e.g., SupportedLocale.hasMany(models.OtherModel);
-    // };
-  
-    return SupportedLocale;
-  };

package/.worktrees/ad-review-status/models/SyncHistory.js

@@ -1,250 +0,0 @@
-// models/SyncHistory.js
-module.exports = (sequelize, DataTypes) => {
-    const SyncHistory = sequelize.define(
-      "SyncHistory",
-      {
-        id: {
-          type: DataTypes.INTEGER,
-          primaryKey: true,
-          autoIncrement: true,
-        },
-        syncId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          unique: true,
-          comment: "Unique identifier for the sync operation"
-        },
-        syncType: {
-          type: DataTypes.ENUM('manual', 'quick_sync', 'group_sync', 'preset_sync', 'scheduled'),
-          allowNull: false,
-          defaultValue: 'manual',
-          comment: "Type of sync operation performed"
-        },
-        initiatedBy: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "User who initiated the sync (username or user ID)"
-        },
-        startTime: {
-          type: DataTypes.DATE,
-          allowNull: false,
-          comment: "When the sync operation started"
-        },
-        endTime: {
-          type: DataTypes.DATE,
-          allowNull: true,
-          comment: "When the sync operation completed"
-        },
-        duration: {
-          type: DataTypes.INTEGER,
-          allowNull: true,
-          comment: "Duration in milliseconds"
-        },
-        status: {
-          type: DataTypes.ENUM('running', 'completed', 'failed', 'cancelled'),
-          allowNull: false,
-          defaultValue: 'running',
-          comment: "Current status of the sync operation"
-        },
-        success: {
-          type: DataTypes.BOOLEAN,
-          allowNull: true,
-          comment: "Whether the sync completed successfully"
-        },
-        totalTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Total number of tables in the sync"
-        },
-        successfulTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of tables synced successfully"
-        },
-        failedTables: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of tables that failed to sync"
-        },
-        totalRecords: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Total number of records synced"
-        },
-        tablesIncluded: {
-          type: DataTypes.ARRAY(DataTypes.STRING),
-          allowNull: false,
-          defaultValue: [],
-          comment: "List of tables included in this sync"
-        },
-        syncOptions: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Sync options used (truncateFirst, batchSize, etc.)"
-        },
-        errorCount: {
-          type: DataTypes.INTEGER,
-          allowNull: false,
-          defaultValue: 0,
-          comment: "Number of errors encountered"
-        },
-        errorSummary: {
-          type: DataTypes.TEXT,
-          allowNull: true,
-          comment: "Brief summary of errors encountered"
-        },
-        detailedResults: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Detailed results for each table (success/failure, record counts, errors)"
-        },
-        safetyChecks: {
-          type: DataTypes.JSONB,
-          allowNull: true,
-          comment: "Safety check results (hosts, direction, etc.)"
-        },
-        sourceHost: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Production database host"
-        },
-        targetHost: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Staging database host"
-        },
-        environment: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "Environment where sync was executed (development, staging, production)"
-        },
-        groupsOrPreset: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: "If this was a group/preset sync, which one was used"
-        }
-      },
-      {
-        tableName: "SyncHistory",
-        timestamps: true, // Adds createdAt and updatedAt
-        indexes: [
-          {
-            fields: ["syncId"],
-            unique: true
-          },
-          {
-            fields: ["startTime"],
-            name: "idx_sync_history_start_time"
-          },
-          {
-            fields: ["status"],
-            name: "idx_sync_history_status"
-          },
-          {
-            fields: ["success"],
-            name: "idx_sync_history_success"
-          },
-          {
-            fields: ["syncType"],
-            name: "idx_sync_history_type"
-          },
-          {
-            fields: ["initiatedBy"],
-            name: "idx_sync_history_user"
-          },
-          {
-            fields: ["createdAt"],
-            name: "idx_sync_history_created"
-          }
-        ]
-      }
-    );
-  
-    // Add model methods
-    SyncHistory.prototype.getDurationInSeconds = function() {
-      return this.duration ? (this.duration / 1000).toFixed(1) : null;
-    };
-  
-    SyncHistory.prototype.getSuccessRate = function() {
-      if (this.totalTables === 0) return 0;
-      return ((this.successfulTables / this.totalTables) * 100).toFixed(1);
-    };
-  
-    SyncHistory.prototype.isRunning = function() {
-      return this.status === 'running';
-    };
-  
-    SyncHistory.prototype.hasErrors = function() {
-      return this.errorCount > 0;
-    };
-  
-    // Static methods for common queries
-    SyncHistory.getRecentHistory = async function(limit = 10) {
-      return await this.findAll({
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getRunningsyncs = async function() {
-      return await this.findAll({
-        where: { status: 'running' },
-        order: [['startTime', 'DESC']]
-      });
-    };
-  
-    SyncHistory.getSuccessfulSyncs = async function(limit = 10) {
-      return await this.findAll({
-        where: { success: true },
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getFailedSyncs = async function(limit = 10) {
-      return await this.findAll({
-        where: { success: false },
-        order: [['startTime', 'DESC']],
-        limit: limit
-      });
-    };
-  
-    SyncHistory.getSyncStats = async function() {
-      const total = await this.count();
-      const successful = await this.count({ where: { success: true } });
-      const failed = await this.count({ where: { success: false } });
-      const running = await this.count({ where: { status: 'running' } });
-  
-      const avgDuration = await this.findOne({
-        attributes: [
-          [sequelize.fn('AVG', sequelize.col('duration')), 'avgDuration']
-        ],
-        where: { success: true },
-        raw: true
-      });
-  
-      const totalRecords = await this.findOne({
-        attributes: [
-          [sequelize.fn('SUM', sequelize.col('totalRecords')), 'totalRecords']
-        ],
-        where: { success: true },
-        raw: true
-      });
-  
-      return {
-        totalSyncs: total,
-        successfulSyncs: successful,
-        failedSyncs: failed,
-        runningSyncs: running,
-        successRate: total > 0 ? ((successful / total) * 100).toFixed(1) : 0,
-        averageDuration: avgDuration?.avgDuration ? Math.round(avgDuration.avgDuration) : null,
-        totalRecordsSynced: totalRecords?.totalRecords || 0
-      };
-    };
-  
-    return SyncHistory;
-  };

package/.worktrees/ad-review-status/models/TTQChannel.js

@@ -1,42 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const TTQChannel = sequelize.define(
-    "TTQChannel",
-    {
-      channelId: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-      },
-      status: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "free",
-        validate: {
-          isIn: [["free", "used", "archived"]],
-        },
-      },
-      connectedCampaigns: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        defaultValue: [],
-      },
-    },
-    {
-      tableName: "ttq_rsoc_channels",
-      timestamps: true,
-    }
-  );
-
-  TTQChannel.associate = (models) => {
-    if (models.RSOCFeedCampaign) {
-      TTQChannel.hasMany(models.RSOCFeedCampaign, {
-        foreignKey: "channelId",
-        sourceKey: "channelId",
-        as: "RSOCFeedCampaigns",
-        constraints: false,
-      });
-    }
-  };
-
-  return TTQChannel;
-};