agrs-sequelize-sdk 1.4.21 → 1.4.22

package/.worktrees/tt-snp-asset-tables/models/RsocKeywordPerformance.js

@@ -1,111 +0,0 @@
-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/.worktrees/tt-snp-asset-tables/models/RuleAction.js

@@ -1,90 +0,0 @@
-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: "AutomationRule",
-          key: "id",
-        },
-        comment: "Reference to the parent rule",
-      },
-      actionType: {
-        type: DataTypes.ENUM(
-          "PAUSE",
-          "ACTIVATE", 
-          "CHANGE_BUDGET",
-          "CHANGE_BID",
-          "CHANGE_BID_STRATEGY",
-          "CUSTOM_ACTION"
-        ),
-        allowNull: false,
-        comment: "Type of action to perform",
-      },
-      targetLevel: {
-        type: DataTypes.ENUM("CAMPAIGN", "ADSET", "AD"),
-        allowNull: false,
-        comment: "Level at which the action operates",
-      },
-      value: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-        comment: "Value for the action (budget amount, bid amount, etc.)",
-      },
-      valueType: {
-        type: DataTypes.ENUM("STRING", "NUMBER", "ARRAY"),
-        allowNull: true,
-        defaultValue: "STRING",
-        comment: "Type of the value field",
-      },
-      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,
-      // Remove indexes from model definition - they will be created by migration
-    }
-  );
-
-  RuleAction.associate = (models) => {
-    // An action belongs to a rule
-    RuleAction.belongsTo(models.AutomationRule, {
-      foreignKey: "ruleId",
-      as: "rule",
-    });
-  };
-
-  return RuleAction;
-};

package/.worktrees/tt-snp-asset-tables/models/RuleCondition.js

@@ -1,137 +0,0 @@
-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: "AutomationRule",
-          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)",
-      },
-      type: {
-        type: DataTypes.ENUM("DIMENSION", "METRIC"),
-        allowNull: false,
-        defaultValue: "DIMENSION",
-        comment:
-          "Type of field - DIMENSION for filtering, METRIC for calculations",
-      },
-      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.)",
-      },
-      valueType: {
-        type: DataTypes.ENUM("STRING", "NUMBER", "ARRAY"),
-        allowNull: true,
-        defaultValue: "STRING",
-        comment: "Type of the value field",
-      },
-      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",
-      },
-      groupId: {
-        type: DataTypes.STRING(50),
-        allowNull: true,
-        comment: "ID to group conditions together (e.g., group1, group2)",
-      },
-      groupOperator: {
-        type: DataTypes.ENUM("AND", "OR"),
-        allowNull: false,
-        defaultValue: "AND",
-        comment: "Operator within the group (AND/OR)",
-      },
-      betweenGroupsOperator: {
-        type: DataTypes.ENUM("AND", "OR"),
-        allowNull: true,
-        comment:
-          "Operator between different groups (AND/OR) - only for first condition in group",
-      },
-      dateRangeType: {
-        type: DataTypes.STRING(50),
-        allowNull: true,
-        comment:
-          "Type of date range (last_7_days, yesterday, today, custom, etc.)",
-      },
-      dateRangeValue: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        comment: "Number of days for relative date ranges",
-      },
-      customStartDate: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        comment: "Custom start date if dateRangeType is custom",
-      },
-      customEndDate: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        comment: "Custom end date if dateRangeType is custom",
-      },
-    },
-    {
-      tableName: "RuleConditions",
-      timestamps: true,
-      // Remove indexes from model definition - they will be created by migration
-    }
-  );
-
-  RuleCondition.associate = (models) => {
-    // A condition belongs to a rule
-    RuleCondition.belongsTo(models.AutomationRule, {
-      foreignKey: "ruleId",
-      as: "rule",
-    });
-  };
-
-  return RuleCondition;
-};

package/.worktrees/tt-snp-asset-tables/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/tt-snp-asset-tables/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/tt-snp-asset-tables/models/SnapchatPublicProfiles.js

@@ -1,47 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const SnapchatPublicProfiles = sequelize.define(
-    "SnapchatPublicProfiles",
-    {
-      id: {
-        type: DataTypes.BIGINT,
-        primaryKey: true,
-        autoIncrement: true,
-      },
-      public_profile_id: {
-        type: DataTypes.STRING(64),
-        allowNull: false,
-        unique: true,
-        comment:
-          "Snapchat public_profile_id used as creative owner on ad creation",
-      },
-      name: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-      },
-      ad_account_id: {
-        type: DataTypes.STRING(64),
-        allowNull: false,
-        comment: "Snapchat ad_account_id this profile belongs to",
-      },
-      status: {
-        type: DataTypes.STRING(16),
-        allowNull: false,
-        defaultValue: "active",
-        comment: "active | disabled",
-      },
-      tier: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        defaultValue: 1,
-        comment:
-          "Rotation weight. Higher tier => higher probability of being picked.",
-      },
-    },
-    {
-      tableName: "snapchat_public_profiles",
-      indexes: [{ fields: ["ad_account_id", "status"] }],
-    }
-  );
-
-  return SnapchatPublicProfiles;
-};

package/.worktrees/tt-snp-asset-tables/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;
-  };