@upstart.gg/sdk 0.0.129 → 0.0.131

package/src/shared/datasources/external/facebook/posts/fetcher.ts

@@ -0,0 +1,52 @@
+import { facebookPostSchema, type FacebookPostSchema } from "./schema";
+import type { MetaFullOAuthConfig } from "../../meta/oauth/config";
+import { UnauthorizedError } from "~/shared/errors";
+import type { MetaOptions } from "../../meta/options";
+import { stringifyObjectValues } from "../../../utils";
+import type { DatasourceFetcher } from "~/shared/datasources/fetcher";
+
+const fetchFacebookPostDatasource: DatasourceFetcher<
+  FacebookPostSchema,
+  MetaFullOAuthConfig,
+  MetaOptions
+> = async ({ options, oauth }) => {
+  const params = new URLSearchParams({
+    ...stringifyObjectValues(options),
+    fields: [
+      "from",
+      "permalink_url",
+      "name",
+      "description",
+      "caption",
+      "id",
+      "is_hidden",
+      "message",
+      "application",
+      "object_id",
+      "link",
+      "is_published",
+      "properties",
+      "status_type",
+      "story",
+      "type",
+      "actions",
+      "call_to_action",
+      "child_attachments",
+    ].join(","),
+    access_token: oauth.config.accessToken,
+  });
+
+  const response = await fetch(`https://graph.facebook.com/me/posts?${params}`);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new UnauthorizedError(`fetchFacebookPostDatasource Error: Unauthorized.`);
+    }
+    throw new Error(`fetchFacebookPostDatasource Error: Response status: ${response.status}`);
+  }
+
+  const post = (await response.json()) as FacebookPostSchema;
+  return post;
+};
+
+export default fetchFacebookPostDatasource;

package/src/shared/datasources/external/facebook/posts/sample.ts

@@ -0,0 +1,35 @@
+import type { FacebookPostSchema } from "./schema";
+
+export const sample = {
+  data: [
+    {
+      from: {
+        name: "Facebook",
+        id: "20531316728",
+      },
+      id: "20531316728_10154052815206729",
+      permalink_url: "https://www.facebook.com/facebook/posts/10154052815206729",
+      is_hidden: false,
+      message: "Great photo!",
+      object_id: "10154052815196729",
+      link: "https://www.facebook.com/photo.php?fbid=10154052815196729&set=a.10150278999681729.345701.20531316728&type=3",
+      is_published: true,
+      status_type: "added_photos",
+      type: "photo",
+      actions: [
+        {
+          name: "Comment",
+          link: "https://www.facebook.com/20531316728/posts/10154052815206729",
+        },
+        {
+          name: "Like",
+          link: "https://www.facebook.com/20531316728/posts/10154052815206729",
+        },
+      ],
+    },
+  ],
+  paging: {
+    next: "url",
+    previous: "url",
+  },
+} satisfies FacebookPostSchema;

package/src/shared/datasources/external/facebook/posts/schema.ts

@@ -0,0 +1,33 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const facebookPostSchema = Type.Object({
+  data: Type.Array(
+    Type.Object({
+      from: Type.Object({
+        name: Type.String(),
+        id: Type.String(),
+      }),
+      id: Type.String(),
+      permalink_url: Type.String(),
+      is_hidden: Type.Boolean(),
+      message: Type.Optional(Type.String()),
+      object_id: Type.String(),
+      link: Type.String(),
+      is_published: Type.Boolean(),
+      status_type: Type.String(),
+      type: Type.String(),
+      actions: Type.Array(
+        Type.Object({
+          name: Type.String(),
+          link: Type.String(),
+        }),
+      ),
+    }),
+  ),
+  paging: Type.Object({
+    previous: Type.Optional(Type.String()),
+    next: Type.Optional(Type.String()),
+  }),
+});
+
+export type FacebookPostSchema = Static<typeof facebookPostSchema>;

