operand-meta-sdk 1.2.1

package/src/interfaces/page-publish.ts

@@ -0,0 +1,72 @@
+import { ConstructorMain } from "./meta";
+import { PagePost } from "./meta-response";
+
+export type PhotoMediaItem = {
+  source: "url" | "path";
+  value: string;
+};
+
+export type VideoMediaItem = {
+  source: "url" | "path";
+  value: string;
+};
+
+export type CreatePost = {
+  mediaType?: "photo" | "video";
+  message?: string;
+  publishNow: boolean;
+  datePublish?: Date;
+  photos?: PhotoMediaItem[];
+  video?: VideoMediaItem;
+};
+
+type CreateStoriesPath = {
+  source: "path";
+  mediaType: "photo" | "video";
+  path: string;
+};
+
+type CreateStoriesUrl = {
+  source: "url";
+  mediaType: "photo" | "video";
+  url: string;
+};
+
+export type CreateStories = CreateStoriesPath | CreateStoriesUrl;
+
+type CreateReelsPath = {
+  source: "path";
+  path: string;
+  title?: string;
+  description?: string;
+};
+
+type CreateReelsUrl = {
+  source: "url";
+  url: string;
+  title?: string;
+  description?: string;
+};
+
+export type CreateReels = CreateReelsPath | CreateReelsUrl;
+
+export type SetThumbnailToReels = {
+  source: "url" | "path";
+  value: string;
+  videoId: string;
+};
+
+export interface ConstructorPage extends ConstructorMain {
+  pageId: string;
+}
+
+export interface IPagePublish {
+  getAllPosts(): Promise<PagePost[]>;
+  getPostUrlById(postId: string): string;
+  createPost(data: CreatePost): Promise<string>;
+  updatePost(postId: string, message: string): Promise<boolean>;
+  deletePost(postId: string): Promise<boolean>;
+  createStories(data: CreateStories): Promise<string>;
+  createReels(data: CreateReels): Promise<{ postId: string; videoId: string }>;
+  setThumbnailToReels(data: SetThumbnailToReels): Promise<{ success: boolean }>;
+}

package/src/modules/auth/meta-auth.spec.ts

