agrs-sequelize-sdk 1.4.21 → 1.4.22

package/.worktrees/creation-logs-platform-code/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/creation-logs-platform-code/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;
-};

package/.worktrees/creation-logs-platform-code/models/TemplateMetadata.js

@@ -1,260 +0,0 @@
-/**
- * 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/creation-logs-platform-code/models/Tier2_AdAccounts.js

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