package/src/shared/datasources/external/facebook/posts/tests/fetcher.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import fetchFacebookPostDatasource from "../fetcher";
+import { UnauthorizedError } from "~/shared/errors";
+import type { MetaOAuthConfig } from "~/shared/datasources/external/meta/oauth/config";
+import type { MetaOptions } from "~/shared/datasources/external/meta/options";
+import type { DatasourceFetcherParams } from "~/shared/datasources/fetcher";
+
+// Mock the fetch function
+global.fetch = vi.fn();
+
+describe("fetchFacebookPostDatasource", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should fetch Facebook posts successfully", async () => {
+    const mockResponse = {
+      data: [
+        {
+          object_id: "123",
+          id: "123",
+          message: "Test post",
+          from: { name: "Test User", id: "456" },
+          permalink_url: "https://facebook.com/post/123",
+          link: "https://facebook.com/post/123",
+          is_hidden: false,
+          is_published: true,
+          type: "status",
+          status_type: "mobile_status_update",
+          actions: [{ name: "Comment", link: "https://facebook.com/post/123" }],
+        },
+      ],
+      paging: { next: "https://graph.facebook.com/me/posts?after=123" },
+    };
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    // @ts-ignore
+    const result = await fetchFacebookPostDatasource({
+      options: { limit: 10 },
+      oauth: { config: { accessToken: "test-token" } },
+      // @ts-ignore
+      pageAttributes: {
+        id: "me",
+        siteId: "123",
+      },
+    } as DatasourceFetcherParams<MetaOAuthConfig, MetaOptions>);
+
+    expect(result).toEqual(mockResponse);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining("https://graph.facebook.com/me/posts?"),
+    );
+  });
+
+  it("should throw UnauthorizedError on unauthorized response", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+    });
+
+    await expect(
+      // @ts-ignore
+      fetchFacebookPostDatasource({
+        options: { limit: 10 },
+        oauth: { config: { accessToken: "invalid-token" } },
+        pageAttributes: {},
+      } as DatasourceFetcherParams<MetaOAuthConfig, MetaOptions>),
+    ).rejects.toThrow(UnauthorizedError);
+  });
+});

package/src/shared/datasources/external/http-json/fetcher.ts

@@ -0,0 +1,31 @@
+import type { DatasourceFetcher } from "../../fetcher";
+import { createPlaceholderReplacer, placeholderRx } from "../../utils";
+import type { HttpJsonOptions } from "./options";
+
+/**
+ * For this fetcher, validation is done outside of the fetcher.
+ */
+const fetchHttpJSON: DatasourceFetcher<unknown, null, HttpJsonOptions> = async ({
+  options,
+  pageAttributes,
+}) => {
+  const replacer = createPlaceholderReplacer(pageAttributes);
+  const url = options.url.replace(placeholderRx, replacer);
+  const headers: Record<string, string> = {};
+
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers ?? {})) {
+      headers[key] = (value as string).replace(placeholderRx, replacer);
+    }
+  }
+
+  const response = await fetch(url, { headers });
+
+  if (!response.ok) {
+    throw new Error(`fetchHttpJSON Error: Response status: ${response.status}`);
+  }
+
+  return response.json();
+};
+
+export default fetchHttpJSON;

package/src/shared/datasources/external/http-json/options.ts

@@ -0,0 +1,8 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const httpJsonOptions = Type.Object({
+  url: Type.String({ format: "uri" }),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+});
+
+export type HttpJsonOptions = Static<typeof httpJsonOptions>;

package/src/shared/datasources/external/http-json/schema.ts

@@ -0,0 +1,6 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const jsonObjectSchema = Type.Object({}, { additionalProperties: true });
+export const jsonArraySchema = Type.Array(jsonObjectSchema, { title: "Http JSON" });
+
+export type JSONArraySchema = Static<typeof jsonArraySchema>;

