agrs-sequelize-sdk 1.4.36 → 1.4.38

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

@@ -1,163 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const FacebookRetryQueue = sequelize.define(
-    "FacebookRetryQueue",
-    {
-      id: {
-        type: DataTypes.INTEGER,
-        primaryKey: true,
-        autoIncrement: true,
-      },
-      process_id: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        field: "process_id",
-        comment: "Process ID from the original campaign creation request",
-      },
-      feed_campaign_id: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-        field: "feed_campaign_id",
-        comment: "AGRS_CID from the feed campaign",
-      },
-      feed_provider: {
-        type: DataTypes.STRING(100),
-        allowNull: false,
-        field: "feed_provider",
-      },
-      country_group: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        field: "country_group",
-        comment: 'Array of country codes, e.g. ["US"] or ["US", "GB"]',
-      },
-      campaign_name: {
-        type: DataTypes.STRING(500),
-        allowNull: true,
-        field: "campaign_name",
-      },
-      account_id: {
-        type: DataTypes.STRING(100),
-        allowNull: true,
-        field: "account_id",
-        comment: "Facebook ad account ID",
-      },
-      original_request: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        field: "original_request",
-        comment: "Full campaignData from the original HTTP request",
-      },
-      facebook_payload: {
-        type: DataTypes.JSONB,
-        allowNull: false,
-        field: "facebook_payload",
-        comment:
-          "facebookCampaignData passed to createFullCampaignController",
-      },
-      feed_campaign_result: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-        field: "feed_campaign_result",
-        comment:
-          "feedCampaign result (AGRS_CID, rac, urlTags, channelId, etc.)",
-      },
-      last_error: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-        field: "last_error",
-      },
-      last_error_code: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        field: "last_error_code",
-      },
-      is_transient: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        field: "is_transient",
-      },
-      status: {
-        type: DataTypes.STRING(50),
-        allowNull: false,
-        defaultValue: "pending",
-        validate: {
-          isIn: [
-            ["pending", "processing", "completed", "failed", "abandoned"],
-          ],
-        },
-      },
-      retry_count: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        defaultValue: 0,
-        field: "retry_count",
-      },
-      max_retries: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        defaultValue: 5,
-        field: "max_retries",
-      },
-      next_retry_at: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        field: "next_retry_at",
-        comment: "When the next retry should be attempted",
-      },
-      last_attempt_at: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        field: "last_attempt_at",
-      },
-      completed_at: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        field: "completed_at",
-      },
-      facebook_campaign_id: {
-        type: DataTypes.STRING(255),
-        allowNull: true,
-        field: "facebook_campaign_id",
-        comment: "Facebook campaign ID (populated on success)",
-      },
-      created_at: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        defaultValue: DataTypes.NOW,
-        field: "created_at",
-      },
-      platform: {
-        type: DataTypes.ENUM("fb", "tt", "snp"),
-        allowNull: false,
-        defaultValue: "fb",
-        field: "platform",
-        comment: "Ad platform identifier: fb=Facebook, tt=TikTok, snp=Snapchat",
-      },
-    },
-    {
-      tableName: "facebook_retry_queue",
-      timestamps: false,
-      indexes: [
-        {
-          fields: ["status", "next_retry_at"],
-          name: "idx_fb_retry_status_next",
-        },
-        {
-          fields: ["process_id"],
-        },
-        {
-          fields: ["feed_provider"],
-        },
-        {
-          fields: ["created_at"],
-        },
-      ],
-    }
-  );
-
-  FacebookRetryQueue.associate = (models) => {
-    // No associations needed
-  };
-
-  return FacebookRetryQueue;
-};

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

@@ -1,34 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const Feed = sequelize.define(
-      "Feed",
-      {
-        id: {
-          type: DataTypes.UUID,
-          defaultValue: DataTypes.UUIDV4,
-          primaryKey: true,
-        },
-        label: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        code: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          unique: true,
-        },
-        sheet: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        feedProvider: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-      },
-      {
-        tableName: "Feed",
-      }
-    );
-  
-    return Feed;
-  };

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