@@ -0,0 +1,93 @@
+import axios from "axios";
+import { MetaAuth } from "./meta-auth";
+import { ApiVersion, CreateMetaAuth } from "@/interfaces/meta-auth";
+
+jest.mock("axios");
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe("Module MetaAuth", () => {
+  describe("createAccessToken", () => {
+    it("should make a request to /oauth/access_token and return the access token", async () => {
+      const requestData: CreateMetaAuth = {
+        client_id: "test-client-id",
+        client_secret: "test-client-secret",
+        redirect_uri: "https://example.com/callback",
+        apiVersion: "v21.0",
+        code: "test-code",
+      };
+
+      const mockAccessTokenResponse = {
+        data: {
+          access_token: "mocked-access-token",
+        },
+      };
+
+      mockedAxios.create.mockReturnValue(mockedAxios);
+      const mockPost = mockedAxios.post.mockResolvedValue(
+        mockAccessTokenResponse,
+      );
+
+      const accessToken = await MetaAuth.createAccessTokenFb(requestData);
+
+      expect(accessToken).toEqual({
+        accessToken: "mocked-access-token",
+        getAccounts: expect.any(Function),
+      });
+
+      expect(mockedAxios.post).toHaveBeenCalledWith("/oauth/access_token", {
+        client_id: requestData.client_id,
+        client_secret: requestData.client_secret,
+        code: requestData.code,
+        redirect_uri: requestData.redirect_uri,
+      });
+
+      expect(mockPost).toHaveBeenCalled();
+      expect(mockPost).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("getAccounts", () => {
+    it("should make a request to /me/accounts and return the accounts", async () => {
+      const requestData = {
+        fields: ["id", "name"],
+        accessToken: "test-access-token",
+        apiVersion: "v21.0" as ApiVersion,
+      };
+
+      const mockGetPageAccountsResponse = {
+        data: {
+          data: [
+            {
+              id: "test-page-id",
+              name: "Test Page",
+            },
+          ],
+        },
+      };
+
+      mockedAxios.create.mockReturnValue(mockedAxios);
+      const mockGet = mockedAxios.get.mockResolvedValue(
+        mockGetPageAccountsResponse,
+      );
+
+      const accounts = await MetaAuth.getAccountsWithFbToken(requestData);
+
+      expect(accounts).toEqual([
+        {
+          id: "test-page-id",
+          name: "Test Page",
+        },
+      ]);
+
+      expect(mockedAxios.get).toHaveBeenCalledWith("/me/accounts", {
+        params: {
+          access_token: requestData.accessToken,
+          fields: requestData.fields.join(","),
+        },
+      });
+
+      expect(mockGet).toHaveBeenCalled();
+      expect(mockGet).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/modules/auth/meta-auth.ts

@@ -0,0 +1,227 @@
+import {
+  ApiVersion,
+  CreateMetaAuth,
+  FieldsPage,
+  GetAccounts,
+} from "../../interfaces/meta-auth";
+import {
+  CreateAccessTokenResponse,
+  FacebookAdAccount,
+  FacebookPage,
+  GetAlongTokenMetaResponse,
+  GetPageAccountsResponse,
+  InstagramAccount,
+} from "../../interfaces/meta-response";
+import { generateAxiosInstance } from "../../utils/api";
+
+export class MetaAuth {
+  public static async createAccessTokenIg({
+    client_id,
+    client_secret,
+    redirect_uri,
+    apiVersion,
+    code,
+  }: CreateMetaAuth) {
+    const api = generateAxiosInstance({
+      apiVersion: "v21.0",
+      isInstagramAccessToken: true,
+    });
+
+    const data = new URLSearchParams();
+
+    data.append("client_id", client_id);
+    data.append("client_secret", client_secret);
+    data.append("grant_type", "authorization_code");
+    data.append("redirect_uri", redirect_uri);
+    data.append("code", code);
+
+    const accessToken = (
+      await api.post<CreateAccessTokenResponse>(`/oauth/access_token`, data)
+    ).data;
+
+    return {
+      accessToken: accessToken.access_token,
+      getAccounts: ({ fields }: { fields: FieldsPage }) => {
+        return MetaAuth.getAccountsWithIgToken({
+          fields,
+          accessToken: accessToken.access_token,
+          apiVersion,
+        });
+      },
+    };
+  }
+
+  public static async createAccessTokenFb({
+    client_id,
+    client_secret,
+    redirect_uri,
+    apiVersion,
+    code,
+  }: CreateMetaAuth) {
+    const api = generateAxiosInstance({ apiVersion });
+
+    const shortAccessToken = (
+      await api.post<CreateAccessTokenResponse>(`/oauth/access_token`, {
+        client_id,
+        client_secret,
+        code,
+        redirect_uri,
+      })
+    ).data.access_token;
+
+    const longAccessToken = await this.extendUserAccessToken({
+      client_id,
+      client_secret,
+      accessToken: shortAccessToken,
+      apiVersion,
+    });
+
+    return {
+      accessToken: longAccessToken,
+      getAccounts: ({ fields }: { fields: FieldsPage }) => {
+        return MetaAuth.getAccountsWithFbToken({
+          fields,
+          accessToken: longAccessToken,
+          apiVersion,
+        });
+      },
+      getAdAccounts: () => {
+        return MetaAuth.getAdAccounts({
+          accessToken: longAccessToken,
+          apiVersion,
+        });
+      },
+    };
+  }
+
+  public static async extendUserAccessToken({
+    client_id,
+    client_secret,
+    accessToken,
+    apiVersion,
+  }: {
+    client_id: string;
+    client_secret: string;
+    accessToken: string;
+    apiVersion: ApiVersion;
+  }) {
+    const api = generateAxiosInstance({ apiVersion });
+
+    const response = await api.get<GetAlongTokenMetaResponse>(
+      "/oauth/access_token",
+      {
+        params: {
+          grant_type: "fb_exchange_token",
+          client_id,
+          client_secret,
+          fb_exchange_token: accessToken,
+        },
+      },
+    );
+
+    return response.data.access_token;
+  }
+
+  public static async getAccountsWithFbToken({
+    fields,
+    accessToken,
+    apiVersion,
+  }: GetAccounts): Promise<FacebookPage[]> {
+    const api = generateAxiosInstance({ apiVersion });
+
+    const allAccounts: FacebookPage[] = [];
+    let afterCursor: string | undefined = undefined;
+    let hasNextPage = true;
+
+    while (hasNextPage) {
+      const response = await api.get<GetPageAccountsResponse>(`/me/accounts`, {
+        params: {
+          access_token: accessToken,
+          fields: fields.join(","),
+          after: afterCursor,
+        },
+      });
+
+      const { data, paging } = response.data;
+      allAccounts.push(...data);
+
+      afterCursor = paging?.cursors?.after;
+      hasNextPage = Boolean(afterCursor);
+    }
+
+    return allAccounts;
+  }
+
+  public static async getAccountsWithIgToken({
+    fields,
+    accessToken,
+    apiVersion,
+  }: GetAccounts): Promise<InstagramAccount> {
+    const api = generateAxiosInstance({ apiVersion, isInstagramApi: true });
+
+    return (
+      await api.get<InstagramAccount>(`/me`, {
+        params: {
+          access_token: accessToken,
+          fields: fields.join(","),
+        },
+      })
+    ).data;
+  }
+
+  public static async getAdAccounts({
+    accessToken,
+    apiVersion,
+  }: Omit<GetAccounts, "fields">): Promise<FacebookPage[]> {
+    const api = generateAxiosInstance({ apiVersion });
+
+    return (
+      await api.get<FacebookAdAccount>(`/me/adaccounts`, {
+        params: {
+          access_token: accessToken,
+        },
+      })
+    ).data.data;
+  }
+
+  public static async generateIgLongToken({
+    accessToken,
+    apiVersion,
+    clientSecret,
+  }: {
+    accessToken: string;
+    apiVersion: ApiVersion;
+    clientSecret: string;
+  }): Promise<string> {
+    const api = generateAxiosInstance({ apiVersion, isInstagramApi: true });
+
+    return (
+      await api.get<GetAlongTokenMetaResponse>("/access_token", {
+        params: {
+          client_secret: clientSecret,
+          access_token: accessToken,
+          grant_type: "ig_exchange_token",
+        },
+      })
+    ).data.access_token;
+  }
+
+  public static async generateIgRefreshToken({
+    accessToken,
+    apiVersion,
+  }: {
+    accessToken: string;
+    apiVersion: ApiVersion;
+  }): Promise<string> {
+    const api = generateAxiosInstance({ apiVersion, isInstagramApi: true });
+
+    return (
+      await api.get<GetAlongTokenMetaResponse>("/refresh_access_token", {
+        params: {
+          access_token: accessToken,
+          grant_type: "ig_refresh_token",
+        },
+      })
+    ).data.access_token;
+  }
+}

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

@@ -0,0 +1,38 @@
+import { ConstructorIng } from "../../interfaces/ing-publish";
+import { IngPublish } from "../publish/ing-publish";
+
+export class IngComments extends IngPublish {
+  constructor(constructorIng: ConstructorIng) {
+    super({ ...constructorIng, isInstagramApi: true });
+  }
+
+  public async createComment(postId: string, message: string): Promise<string> {
+    const response = await this.api.post<{ id: string }>(
+      `/${postId}/comments`,
+      {
+        message,
+        access_token: this.pageAccessToken,
+      },
+    );
+
+    return response.data.id;
+  }
+
+  public async updateCommentStatus(
+    postId: string,
+    enabled: boolean,
+  ): Promise<boolean> {
+    await this.api.post(
+      `/${postId}`,
+      {},
+      {
+        params: {
+          comment_enabled: enabled,
+          access_token: this.pageAccessToken,
+        },
+      },
+    );
+
+    return true;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { ConstructorPage } from "../../interfaces/page-publish";
+import { PagePublish } from "../publish/page-publish";
+
+export class PageComments extends PagePublish {
+  constructor(constructorPage: ConstructorPage) {
+    super(constructorPage);
+  }
+
+  public async createComment(postId: string, message: string): Promise<string> {
+    const response = await this.api.post<{ id: string }>(
+      `/${postId}/comments`,
+      {
+        message,
+        access_token: this.pageAccessToken,
+      },
+    );
+
+    return response.data.id;
+  }
+}