package/src/shared/datasources/external/http-json/tests/fetcher.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import fetchHttpJSON from "../fetcher";
+import type { HttpJsonOptions } from "../options";
+import type { DatasourceFetcherParams } from "~/shared/datasources/fetcher";
+
+// Mock the fetch function
+globalThis.fetch = vi.fn();
+
+describe("fetchHttpJSON", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should fetch JSON data successfully", async () => {
+    const mockResponse = { data: "test" };
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await fetchHttpJSON({
+      options: { url: "https://api.example.com/data" },
+      pageAttributes: {},
+      oauth: null,
+    } as DatasourceFetcherParams<null, HttpJsonOptions>);
+
+    expect(result).toEqual(mockResponse);
+    expect(global.fetch).toHaveBeenCalledWith("https://api.example.com/data", { headers: {} });
+  });
+
+  it("should replace placeholders in URL and headers", async () => {
+    const mockResponse = { data: "test" };
+
+    (globalThis.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await fetchHttpJSON({
+      options: {
+        url: "https://api.example.com/{{dataType}}",
+        headers: { "X-API-Key": "{{apiKey}}" },
+      },
+      pageAttributes: { dataType: "users", apiKey: "secret-key" },
+      env: {},
+      oauth: null,
+    } as unknown as DatasourceFetcherParams<null, HttpJsonOptions>);
+
+    expect(result).toEqual(mockResponse);
+    expect(global.fetch).toHaveBeenCalledWith("https://api.example.com/users", {
+      headers: { "X-API-Key": "secret-key" },
+    });
+  });
+
+  it("should throw error on non-OK response", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+    });
+
+    await expect(
+      fetchHttpJSON({
+        options: { url: "https://api.example.com/notfound" },
+        pageAttributes: {},
+        oauth: null,
+      } as DatasourceFetcherParams<null, HttpJsonOptions>),
+    ).rejects.toThrow("fetchHttpJSON Error: Response status: 404");
+  });
+});

package/src/shared/datasources/external/instagram/feed/fetcher.ts

@@ -0,0 +1,33 @@
+import type { InstagramFeedSchema } from "./schema";
+import type { MetaFullOAuthConfig } from "~/shared/datasources/external/meta/oauth/config";
+import { UnauthorizedError } from "~/shared/errors";
+import type { MetaOptions } from "~/shared/datasources/external/meta/options";
+import { stringifyObjectValues } from "~/shared/datasources/utils";
+import type { DatasourceFetcher } from "~/shared/datasources/fetcher";
+
+const fetchInstagramFeedDatasource: DatasourceFetcher<
+  InstagramFeedSchema,
+  MetaFullOAuthConfig,
+  MetaOptions
+> = async ({ options, oauth }) => {
+  const params = new URLSearchParams({
+    ...stringifyObjectValues(options),
+    access_token: oauth.config.accessToken,
+    fields: ["id", "caption", "timestamp", "thumbnail_url", "media_url", "permalink", "media_type"].join(","),
+  });
+
+  const response = await fetch(`https://graph.instagram.com/me/media?${params.toString()}`);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new UnauthorizedError(`fetchInstagramFeedDatasource Error: Unauthorized.`);
+    }
+    throw new Error(`fetchInstagramFeedDatasource Error: Response status: ${response.status}`);
+  }
+
+  const feed = (await response.json()) as InstagramFeedSchema;
+
+  return feed;
+};
+
+export default fetchInstagramFeedDatasource;

package/src/shared/datasources/external/instagram/feed/sample.ts

@@ -0,0 +1,22 @@
+import type { InstagramFeedSchema } from "./schema";
+
+export const sample = {
+  data: [
+    {
+      id: "17895695668004550",
+      caption: "Caption",
+      timestamp: "2021-08-26T19:00:00+0000",
+      media_url: "https://www.instagram.com/p/CTB8Vz7p9d4/",
+      permalink: "https://www.instagram.com/p/CTB8Vz7p9d4/",
+      media_type: "IMAGE",
+    },
+    {
+      id: "17895695668004551",
+      caption: "Caption",
+      timestamp: "2021-08-26T19:00:00+0000",
+      media_url: "https://www.instagram.com/p/CTB8Vz7p9d4/",
+      permalink: "https://www.instagram.com/p/CTB8Vz7p9d4/",
+      media_type: "VIDEO",
+    },
+  ],
+} as InstagramFeedSchema;

package/src/shared/datasources/external/instagram/feed/schema.ts

@@ -0,0 +1,23 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const instagramFeedSchema = Type.Object({
+  data: Type.Array(
+    Type.Object({
+      id: Type.String(),
+      caption: Type.String(),
+      timestamp: Type.String(),
+      media_url: Type.String(),
+      permalink: Type.String(),
+      media_type: Type.Union([Type.Literal("IMAGE"), Type.Literal("VIDEO"), Type.Literal("CAROUSEL_ALBUM")]),
+    }),
+  ),
+  paging: Type.Object({
+    cursors: Type.Object({
+      before: Type.Optional(Type.String()),
+      after: Type.Optional(Type.String()),
+    }),
+    next: Type.Optional(Type.String()),
+  }),
+});
+
+export type InstagramFeedSchema = Static<typeof instagramFeedSchema>;

