agrs-sequelize-sdk 1.2.67 → 1.2.69

package/models/RsocKeywordPerformance.js

@@ -1,111 +1,111 @@
-module.exports = (sequelize, DataTypes) => {
-    const RsocKeywordPerformance = sequelize.define('RsocKeywordPerformance', {
-        id: {
-            type: DataTypes.INTEGER,
-            primaryKey: true,
-            autoIncrement: true,
-            allowNull: false
-        },
-        ts: {
-            type: DataTypes.DATE,
-            allowNull: false,
-            comment: 'Timestamp of the record'
-        },
-        channel_id: {
-            type: DataTypes.STRING,
-            allowNull: false,
-            comment: 'Channel identifier'
-        },
-        style_id: {
-            type: DataTypes.STRING,
-            allowNull: true,
-            comment: 'Style identifier'
-        },
-        country_code: {
-            type: DataTypes.STRING(2),
-            allowNull: true,
-            comment: 'Country code (ISO 2-letter)'
-        },
-        custom_query: {
-            type: DataTypes.TEXT,
-            allowNull: true,
-            comment: 'Custom search query'
-        },
-        query: {
-            type: DataTypes.TEXT,
-            allowNull: true,
-            comment: 'Standard search query'
-        },
-        funnel_page_views: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel page views'
-        },
-        funnel_impressions: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel impressions'
-        },
-        funnel_clicks: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of funnel clicks'
-        },
-        page_views: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of page views'
-        },
-        impressions: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of impressions'
-        },
-        clicks: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            defaultValue: 0,
-            comment: 'Number of clicks'
-        },
-        agrs_cid: {
-            type: DataTypes.STRING,
-            allowNull: true,
-            comment: 'AGRS campaign identifier linking to campaign data'
-        }
-    }, {
-        tableName: 'rsoc_keyword_performance',
-        timestamps: true, // Adds createdAt and updatedAt columns
-        indexes: [
-            {
-                fields: ['channel_id', 'ts'],
-                name: 'idx_rsoc_keyword_channel_time'
-            },
-            {
-                fields: ['style_id'],
-                name: 'idx_rsoc_keyword_style'
-            },
-            {
-                fields: ['country_code'],
-                name: 'idx_rsoc_keyword_country'
-            },
-            {
-                fields: ['agrs_cid'],
-                name: 'idx_rsoc_keyword_agrs_cid'
-            }
-        ]
-    });
-
-    // Define associations if needed
-    RsocKeywordPerformance.associate = (models) => {
-        // Add associations here if your table needs to reference other tables
-        // For example:
-        // RsocKeywordPerformance.belongsTo(models.Channel, { foreignKey: 'channel_id' });
-    };
-
-    return RsocKeywordPerformance;
+module.exports = (sequelize, DataTypes) => {
+    const RsocKeywordPerformance = sequelize.define('RsocKeywordPerformance', {
+        id: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+            allowNull: false
+        },
+        ts: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            comment: 'Timestamp of the record'
+        },
+        channel_id: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            comment: 'Channel identifier'
+        },
+        style_id: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'Style identifier'
+        },
+        country_code: {
+            type: DataTypes.STRING(2),
+            allowNull: true,
+            comment: 'Country code (ISO 2-letter)'
+        },
+        custom_query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Custom search query'
+        },
+        query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Standard search query'
+        },
+        funnel_page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel page views'
+        },
+        funnel_impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel impressions'
+        },
+        funnel_clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel clicks'
+        },
+        page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of page views'
+        },
+        impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of impressions'
+        },
+        clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of clicks'
+        },
+        agrs_cid: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'AGRS campaign identifier linking to campaign data'
+        }
+    }, {
+        tableName: 'rsoc_keyword_performance',
+        timestamps: true, // Adds createdAt and updatedAt columns
+        indexes: [
+            {
+                fields: ['channel_id', 'ts'],
+                name: 'idx_rsoc_keyword_channel_time'
+            },
+            {
+                fields: ['style_id'],
+                name: 'idx_rsoc_keyword_style'
+            },
+            {
+                fields: ['country_code'],
+                name: 'idx_rsoc_keyword_country'
+            },
+            {
+                fields: ['agrs_cid'],
+                name: 'idx_rsoc_keyword_agrs_cid'
+            }
+        ]
+    });
+
+    // Define associations if needed
+    RsocKeywordPerformance.associate = (models) => {
+        // Add associations here if your table needs to reference other tables
+        // For example:
+        // RsocKeywordPerformance.belongsTo(models.Channel, { foreignKey: 'channel_id' });
+    };
+
+    return RsocKeywordPerformance;
 };

