operand-meta-sdk 1.2.1

package/src/modules/insights/ing-insights.ts

@@ -0,0 +1,275 @@
+import { ConstructorIng } from "../../interfaces/ing-publish";
+import {
+  GetFollowersCountResponseCurrent,
+  GetInsightsAccountsEngagedResponse,
+  GetInsightsPageFollowersAndUnFollowersResponse,
+  GetInsightsResponse,
+} from "../../interfaces/meta-response";
+import { addDays, differenceInDays } from "date-fns";
+import { IngComments } from "../comments/ing-comments";
+import { formatInTimeZone } from "date-fns-tz";
+import Axios from "axios";
+
+export class IngInsights extends IngComments {
+  constructor(constructorIng: ConstructorIng) {
+    super({
+      ...constructorIng,
+      isInstagramApi: constructorIng.typeToken === "ig",
+    });
+  }
+
+  private generateSinceAndUntil(startDate: Date, endDate: Date) {
+    const nextDay = addDays(endDate, 1);
+
+    return {
+      since: formatInTimeZone(startDate, "UTC", "yyyy-MM-dd"),
+      until: formatInTimeZone(nextDay, "UTC", "yyyy-MM-dd"),
+    };
+  }
+
+  private async generateWhileLoopToGetLikesAndCommentsAndShares(
+    startDate: Date,
+    endDate: Date,
+    metric: "likes" | "comments" | "shares",
+  ): Promise<{ value: number; end_time?: string }[]> {
+    const results: { value: number; end_time?: string }[] = [];
+
+    let currentDate = startDate;
+
+    while (currentDate <= endDate) {
+      const response = await this.api.get<GetInsightsResponse>(
+        `/${this.ingId}/insights`,
+        {
+          params: {
+            metric,
+            period: "day",
+            metric_type: "total_value",
+            ...this.generateSinceAndUntil(currentDate, currentDate),
+            access_token: this.pageAccessToken,
+          },
+        },
+      );
+
+      const value = response.data.data[0]?.total_value?.value || 0;
+      const endTime = response.data.data[0]?.values?.[0]?.end_time;
+
+      results.push({ value, end_time: endTime });
+
+      currentDate = addDays(currentDate, 1);
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    return results;
+  }
+
+  public async getFollowersCountCurrent() {
+    return (
+      await this.api.get<GetFollowersCountResponseCurrent>(`/${this.ingId}`, {
+        params: {
+          fields: "followers_count",
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.followers_count;
+  }
+
+  public async getDayFollowersByDateInterval(startDate: Date, endDate: Date) {
+    const response = await this.api.get<GetInsightsResponse>(
+      `/${this.ingId}/insights`,
+      {
+        params: {
+          metric: "follower_count",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      },
+    );
+
+    return response.data.data?.[0]?.values?.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayUnFollowersByDateInterval(startDate: Date, endDate: Date) {
+    const response =
+      await this.api.get<GetInsightsPageFollowersAndUnFollowersResponse>(
+        `/${this.ingId}/insights`,
+        {
+          params: {
+            metric: "follows_and_unfollows",
+            metric_type: "total_value",
+            period: "day",
+            ...this.generateSinceAndUntil(startDate, endDate),
+            access_token: this.pageAccessToken,
+          },
+        },
+      );
+
+    return response.data.data?.[0]?.values?.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayAllViews(startDate: Date, endDate: Date) {
+    const days = differenceInDays(endDate, startDate);
+    const viewsArray: { [a: string]: number }[] = [];
+    let next: string | undefined = undefined;
+
+    for (let index = 0; index <= days; index++) {
+      const response = next
+        ? await Axios.get<GetInsightsAccountsEngagedResponse>(next)
+        : await this.api.get<GetInsightsAccountsEngagedResponse>(
+            `/${this.ingId}/insights`,
+            {
+              params: {
+                metric: "views",
+                metric_type: "total_value",
+                period: "day",
+                since: formatInTimeZone(startDate, "UTC", "yyyy-MM-dd"),
+                until: formatInTimeZone(
+                  addDays(startDate, 1),
+                  "UTC",
+                  "yyyy-MM-dd",
+                ),
+                access_token: this.pageAccessToken,
+              },
+            },
+          );
+
+      const { data, paging } = response.data;
+
+      viewsArray.push({
+        [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+          Number(data?.[0]?.total_value?.value || 0),
+      });
+
+      next = paging?.next;
+    }
+
+    return viewsArray;
+  }
+
+  public async getDayAllReaches(startDate: Date, endDate: Date) {
+    const response = await this.api.get<GetInsightsResponse>(
+      `/${this.ingId}/insights`,
+      {
+        params: {
+          metric: "reach",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      },
+    );
+
+    return response.data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayAllLikesInAllPosts(startDate: Date, endDate: Date) {
+    return this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "likes",
+    );
+  }
+
+  public async getDayAllCommentsInAllPosts(startDate: Date, endDate: Date) {
+    return this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "comments",
+    );
+  }
+
+  public async getDayAllSharesInAllPosts(startDate: Date, endDate: Date) {
+    return this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "shares",
+    );
+  }
+
+  public async getTotalLikesInAllPosts(startDate: Date, endDate: Date) {
+    const values = await this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "likes",
+    );
+
+    return values.reduce((acc, curr) => acc + curr.value, 0);
+  }
+
+  public async getTotalCommentsInAllPosts(startDate: Date, endDate: Date) {
+    const values = await this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "comments",
+    );
+
+    return values.reduce((acc, curr) => acc + curr.value, 0);
+  }
+
+  public async getTotalSharesInAllPosts(startDate: Date, endDate: Date) {
+    const values = await this.generateWhileLoopToGetLikesAndCommentsAndShares(
+      startDate,
+      endDate,
+      "shares",
+    );
+
+    return values.reduce((acc, curr) => acc + curr.value, 0);
+  }
+
+  public async getTotalInteractionsInAllPosts(startDate: Date, endDate: Date) {
+    const likes = await this.getTotalLikesInAllPosts(startDate, endDate);
+    const comments = await this.getTotalCommentsInAllPosts(startDate, endDate);
+    const shares = await this.getTotalSharesInAllPosts(startDate, endDate);
+
+    return likes + comments + shares;
+  }
+
+  public async getDayEngagementInAllPosts(startDate: Date, endDate: Date) {
+    const days = differenceInDays(endDate, startDate);
+    const engagementArray: { [a: string]: number }[] = [];
+    let next: string | undefined = undefined;
+
+    for (let index = 0; index <= days; index++) {
+      const response = next
+        ? await Axios.get<GetInsightsAccountsEngagedResponse>(next)
+        : await this.api.get<GetInsightsAccountsEngagedResponse>(
+            `/${this.ingId}/insights`,
+            {
+              params: {
+                metric: "accounts_engaged",
+                metric_type: "total_value",
+                period: "day",
+                since: formatInTimeZone(startDate, "UTC", "yyyy-MM-dd"),
+                until: formatInTimeZone(
+                  addDays(startDate, 1),
+                  "UTC",
+                  "yyyy-MM-dd",
+                ),
+                access_token: this.pageAccessToken,
+              },
+            },
+          );
+
+      const { data, paging } = response.data;
+
+      engagementArray.push({
+        [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+          Number(data?.[0]?.total_value?.value || 0),
+      });
+
+      next = paging?.next;
+    }
+
+    return engagementArray;
+  }
+}

package/src/modules/insights/mkt-insights.ts

@@ -0,0 +1,68 @@
+import { Meta } from "../meta";
+import { AdMetrics, AdMetricsResponse } from "../../interfaces/meta-response";
+import { addDays } from "date-fns";
+import { ConstructorMkt } from "../../interfaces/meta-mkt";
+import { formatInTimeZone } from "date-fns-tz";
+
+export class MktInsights extends Meta {
+  protected readonly adAAccountId: string;
+
+  constructor(constructorMkt: ConstructorMkt) {
+    super(constructorMkt);
+    this.adAAccountId = constructorMkt.adAAccountId;
+  }
+
+  private generateSinceAndUntil(startDate: Date, endDate: Date) {
+    return {
+      time_range: {
+        since: formatInTimeZone(startDate, "UTC", "yyyy-MM-dd"),
+        until: formatInTimeZone(endDate, "UTC", "yyyy-MM-dd"),
+      },
+    };
+  }
+
+  public async getDayPaidReaches(
+    startDate: Date,
+    endDate: Date,
+    platform: string,
+  ) {
+    const reachArray: AdMetrics[] = [];
+    let afterCursor: string | undefined = undefined;
+    let hasNextPage = true;
+
+    while (hasNextPage) {
+      const response = await this.api.get<AdMetricsResponse>(
+        `/${this.adAAccountId}/insights`,
+        {
+          params: {
+            ...this.generateSinceAndUntil(startDate, endDate),
+            time_increment: 1,
+            fields: "reach",
+            breakdowns: "publisher_platform",
+            access_token: this.pageAccessToken,
+            filtering: [
+              {
+                field: "publisher_platform",
+                operator: "IN",
+                value: [platform],
+              },
+            ],
+            after: afterCursor,
+          },
+        },
+      );
+
+      const { data, paging } = response.data;
+
+      reachArray.push(...data);
+
+      afterCursor = paging?.cursors?.after;
+      hasNextPage = Boolean(afterCursor);
+    }
+
+    return reachArray.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        Number(value.reach || 0),
+    }));
+  }
+}

package/src/modules/insights/page-insights.ts

@@ -0,0 +1,267 @@
+import { ConstructorPage } from "../../interfaces/page-publish";
+import {
+  GetInsightsResponse,
+  GetFollowersCountResponseCurrent,
+  GetInsightsPageActionsPostReactionsTotalResponse,
+  PostComment,
+  GetPostCommentsResponse,
+} from "../../interfaces/meta-response";
+import { addDays, endOfDay, isSameDay, startOfDay, subDays } from "date-fns";
+import { formatInTimeZone, toZonedTime } from "date-fns-tz";
+import { PageComments } from "../comments/page-comments";
+
+export class PageInsights extends PageComments {
+  constructor(constructorPage: ConstructorPage) {
+    super(constructorPage);
+  }
+
+  private splitArrayPromises(
+    arrayPromises: (() => Promise<void>)[],
+    size: number,
+  ) {
+    const arrayPromisesSplited: (() => Promise<void>)[][] = [];
+
+    for (let i = 0; i < arrayPromises.length; i += size) {
+      arrayPromisesSplited.push(arrayPromises.slice(i, i + size));
+    }
+
+    return arrayPromisesSplited;
+  }
+
+  private generateSinceAndUntil(startDate: Date, endDate: Date) {
+    const nextDay = addDays(endDate, 1);
+
+    return {
+      since: formatInTimeZone(startDate, "UTC", "yyyy-MM-dd"),
+      until: formatInTimeZone(nextDay, "UTC", "yyyy-MM-dd"),
+    };
+  }
+
+  public async getFollowersCountCurrent() {
+    return (
+      await this.api.get<GetFollowersCountResponseCurrent>(`/${this.pageId}`, {
+        params: {
+          fields: "followers_count",
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.followers_count;
+  }
+
+  public async getDayTotalFollowersByDateInterval(
+    startDate: Date,
+    endDate: Date,
+  ) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_follows",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayFollowersByDateInterval(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_daily_follows_unique",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayUnFollowersByDateInterval(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_daily_unfollows_unique",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayAllImpressions(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_impressions",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayAllImpressionsUnique(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_impressions_unique",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayPaidImpressionsUnique(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_impressions_paid_unique",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+
+  public async getDayAllLikesTypesInAllPosts(startDate: Date, endDate: Date) {
+    const response =
+      await this.api.get<GetInsightsPageActionsPostReactionsTotalResponse>(
+        `/${this.pageId}/insights/page_actions_post_reactions_total`,
+        {
+          params: {
+            period: "day",
+            ...this.generateSinceAndUntil(startDate, endDate),
+            access_token: this.pageAccessToken,
+          },
+        },
+      );
+
+    return response.data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        (value?.value.anger || 0) +
+        (value?.value.haha || 0) +
+        (value?.value.like || 0) +
+        (value?.value.love || 0) +
+        (value?.value.sorry || 0) +
+        (value?.value.wow || 0),
+    }));
+  }
+
+  public async getTotalAllLikesTypesInAllPosts(startDate: Date, endDate: Date) {
+    const values = await this.getDayAllLikesTypesInAllPosts(startDate, endDate);
+
+    return values.reduce((acc, value) => acc + Object.values(value)[0], 0);
+  }
+
+  public async getDayAllCommentsInAllPosts(startDate: Date, endDate: Date) {
+    startDate = startOfDay(toZonedTime(startDate, "UTC"));
+    endDate = endOfDay(toZonedTime(endDate, "UTC"));
+
+    const allIds = (await this.getAllPosts()).map((post) => post.id);
+
+    const values: PostComment[] = [];
+
+    const arrayPromises = allIds.map((id) => {
+      return async () => {
+        let nextUrl = `${this.api.getUri()}/${id}/comments?order=reverse_chronological&access_token=${this.pageAccessToken}`;
+
+        while (nextUrl) {
+          const response = (await (
+            await fetch(nextUrl)
+          ).json()) as GetPostCommentsResponse;
+
+          values.push(
+            ...response.data.filter((value) => {
+              const date = new Date(value.created_time);
+
+              return date >= startDate && date <= endDate;
+            }),
+          );
+
+          const isValidNext =
+            response.paging?.next && this.isValidUrl(response.paging.next);
+
+          const lastObjectDate = response.data[response.data.length - 1]
+            ?.created_time
+            ? new Date(response.data[response.data.length - 1].created_time)
+            : null;
+
+          if (
+            !isValidNext ||
+            !response.data.length ||
+            (lastObjectDate >= startDate && lastObjectDate <= endDate)
+          ) {
+            nextUrl = "";
+            break;
+          }
+
+          nextUrl = response.paging.next;
+        }
+      };
+    });
+
+    const splitArrayPromises = this.splitArrayPromises(arrayPromises, 50);
+
+    for (const arrayPromises of splitArrayPromises) {
+      await Promise.all(arrayPromises.map((promise) => promise()));
+    }
+
+    const qtdDays = subDays(endDate, startDate.getDate()).getDate();
+
+    const valuesNumber: number[] = [];
+
+    for (let i = 0; i <= qtdDays; i++) {
+      const currentDay = addDays(startDate, i);
+
+      const comments = values.filter((value) => {
+        const date = new Date(value.created_time);
+
+        return isSameDay(date, currentDay);
+      });
+
+      valuesNumber.push(comments.length);
+    }
+
+    return valuesNumber;
+  }
+
+  public async getDayEngagementInAllPosts(startDate: Date, endDate: Date) {
+    return (
+      await this.api.get<GetInsightsResponse>(`/${this.pageId}/insights`, {
+        params: {
+          metric: "page_post_engagements",
+          period: "day",
+          ...this.generateSinceAndUntil(startDate, endDate),
+          access_token: this.pageAccessToken,
+        },
+      })
+    ).data.data[0].values.map((value, index) => ({
+      [formatInTimeZone(addDays(startDate, index), "UTC", "yyyy-MM-dd")]:
+        value.value,
+    }));
+  }
+}

package/src/modules/meta-ing.ts

@@ -0,0 +1,8 @@
+import { ConstructorIng } from "../interfaces/ing-publish";
+import { IngInsights } from "./insights/ing-insights";
+
+export class MetaIng extends IngInsights {
+  constructor(constructorPage: ConstructorIng) {
+    super(constructorPage);
+  }
+}

package/src/modules/meta-mkt.ts

@@ -0,0 +1,8 @@
+import { ConstructorMkt } from "../interfaces/meta-mkt";
+import { MktInsights } from "./insights/mkt-insights";
+
+export class MetaMkt extends MktInsights {
+  constructor(constructorPage: ConstructorMkt) {
+    super(constructorPage);
+  }
+}

package/src/modules/meta-page.ts

@@ -0,0 +1,8 @@
+import { ConstructorPage } from "../interfaces/page-publish";
+import { PageInsights } from "./insights/page-insights";
+
+export class MetaPage extends PageInsights {
+  constructor(constructorPage: ConstructorPage) {
+    super(constructorPage);
+  }
+}

package/src/modules/meta.ts

@@ -0,0 +1,31 @@
+import { ConstructorMain } from "../interfaces/meta";
+import { generateAxiosInstance } from "../utils/api";
+import { AxiosInstance } from "axios";
+import * as fs from "fs";
+import * as path from "path";
+
+export class Meta {
+  protected readonly pageAccessToken: string;
+  protected readonly api: AxiosInstance;
+  protected readonly apiVideo: AxiosInstance;
+  protected readonly apiIng: AxiosInstance;
+
+  protected async createTempFolder() {
+    await fs.promises.mkdir(path.resolve(__dirname, "..", "temp"), {
+      recursive: true,
+    });
+  }
+
+  constructor({
+    pageAccessToken,
+    apiVersion,
+    isInstagramApi,
+  }: ConstructorMain) {
+    this.pageAccessToken = pageAccessToken;
+    this.api = generateAxiosInstance({
+      apiVersion,
+      isInstagramApi,
+    });
+    this.apiVideo = generateAxiosInstance({ apiVersion, isVideoApi: true });
+  }
+}