package/src/shared/datasources/external/instagram/feed/tests/fetcher.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import fetchInstagramFeedDatasource from "../fetcher";
+import { UnauthorizedError } from "~/shared/errors";
+
+// Mock the fetch function
+global.fetch = vi.fn();
+
+describe("fetchInstagramFeedDatasource", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should fetch Instagram feed successfully", async () => {
+    const mockResponse = {
+      data: [
+        {
+          id: "123",
+          caption: "Test post",
+          media_url: "https://example.com/image.jpg",
+          permalink: "https://instagram.com/p/123",
+          media_type: "IMAGE",
+          timestamp: "2023-05-01T12:00:00+0000",
+        },
+      ],
+      paging: {
+        cursors: { before: "before-cursor", after: "after-cursor" },
+        next: "https://example.com/next",
+      },
+    };
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(mockResponse),
+    });
+
+    const result = await fetchInstagramFeedDatasource({
+      options: { limit: 10 },
+      oauth: { config: { accessToken: "test-token" } },
+      env: {},
+      pageConfig: {},
+    } as any);
+
+    expect(result).toEqual(mockResponse);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining("https://graph.instagram.com/me/media?"),
+    );
+  });
+
+  it("should throw Http401Error on unauthorized response", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+    });
+
+    await expect(
+      fetchInstagramFeedDatasource({
+        options: { limit: 10 },
+        oauth: { config: { accessToken: "invalid-token" } },
+        env: {},
+        pageConfig: {},
+      } as any),
+    ).rejects.toThrow(UnauthorizedError);
+  });
+});

package/src/shared/datasources/external/mastodon/account/fetcher.ts

@@ -0,0 +1,24 @@
+import type { MastodonAccountSchema } from "./schema";
+import type { MastodonCommonOptions } from "../options";
+import type { DatasourceFetcher } from "~/shared/datasources/fetcher";
+
+const fetchMastodonAccount: DatasourceFetcher<MastodonAccountSchema, null, MastodonCommonOptions> = async ({
+  options,
+}) => {
+  const params = new URLSearchParams({
+    acct: options.username,
+  });
+
+  const url = `https://mastodon.social/api/v1/accounts/lookup?${params.toString()}`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`fetchMastodonAccount Error: Response status: ${response.status}`);
+  }
+
+  const account = (await response.json()) as MastodonAccountSchema;
+
+  return account;
+};
+
+export default fetchMastodonAccount;

package/src/shared/datasources/external/mastodon/account/sample.ts

@@ -0,0 +1,33 @@
+import type { MastodonAccountSchema } from "./schema";
+
+export const sample = {
+  id: "1",
+  acct: "Gargron",
+  url: "https://mastodon.social/@Gargron",
+  noindex: false,
+  locked: false,
+  discoverable: true,
+  fields: [],
+  followers_count: 0,
+  following_count: 0,
+  group: false,
+  statuses_count: 0,
+  note: "Admin of mastodon.social",
+  username: "Gargron",
+  header_static: "https://files.mastodon.social/accounts/headers/000/000/001/original/7b7e3c3e3e7e3e3e.png",
+  header: "https://files.mastodon.social/accounts/headers/000/000/001/original/7b7e3c3e3e7e3e3e.png",
+  avatar: "https://files.mastodon.social/accounts/avatars/000/000/001/original/7b7e3c3e3e7e3e3e.png",
+  avatar_static: "https://files.mastodon.social/accounts/avatars/000/000/001/original/7b7e3c3e3e7e3e3e.png",
+  bot: false,
+  created_at: "2016-04-04T17:41:54.000Z",
+  display_name: "Eugen",
+  emojis: [
+    {
+      category: "custom",
+      shortcode: "blobawave",
+      static_url: "https://files.mastodon.social/custom_emojis/images/000/000/001/static/1f4a9.png",
+      url: "https://files.mastodon.social/custom_emojis/images/000/000/001/original/1f4a9.png",
+      visible_in_picker: true,
+    },
+  ],
+} satisfies MastodonAccountSchema;