@@ -1,81 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const FeedArticleConfiguration = sequelize.define(
-      "FeedArticleConfiguration",
-      {
-        id: {
-          type: DataTypes.INTEGER,
-          primaryKey: true,
-          autoIncrement: true,
-        },
-        feedProvider: {
-          type: DataTypes.STRING(100),
-          allowNull: false,
-          unique: true,
-          field: "feed_provider",
-        },
-        requiredFields: {
-          type: DataTypes.JSONB,
-          allowNull: false,
-          defaultValue: [],
-          field: "required_fields",
-          comment: "Array of field configs: [{ name, description, allowedValues }]"
-        },
-        model: {
-          type: DataTypes.STRING(50),
-          allowNull: false,
-          defaultValue: "gpt-4o-mini",
-          comment: "OpenAI model to use for this feed"
-        },
-        temperature: {
-          type: DataTypes.FLOAT,
-          allowNull: false,
-          defaultValue: 0.7,
-          comment: "Temperature for AI generation (0.0-1.0)"
-        },
-        baseUrl: {
-          type: DataTypes.STRING(500),
-          allowNull: true,
-          field: "base_url",
-        },
-        isActive: {
-          type: DataTypes.BOOLEAN,
-          allowNull: false,
-          defaultValue: true,
-          field: "is_active",
-        },
-        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: "feed_article_configurations",
-        timestamps: true,
-        createdAt: "created_at",
-        updatedAt: "updated_at",
-        indexes: [
-          {
-            unique: true,
-            fields: ["feed_provider"],
-          },
-          {
-            fields: ["is_active"],
-          },
-        ],
-      }
-    );
-  
-    FeedArticleConfiguration.associate = (models) => {
-      // Future: Add associations if needed
-    };
-  
-    return FeedArticleConfiguration;
-  };

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

@@ -1,73 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Files = sequelize.define("Files", {
-    id: {
-      type: DataTypes.STRING,
-      primaryKey: true,
-    },
-    accounts: {
-      type: DataTypes.JSONB(),
-      allowNull: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    type: {
-      type: DataTypes.STRING, // Can be "image" or "video"
-      allowNull: false,
-    },
-    adAccountId: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    adId: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-
-    URL: {
-      type: DataTypes.STRING, // URL for the file
-      allowNull: false,
-    },
-    ParentFolder: {
-      type: DataTypes.STRING, // Folder ID for the parent folder
-      allowNull: true, // This allows the file to exist without a folder
-    },
-    ParentFolders: {
-      type: DataTypes.ARRAY(DataTypes.STRING),
-      allowNull: true,
-    },
-    FileType: {
-      type: DataTypes.STRING,
-      allowNull: true,
-      defaultValue: "txt",
-    },
-    Size: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    Language: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-    Vertical: {
-      type: DataTypes.STRING,
-      allowNull: true,
-    },
-  });
-
-  return Files;
-};
-
-/*
-[
-    {
-      accountId: kkelks,
-      id: klflf
-    },
-    {
-      accountId: kkejkjklks,
-      id: klflhhkf
-    },
-]
-*/

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

