agrs-sequelize-sdk 1.4.18 → 1.4.21

package/.worktrees/add-platform-to-rule/models/SyncHistory.js

@@ -0,0 +1,250 @@
+// 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/add-platform-to-rule/models/TTQChannel.js

@@ -0,0 +1,42 @@
+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;
+};

package/.worktrees/add-platform-to-rule/models/TemplateMetadata.js

@@ -0,0 +1,260 @@
+/**
+ * TemplateMetadata Model
+ * Stores rich metadata for banner templates with AI-generated insights
+ * Used for advanced filtering, sorting, and template library management
+ */
+
+module.exports = (sequelize, DataTypes) => {
+  const TemplateMetadata = sequelize.define(
+    "TemplateMetadata",
+    {
+      id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        comment: "Auto-incremented primary key",
+      },
+      name: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+        comment: "Template name (e.g., 'Template 1')",
+      },
+      status: {
+        type: DataTypes.STRING(20),
+        allowNull: false,
+        defaultValue: "Active",
+        comment: "Template status (e.g., 'Active', 'Inactive')",
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Short description (200 chars)",
+      },
+      detailedDescription: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "detailed_description",
+        comment: "Full template description from templateDescriptions.js",
+      },
+
+      // ===== Metadata Fields =====
+      imageType: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "image_type",
+        comment:
+          "Best image type for this template (e.g., 'photo', 'illustration', 'render3d', 'collage', 'solid', 'cartoon', 'mixed')",
+      },
+      category: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Layout category (e.g., 'asymmetric-split', 'vertical-stack')",
+      },
+      tags: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        comment: "Array of descriptive tags for filtering",
+      },
+      elements: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        comment:
+          "Array of visual elements (e.g., ['Photo', 'Headline', 'CTA'])",
+      },
+      complexity: {
+        type: DataTypes.STRING(20),
+        allowNull: true,
+        comment: "Template complexity level (e.g., 'low', 'medium', 'high')",
+      },
+      textDensity: {
+        type: DataTypes.STRING(20),
+        allowNull: true,
+        field: "text_density",
+        comment:
+          "Amount of text in template (e.g., 'none', 'low', 'medium', 'high')",
+      },
+      imageCount: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        field: "image_count",
+        comment: "Number of image slots",
+      },
+
+      // ===== Layout Fields =====
+      layoutStructure: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "layout_structure",
+        comment: "Description of layout structure",
+      },
+      composition: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Description of visual composition",
+      },
+      textPlacement: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        field: "text_placement",
+        comment: "Array of text placement descriptions",
+      },
+      imagePlacement: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        field: "image_placement",
+        comment: "Array of image placement descriptions",
+      },
+
+      // ===== Prompt Fields (for AI generation) =====
+      imageStyle: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "image_style",
+        comment: "Image style for AI prompt (e.g., 'PHOTO', 'ILLUSTRATION')",
+      },
+      layoutDescription: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "layout_description",
+        comment: "Detailed layout description for AI prompt",
+      },
+      textPositions: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        field: "text_positions",
+        comment: "Text positioning info for AI prompt (headline, cta, subtext)",
+      },
+      backgroundType: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "background_type",
+        comment: "Background type description",
+      },
+      colorPalette: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        field: "color_palette",
+        comment: "Array of color palette hints",
+      },
+      mood: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Mood/aesthetic description",
+      },
+
+      // ===== Sample Images =====
+      sampleImages: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        defaultValue: [],
+        field: "sample_images",
+        comment: "Array of sample image URLs",
+      },
+
+      // ===== User Uploaded Original Image =====
+      userUploadedImageUrl: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "user_uploaded_image_url",
+        comment:
+          "URL of the original banner image uploaded by user (stored in GCP)",
+      },
+      uploadedBy: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        field: "uploaded_by",
+        comment: "Username of the user who uploaded this template",
+      },
+      isUserGenerated: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+        field: "is_user_generated",
+        comment:
+          "True if template was uploaded/analyzed by user, false if system template",
+      },
+
+      // ===== Preview =====
+      layoutPreview: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        field: "layout_preview",
+        comment: "HTML/CSS preview generated by Gemini AI",
+      },
+
+      // ===== Template Specification (JSON) =====
+      templateSpec: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        field: "template_spec",
+        comment: "Detailed JSON specification for template reproduction (imageStyle, layout, positions)",
+      },
+
+      // ===== Legacy Grid Config (for backward compatibility) =====
+      legacyGridConfig: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        field: "legacy_grid_config",
+        comment: "Original Grid CSS config from templateConfig.json",
+      },
+      originalCreatedAt: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        field: "original_created_at",
+        comment: "Original creation date from templateConfig.json",
+      },
+
+      // ===== Timestamps =====
+      createdAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+        field: "created_at",
+      },
+      updatedAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+        field: "updated_at",
+      },
+    },
+    {
+      tableName: "template_metadata",
+      timestamps: true,
+      underscored: true,
+      indexes: [
+        {
+          name: "idx_template_metadata_status",
+          fields: ["status"],
+        },
+        {
+          name: "idx_template_metadata_image_type",
+          fields: ["image_type"],
+        },
+        {
+          name: "idx_template_metadata_complexity",
+          fields: ["complexity"],
+        },
+        {
+          name: "idx_template_metadata_category",
+          fields: ["category"],
+        },
+        {
+          name: "idx_template_metadata_image_count",
+          fields: ["image_count"],
+        },
+        {
+          name: "idx_template_metadata_is_user_generated",
+          fields: ["is_user_generated"],
+        },
+      ],
+    }
+  );
+
+  return TemplateMetadata;
+};

package/.worktrees/add-platform-to-rule/models/Tier2_AdAccounts.js

@@ -0,0 +1,110 @@
+module.exports = (sequelize, DataTypes) => {
+  const Tier2_AdAccounts = sequelize.define(
+    "Tier2_AdAccounts",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      userId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: "Users",
+          key: "id",
+        },
+        onDelete: "CASCADE",
+        onUpdate: "CASCADE",
+      },
+      businessManagerId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        references: {
+          model: "Tier2_BusinessManagers",
+          key: "id",
+        },
+        onDelete: "CASCADE",
+        onUpdate: "CASCADE",
+      },
+      facebookAdAccountId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      accountStatus: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      currency: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      timezone: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      timezoneOffset: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      spendCap: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+      },
+      amountSpent: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+      },
+      balance: {
+        type: DataTypes.FLOAT,
+        allowNull: true,
+      },
+      disabledReason: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      lastSyncAt: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+    },
+    {
+      tableName: "Tier2_AdAccounts",
+      indexes: [
+        {
+          fields: ["userId"],
+        },
+        {
+          fields: ["businessManagerId"],
+        },
+        {
+          fields: ["facebookAdAccountId"],
+          unique: true,
+        },
+        {
+          fields: ["accountStatus"],
+        },
+      ],
+    }
+  );
+
+  Tier2_AdAccounts.associate = (models) => {
+    Tier2_AdAccounts.belongsTo(models.Users, {
+      foreignKey: "userId",
+      as: "user",
+    });
+
+    Tier2_AdAccounts.belongsTo(models.Tier2_BusinessManagers, {
+      foreignKey: "businessManagerId",
+      as: "businessManager",
+    });
+  };
+
+  return Tier2_AdAccounts;
+};