package/src/shared/datasources/external/mastodon/account/schema.ts

@@ -0,0 +1,45 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const mastodonAccountSchema = Type.Object({
+  id: Type.String(),
+  username: Type.String(),
+  acct: Type.String(),
+  url: Type.String(),
+  display_name: Type.Optional(Type.String()),
+  note: Type.String(),
+  avatar: Type.String(),
+  avatar_static: Type.String(),
+  header: Type.String(),
+  header_static: Type.String(),
+  locked: Type.Boolean(),
+  fields: Type.Array(
+    Type.Object({
+      name: Type.String(),
+      value: Type.String(),
+      verified_at: Type.Optional(Type.String()),
+    }),
+  ),
+  emojis: Type.Array(
+    Type.Object({
+      shortcode: Type.String(),
+      url: Type.String(),
+      static_url: Type.String(),
+      visible_in_picker: Type.Boolean(),
+      category: Type.Optional(Type.String()),
+    }),
+  ),
+  bot: Type.Boolean(),
+  group: Type.Boolean(),
+  discoverable: Type.Union([Type.Boolean(), Type.Null()]),
+  noindex: Type.Optional(Type.Boolean()),
+  moved: Type.Optional(Type.String()),
+  suspended: Type.Optional(Type.Boolean()),
+  limited: Type.Optional(Type.Boolean()),
+  created_at: Type.String(),
+  last_status_at: Type.Optional(Type.String()),
+  statuses_count: Type.Number(),
+  followers_count: Type.Number(),
+  following_count: Type.Number(),
+});
+
+export type MastodonAccountSchema = Static<typeof mastodonAccountSchema>;

package/src/shared/datasources/external/mastodon/account/tests/fetcher.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import fetchMastodonAccount from "../fetcher";
+import { sample } from "../sample";
+
+// Mock the fetch function
+global.fetch = vi.fn();
+
+describe("fetchMastodonAccount", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should fetch Mastodon account successfully", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(sample),
+    });
+
+    const result = await fetchMastodonAccount({
+      options: { username: "testuser" },
+      env: {},
+      pageConfig: {},
+      oauth: null,
+    } as any);
+
+    expect(result).toEqual(sample);
+    expect(global.fetch).toHaveBeenCalledWith(
+      expect.stringContaining("https://mastodon.social/api/v1/accounts/lookup?acct=testuser"),
+    );
+  });
+
+  it("should throw error on non-OK response", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+    });
+
+    await expect(
+      fetchMastodonAccount({
+        options: { username: "nonexistent" },
+        env: {},
+        pageConfig: {},
+        oauth: null,
+      } as any),
+    ).rejects.toThrow("fetchMastodonAccount Error: Response status: 404");
+  });
+});

package/src/shared/datasources/external/mastodon/options.ts

@@ -0,0 +1,6 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export const mastodonCommonOptions = Type.Object({
+  username: Type.String(),
+});
+export type MastodonCommonOptions = Static<typeof mastodonCommonOptions>;

package/src/shared/datasources/external/mastodon/status/fetcher.ts

@@ -0,0 +1,35 @@
+import { type MastodonStatusArraySchema, mastodonStatusArraySchema } from "./schema";
+import fetchMastodonAccount from "../account/fetcher";
+import { UnauthorizedError } from "~/shared/errors";
+import type { MastodonCommonOptions } from "../options";
+import type { DatasourceFetcher } from "~/shared/datasources/fetcher";
+
+const fetchMastodonStatus: DatasourceFetcher<
+  MastodonStatusArraySchema,
+  null,
+  MastodonCommonOptions
+> = async ({ options, pageAttributes: attr }) => {
+  const account = await fetchMastodonAccount({
+    options: { username: options.username },
+    pageAttributes: attr,
+    oauth: null,
+  });
+
+  const accountUrl = new URL(account.url);
+  const url = `https://${accountUrl.host}/api/v1/accounts/${account.id}/statuses`;
+
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new UnauthorizedError(`fetchMastodonStatus Error: Unauthorized.`);
+    }
+    throw new Error(`fetchMastodonStatus Error: Response status: ${response.status}`);
+  }
+
+  const statuses = (await response.json()) as MastodonStatusArraySchema;
+
+  return statuses;
+};
+
+export default fetchMastodonStatus;