package/models/Rule.js

@@ -1,39 +1,153 @@
-module.exports = (sequelize, DataTypes) => {
-  const Rule = sequelize.define("Rule", {
-    ruleName: {
-      type: DataTypes.STRING,
+const { DataTypes } = require('sequelize');
+
+module.exports = (sequelize) => {
+  const Rule = sequelize.define('Rule', {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+    },
+    name: {
+      type: DataTypes.STRING(255),
       allowNull: false,
+      comment: 'Rule name for identification',
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      comment: 'Optional description of what this rule does',
     },
-    timeUnit: {
-      type: DataTypes.ENUM("minutes", "hours", "days"),
+    isActive: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true,
       allowNull: false,
+      comment: 'Whether the rule is currently active',
     },
-    timeValue: {
-      type: DataTypes.INTEGER,
+    ruleType: {
+      type: DataTypes.ENUM(
+        'PAUSE',
+        'BUDGET',
+        'BID',
+        'STATUS',
+        'CUSTOM'
+      ),
       allowNull: false,
+      comment: 'Type of rule - determines the action category',
     },
-    daysAndTimes: {
-      type: DataTypes.JSONB, // Store days, time ranges, and conditions as a JSON object
-      allowNull: true,
+    targetLevel: {
+      type: DataTypes.ENUM(
+        'CAMPAIGN',
+        'ADSET',
+        'AD'
+      ),
+      allowNull: false,
+      comment: 'Level at which the rule operates',
     },
-    filters: {
+    scheduleType: {
+      type: DataTypes.ENUM(
+        'INTERVAL',
+        'CRON',
+        'MANUAL'
+      ),
+      allowNull: false,
+      defaultValue: 'MANUAL',
+      comment: 'How the rule is triggered',
+    },
+    scheduleConfig: {
       type: DataTypes.JSONB,
       allowNull: true,
+      comment: 'Schedule configuration (interval minutes, cron expression, etc.)',
     },
-    triggers: {
-      type: DataTypes.JSONB,
+    gcpJobName: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      comment: 'GCP Cloud Scheduler job name for this rule',
+    },
+    lastExecuted: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      comment: 'When the rule was last executed',
+    },
+    nextExecution: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      comment: 'When the rule is scheduled to run next',
+    },
+    executionCount: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
       allowNull: false,
+      comment: 'Number of times this rule has been executed',
     },
-    actions: {
-      type: DataTypes.JSONB,
+    successCount: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
       allowNull: false,
+      comment: 'Number of successful executions',
     },
-    status: {
-      type: DataTypes.ENUM("active", "paused"),
+    failureCount: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
       allowNull: false,
-      defaultValue: "active",
+      comment: 'Number of failed executions',
     },
+    createdBy: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      comment: 'User who created this rule',
+    },
+    updatedBy: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      comment: 'User who last updated this rule',
+    },
+  }, {
+    tableName: 'Rules',
+    timestamps: true,
+    indexes: [
+      {
+        fields: ['isActive'],
+      },
+      {
+        fields: ['ruleType'],
+      },
+      {
+        fields: ['targetLevel'],
+      },
+      {
+        fields: ['scheduleType'],
+      },
+      {
+        fields: ['nextExecution'],
+      },
+      {
+        fields: ['createdBy'],
+      },
+    ],
   });
 
+  Rule.associate = (models) => {
+    // A rule has many conditions
+    Rule.hasMany(models.RuleCondition, {
+      foreignKey: 'ruleId',
+      as: 'conditions',
+      onDelete: 'CASCADE',
+    });
+
+    // A rule has many actions
+    Rule.hasMany(models.RuleAction, {
+      foreignKey: 'ruleId',
+      as: 'actions',
+      onDelete: 'CASCADE',
+    });
+
+    // A rule has many execution logs
+    Rule.hasMany(models.RuleExecution, {
+      foreignKey: 'ruleId',
+      as: 'executions',
+      onDelete: 'CASCADE',
+    });
+  };
+
   return Rule;
 };

package/models/RuleAction.js

@@ -0,0 +1,92 @@
+const { DataTypes } = require('sequelize');
+
+module.exports = (sequelize) => {
+  const RuleAction = sequelize.define('RuleAction', {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+    },
+    ruleId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Rules',
+        key: 'id',
+      },
+      comment: 'Reference to the parent rule',
+    },
+    actionType: {
+      type: DataTypes.ENUM(
+        // Campaign level actions
+        'PAUSE_CAMPAIGN',
+        'ACTIVATE_CAMPAIGN',
+        'CHANGE_CAMPAIGN_BUDGET',
+        'CHANGE_CAMPAIGN_BID_STRATEGY',
+        
+        // AdSet level actions
+        'PAUSE_ADSET',
+        'ACTIVATE_ADSET',
+        'CHANGE_ADSET_BUDGET',
+        'CHANGE_ADSET_BID',
+        'CHANGE_ADSET_BID_STRATEGY',
+        
+        // Ad level actions
+        'PAUSE_AD',
+        'ACTIVATE_AD',
+        
+        // Custom actions
+        'CUSTOM_ACTION'
+      ),
+      allowNull: false,
+      comment: 'Type of action to perform',
+    },
+    actionConfig: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+      comment: 'Configuration for the action (budget amount, bid strategy, etc.)',
+    },
+    order: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      comment: 'Order of this action within the rule',
+    },
+    isActive: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true,
+      allowNull: false,
+      comment: 'Whether this action is active',
+    },
+    delayMinutes: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      defaultValue: 0,
+      comment: 'Delay in minutes before executing this action',
+    },
+  }, {
+    tableName: 'RuleActions',
+    timestamps: true,
+    indexes: [
+      {
+        fields: ['ruleId'],
+      },
+      {
+        fields: ['actionType'],
+      },
+      {
+        fields: ['order'],
+      },
+    ],
+  });
+
+  RuleAction.associate = (models) => {
+    // An action belongs to a rule
+    RuleAction.belongsTo(models.Rule, {
+      foreignKey: 'ruleId',
+      as: 'rule',
+    });
+  };
+
+  return RuleAction;
+};