@@ -1,133 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Folders = sequelize.define("Folders", {
-    id: {
-      type: DataTypes.STRING,
-      primaryKey: true,
-    },
-    ParentFolder: {
-      type: DataTypes.STRING, // Self-referencing folder ID
-      allowNull: true,
-    },
-    ParentFolders: {
-      type: DataTypes.ARRAY(DataTypes.STRING), // Array of folder IDs
-      allowNull: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    FilesCount: {
-      type: DataTypes.INTEGER,
-      allowNull: true,
-      defaultValue: 0,
-    }
-  });
-
-  Folders.associate = function (models) {
-    // One-to-many: A folder can have many files
-    Folders.hasMany(models.Files, { foreignKey: "ParentFolder", sourceKey: "id" });
-
-    // Self-referencing: A folder can have subfolders
-    Folders.hasMany(models.Folders, { foreignKey: "ParentFolder", sourceKey: "id" });
-    Folders.belongsTo(models.Folders, { foreignKey: "ParentFolder", targetKey: "id" });
-  };
-
-  // Function to count files and subfolders for each parent folder in ParentFolders array
-  Folders.countFilesAndSubfolders = async function (parentFolderIds) {
-    try {
-      const { Files } = sequelize.models; // Move the reference inside the function
-      
-      // Loop through each parent folder ID
-      for (const parentFolderId of parentFolderIds) {
-        // Find the parent folder by ID
-        const parentFolder = await Folders.findOne({ where: { id: parentFolderId } });
-
-        if (!parentFolder) {
-          console.warn(`Folder with ID ${parentFolderId} not found.`);
-          continue;
-        }
-
-        // Count the number of files directly under this folder
-        const fileCount = await Files.count({
-          where: { ParentFolder: parentFolder.id }
-        });
-
-        // Count the number of subfolders directly under this folder
-        const subfolderCount = await Folders.count({
-          where: { ParentFolder: parentFolder.id }
-        });
-
-        // Total count is files + subfolders
-        const totalFilesCount = fileCount + subfolderCount;
-
-        // Update the FilesCount field in the parent folder
-        await parentFolder.update({ FilesCount: totalFilesCount });
-      }
-    } catch (error) {
-      console.error(error);
-      throw error;
-    }
-  };
-
-  // Add a hook that triggers after a folder is created, updated, or deleted
-  Folders.addHook('afterCreate', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  Folders.addHook('afterDestroy', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  Folders.addHook('afterUpdate', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  // Add hooks for Files
-  sequelize.models.Files.addHook('afterCreate', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-  sequelize.models.Files.addHook('afterDestroy', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-  sequelize.models.Files.addHook('afterUpdate', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-    // Add a hook before saving the folder to check ParentFolders
-  Folders.addHook('beforeSave', (folder, options) => {
-    // If ParentFolders is an empty array or contains only nulls, set it to null
-    if (folder.ParentFolders && (folder.ParentFolders.length === 0 || folder.ParentFolders.every(f => f === null))) {
-      folder.ParentFolders = null;
-    }
-  });
-
-  // You can also add this hook for files
-  sequelize.models.Files.addHook('beforeSave', (file, options) => {
-    // If ParentFolders is an empty array or contains only nulls, set it to null
-    if (file.ParentFolders && (file.ParentFolders.length === 0 || file.ParentFolders.every(f => f === null))) {
-      file.ParentFolders = null;
-    }
-  });
-
-  return Folders;
-};

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

@@ -1,60 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const FrontStoryChannel = sequelize.define(
-      "FrontStoryChannel",
-      {
-        channelId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          // Not setting as primary key or unique since duplicates are allowed
-        },
-        channelName: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: 'Human-readable name for the channel'
-        },
-        styleId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        status: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          defaultValue: "free",
-          validate: {
-            isIn: [["free", "used", "archived"]],
-          },
-        },
-        connectedCampaigns: {
-          type: DataTypes.JSONB, // Use JSONB for better querying capabilities
-          allowNull: false,
-          defaultValue: [],
-        },
-      },
-      {
-        tableName: "front_story_channels",
-        timestamps: true,
-        // indexes: [
-        //   // Add a composite unique index on channelId and styleId if needed
-        //   {
-        //     unique: true,
-        //     fields: ["channelId", "styleId"],
-        //     name: "unique_front_story_channel_style",
-        //   },
-        // ],
-      }
-    );
-  
-    // Define associations without enforcing constraints
-    FrontStoryChannel.associate = (models) => {
-      if (models.RSOCFeedCampaign) {
-        FrontStoryChannel.hasMany(models.RSOCFeedCampaign, {
-          foreignKey: "channelId",
-          sourceKey: "channelId",
-          as: "RSOCFeedCampaigns",
-          constraints: false, // Disable FK constraint
-        });
-      }
-    };
-  
-    return FrontStoryChannel;
-  };

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

@@ -1,60 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const FrontStoryChannelV2 = sequelize.define(
-      "FrontStoryChannelV2",
-      {
-        channelId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          // Not setting as primary key or unique since duplicates are allowed
-        },
-        channelName: {
-          type: DataTypes.STRING,
-          allowNull: true,
-          comment: 'Human-readable name for the channel'
-        },
-        styleId: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        status: {
-          type: DataTypes.STRING,
-          allowNull: false,
-          defaultValue: "free",
-          validate: {
-            isIn: [["free", "used", "archived"]],
-          },
-        },
-        connectedCampaigns: {
-          type: DataTypes.JSONB, // Use JSONB for better querying capabilities
-          allowNull: false,
-          defaultValue: [],
-        },
-      },
-      {
-        tableName: "front_story_channels_v2",
-        timestamps: true,
-        // indexes: [
-        //   // Add a composite unique index on channelId and styleId if needed
-        //   {
-        //     unique: true,
-        //     fields: ["channelId", "styleId"],
-        //     name: "unique_front_story_channel_v2_style",
-        //   },
-        // ],
-      }
-    );
-  
-    // Define associations without enforcing constraints
-    FrontStoryChannelV2.associate = (models) => {
-      if (models.RSOCFeedCampaign) {
-        FrontStoryChannelV2.hasMany(models.RSOCFeedCampaign, {
-          foreignKey: "channelId",
-          sourceKey: "channelId",
-          as: "RSOCFeedCampaigns",
-          constraints: false, // Disable FK constraint
-        });
-      }
-    };
-  
-    return FrontStoryChannelV2;
-  };