package/models/RuleCondition.js

@@ -0,0 +1,97 @@
+const { DataTypes } = require('sequelize');
+
+module.exports = (sequelize) => {
+  const RuleCondition = sequelize.define('RuleCondition', {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+    },
+    ruleId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Rules',
+        key: 'id',
+      },
+      comment: 'Reference to the parent rule',
+    },
+    field: {
+      type: DataTypes.STRING(100),
+      allowNull: false,
+      comment: 'Field to evaluate (e.g., roi, ctr, campaign_name)',
+    },
+    operator: {
+      type: DataTypes.ENUM(
+        'EQUALS',
+        'NOT_EQUALS',
+        'GREATER_THAN',
+        'LESS_THAN',
+        'GREATER_THAN_OR_EQUAL',
+        'LESS_THAN_OR_EQUAL',
+        'BETWEEN',
+        'IN',
+        'NOT_IN',
+        'CONTAINS',
+        'NOT_CONTAINS',
+        'IS_NULL',
+        'IS_NOT_NULL'
+      ),
+      allowNull: false,
+      comment: 'Comparison operator',
+    },
+    value: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+      comment: 'Value(s) to compare against (can be array for BETWEEN, IN, etc.)',
+    },
+    logicalOperator: {
+      type: DataTypes.ENUM(
+        'AND',
+        'OR'
+      ),
+      allowNull: false,
+      defaultValue: 'AND',
+      comment: 'How this condition connects to the next one',
+    },
+    order: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      comment: 'Order of this condition within the rule',
+    },
+    isActive: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true,
+      allowNull: false,
+      comment: 'Whether this condition is active',
+    },
+  }, {
+    tableName: 'RuleConditions',
+    timestamps: true,
+    indexes: [
+      {
+        fields: ['ruleId'],
+      },
+      {
+        fields: ['field'],
+      },
+      {
+        fields: ['operator'],
+      },
+      {
+        fields: ['order'],
+      },
+    ],
+  });
+
+  RuleCondition.associate = (models) => {
+    // A condition belongs to a rule
+    RuleCondition.belongsTo(models.Rule, {
+      foreignKey: 'ruleId',
+      as: 'rule',
+    });
+  };
+
+  return RuleCondition;
+};

package/models/RuleExecution.js

@@ -0,0 +1,120 @@
+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: 'Rules',
+        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',
+    },
+    triggeredBy: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      comment: 'User or system that triggered the execution',
+    },
+  }, {
+    tableName: 'RuleExecutions',
+    timestamps: true,
+    indexes: [
+      {
+        fields: ['ruleId'],
+      },
+      {
+        fields: ['status'],
+      },
+      {
+        fields: ['startTime'],
+      },
+      {
+        fields: ['executionType'],
+      },
+    ],
+  });
+
+  RuleExecution.associate = (models) => {
+    // An execution belongs to a rule
+    RuleExecution.belongsTo(models.Rule, {
+      foreignKey: 'ruleId',
+      as: 'rule',
+    });
+  };
+
+  return RuleExecution;
+};