naystack 1.8.19 → 1.9.1

package/dist/socials/index.cjs.js

@@ -20,11 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/socials/index.ts
 var socials_exports = {};
 __export(socials_exports, {
+  InstagramProvider: () => InstagramProvider,
   MetaMediaType: () => MetaMediaType,
+  SocialMediaKind: () => SocialMediaKind,
+  SocialPlatform: () => SocialPlatform,
   canPublishToInstagram: () => canPublishToInstagram,
   createInstagramPost: () => createInstagramPost,
   createThread: () => createThread,
   createThreadsPost: () => createThreadsPost,
+  getInstagramAuthorizationURL: () => getInstagramAuthorizationURL,
   getInstagramConversation: () => getInstagramConversation,
   getInstagramConversationByUser: () => getInstagramConversationByUser,
   getInstagramConversations: () => getInstagramConversations,
@@ -33,18 +37,203 @@ __export(socials_exports, {
   getInstagramMedia: () => getInstagramMedia,
   getInstagramMessage: () => getInstagramMessage,
   getInstagramUser: () => getInstagramUser,
+  getLongLivedInstagramToken: () => getLongLivedInstagramToken,
   getThread: () => getThread,
   getThreads: () => getThreads,
   getThreadsData: () => getThreadsData,
   getThreadsReplies: () => getThreadsReplies,
+  pollUntilReady: () => pollUntilReady,
   readGraphID: () => readGraphID,
+  refreshInstagramAccessToken: () => refreshInstagramAccessToken,
   replyToInstagramComment: () => replyToInstagramComment,
   sendInstagramMessage: () => sendInstagramMessage,
   setupInstagramWebhook: () => setupInstagramWebhook,
-  setupThreadsWebhook: () => setupThreadsWebhook
+  setupSocialAuth: () => setupSocialAuth,
+  setupThreadsWebhook: () => setupThreadsWebhook,
+  withRetry: () => withRetry
 });
 module.exports = __toCommonJS(socials_exports);
 
+// src/socials/connect.ts
+var import_server2 = require("next/server");
+
+// src/auth/email/token.ts
+var import_bcryptjs = require("bcryptjs");
+var import_jsonwebtoken = require("jsonwebtoken");
+var import_headers = require("next/headers");
+var import_navigation = require("next/navigation");
+var import_server = require("next/server");
+
+// src/env.ts
+var EXTRA_ENV = globalThis.__NAYSTACK_ENV__ || (globalThis.__NAYSTACK_ENV__ = {});
+var getEnvValue = (key) => {
+  switch (key) {
+    case "NEXT_PUBLIC_GRAPHQL_ENDPOINT" /* NEXT_PUBLIC_GRAPHQL_ENDPOINT */:
+      return process.env.NEXT_PUBLIC_GRAPHQL_ENDPOINT || EXTRA_ENV.GRAPHQL_ENDPOINT;
+    case "NEXT_PUBLIC_EMAIL_AUTH_ENDPOINT" /* NEXT_PUBLIC_EMAIL_AUTH_ENDPOINT */:
+      return process.env.NEXT_PUBLIC_EMAIL_AUTH_ENDPOINT || EXTRA_ENV.EMAIL_AUTH_ENDPOINT;
+    case "NEXT_PUBLIC_GOOGLE_AUTH_ENDPOINT" /* NEXT_PUBLIC_GOOGLE_AUTH_ENDPOINT */:
+      return process.env.NEXT_PUBLIC_GOOGLE_AUTH_ENDPOINT || EXTRA_ENV.GOOGLE_AUTH_ENDPOINT;
+    case "NEXT_PUBLIC_SOCIAL_AUTH_ENDPOINT" /* NEXT_PUBLIC_SOCIAL_AUTH_ENDPOINT */:
+      return process.env.NEXT_PUBLIC_SOCIAL_AUTH_ENDPOINT || EXTRA_ENV.SOCIAL_AUTH_ENDPOINT;
+    case "NEXT_PUBLIC_FILE_ENDPOINT" /* NEXT_PUBLIC_FILE_ENDPOINT */:
+      return process.env.NEXT_PUBLIC_FILE_ENDPOINT || EXTRA_ENV.FILE_ENDPOINT;
+    case "NEXT_PUBLIC_BASE_URL" /* NEXT_PUBLIC_BASE_URL */:
+      return process.env.NEXT_PUBLIC_BASE_URL || EXTRA_ENV.BASE_URL;
+    case "REFRESH_KEY" /* REFRESH_KEY */:
+      return process.env.REFRESH_KEY;
+    case "SIGNING_KEY" /* SIGNING_KEY */:
+      return process.env.SIGNING_KEY;
+    case "INSTAGRAM_CLIENT_SECRET" /* INSTAGRAM_CLIENT_SECRET */:
+      return process.env.INSTAGRAM_CLIENT_SECRET;
+    case "INSTAGRAM_CLIENT_ID" /* INSTAGRAM_CLIENT_ID */:
+      return process.env.INSTAGRAM_CLIENT_ID;
+    case "GOOGLE_CLIENT_SECRET" /* GOOGLE_CLIENT_SECRET */:
+      return process.env.GOOGLE_CLIENT_SECRET;
+    case "GOOGLE_CLIENT_ID" /* GOOGLE_CLIENT_ID */:
+      return process.env.GOOGLE_CLIENT_ID;
+    case "TURNSTILE_KEY" /* TURNSTILE_KEY */:
+      return process.env.TURNSTILE_KEY;
+    case "S3_ACCESS_KEY_ID" /* S3_ACCESS_KEY_ID */:
+      return process.env.S3_ACCESS_KEY_ID;
+    case "S3_ACCESS_KEY_SECRET" /* S3_ACCESS_KEY_SECRET */:
+      return process.env.S3_ACCESS_KEY_SECRET;
+    case "S3_REGION" /* S3_REGION */:
+      return process.env.S3_REGION;
+    case "S3_BUCKET" /* S3_BUCKET */:
+      return process.env.S3_BUCKET;
+    case "NODE_ENV" /* NODE_ENV */:
+      return process.env.NODE_ENV;
+    default:
+      return process.env[key];
+  }
+};
+function getEnv(key, skipCheck) {
+  const value = getEnvValue(key);
+  if (!skipCheck && !value) throw new Error(`${key} is not defined`);
+  return value;
+}
+
+// src/auth/email/token.ts
+function getUserIdFromAccessToken(accessToken) {
+  if (accessToken)
+    try {
+      const decoded = (0, import_jsonwebtoken.verify)(accessToken, getEnv("SIGNING_KEY" /* SIGNING_KEY */));
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof import_jsonwebtoken.JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/socials/connect.ts
+function setupSocialAuth({
+  providers,
+  endpoint,
+  onConnect,
+  redirectURL,
+  errorRedirectURL,
+  scopes
+}) {
+  const handleError = (message) => import_server2.NextResponse.redirect(`${errorRedirectURL}?error=${message}`);
+  const GET = async (req, ctx) => {
+    const { platform } = await ctx.params;
+    const provider = providers.find((p) => p.platform === platform);
+    if (!provider) return handleError("Unsupported platform");
+    const code = req.nextUrl.searchParams.get("code");
+    const error = req.nextUrl.searchParams.get("error");
+    const state = req.nextUrl.searchParams.get("state");
+    if (error) return handleError(error);
+    if (!state) return handleError("Invalid request");
+    const redirectURI = `${endpoint}/${provider.platform}`;
+    if (!code) {
+      return import_server2.NextResponse.redirect(
+        provider.auth.authorizationURL({
+          state,
+          redirectURI,
+          scopes: scopes?.[provider.platform]
+        }),
+        302
+      );
+    }
+    const exchanged = await provider.auth.exchangeCode({ code, redirectURI });
+    if (!exchanged) return handleError("Couldn't connect your account");
+    const { platformUserId, ...tokens } = exchanged;
+    const profile = await provider.fetchProfile(tokens.accessToken);
+    if (!profile) return handleError("Couldn't read your profile");
+    const errorMessage = await onConnect({
+      platform: provider.platform,
+      profile: {
+        ...profile,
+        platformUserId: profile.platformUserId ?? platformUserId
+      },
+      tokens,
+      userId: getUserIdFromAccessToken(state)
+    });
+    if (errorMessage) return handleError(errorMessage);
+    return import_server2.NextResponse.redirect(redirectURL);
+  };
+  return { GET };
+}
+
+// src/socials/types.ts
+var SocialPlatform = /* @__PURE__ */ ((SocialPlatform2) => {
+  SocialPlatform2["Instagram"] = "instagram";
+  SocialPlatform2["YouTube"] = "youtube";
+  SocialPlatform2["TikTok"] = "tiktok";
+  return SocialPlatform2;
+})(SocialPlatform || {});
+var SocialMediaKind = /* @__PURE__ */ ((SocialMediaKind2) => {
+  SocialMediaKind2["Image"] = "image";
+  SocialMediaKind2["Video"] = "video";
+  SocialMediaKind2["Carousel"] = "carousel";
+  return SocialMediaKind2;
+})(SocialMediaKind || {});
+
+// src/socials/instagram/auth.ts
+var getInstagramAuthorizationURL = (state, redirectURI, scopes = ["instagram_business_basic"]) => `https://www.instagram.com/oauth/authorize/?client_id=${getEnv(
+  "INSTAGRAM_CLIENT_ID" /* INSTAGRAM_CLIENT_ID */
+)}&response_type=code&enable_fb_login=0&force_authentication=1&scope=${scopes.join(",")}&state=${state}&redirect_uri=${redirectURI}#weblink`;
+async function getLongLivedInstagramToken(code, redirectURI) {
+  const formData = new FormData();
+  formData.set("client_id", getEnv("INSTAGRAM_CLIENT_ID" /* INSTAGRAM_CLIENT_ID */));
+  formData.set("client_secret", getEnv("INSTAGRAM_CLIENT_SECRET" /* INSTAGRAM_CLIENT_SECRET */));
+  formData.set("grant_type", "authorization_code");
+  formData.set("redirect_uri", redirectURI);
+  formData.set("code", code);
+  const shortRes = await fetch("https://api.instagram.com/oauth/access_token", {
+    method: "POST",
+    body: formData
+  });
+  if (!shortRes.ok) return void 0;
+  const shortResData = await shortRes.json();
+  if (!shortResData.access_token) return void 0;
+  const longRes = await fetch(
+    `https://graph.instagram.com/access_token?grant_type=ig_exchange_token&access_token=${shortResData.access_token}&client_secret=${getEnv("INSTAGRAM_CLIENT_SECRET" /* INSTAGRAM_CLIENT_SECRET */)}`
+  );
+  if (!longRes.ok) return void 0;
+  const longResData = await longRes.json();
+  return {
+    accessToken: longResData.access_token,
+    userId: shortResData.user_id,
+    expiresIn: longResData.expires_in,
+    permissions: shortResData.permissions
+  };
+}
+async function refreshInstagramAccessToken(token) {
+  const request = await fetch(
+    `https://graph.instagram.com/refresh_access_token?grant_type=ig_refresh_token&access_token=${token}`
+  );
+  const response = await request.json();
+  if (!response.access_token) return void 0;
+  return {
+    accessToken: response.access_token,
+    expiresIn: response.expires_in
+  };
+}
+
 // src/socials/meta/request.ts
 function createGraphClient(baseURL) {
   const buildURL = (token, path, params = {}) => {
@@ -177,25 +366,152 @@ var canPublishToInstagram = async (token) => {
   return true;
 };
 
-// src/socials/meta/container.ts
+// src/socials/instagram/adapter.ts
+var PROFILE_FIELDS = [
+  "id",
+  "user_id",
+  "username",
+  "name",
+  "profile_picture_url",
+  "followers_count",
+  "media_count"
+];
+var MEDIA_FIELDS = [
+  "id",
+  "caption",
+  "media_type",
+  "media_url",
+  "permalink",
+  "thumbnail_url",
+  "timestamp",
+  "like_count",
+  "comments_count"
+];
+var expiresAt = (seconds) => seconds ? new Date(Date.now() + seconds * 1e3) : void 0;
+function toKind(mediaType) {
+  if (mediaType === "VIDEO") return "video" /* Video */;
+  if (mediaType === "CAROUSEL_ALBUM") return "carousel" /* Carousel */;
+  return "image" /* Image */;
+}
+function toPost(media) {
+  const kind = toKind(media.media_type);
+  return {
+    platform: "instagram" /* Instagram */,
+    platformMediaId: media.id,
+    permalink: media.permalink,
+    // A video's `media_url` is the .mp4 itself, so it is never a stand-in for a
+    // missing poster frame — better no thumbnail than one that can't render.
+    thumbnail: media.thumbnail_url ?? (kind === "video" /* Video */ ? null : media.media_url ?? null),
+    mediaURL: media.media_url ?? null,
+    caption: media.caption ?? null,
+    kind,
+    publishedAt: media.timestamp,
+    likes: media.like_count ?? null,
+    comments: media.comments_count ?? null,
+    // Both need the Insights API; the basic media fields carry neither.
+    views: null,
+    shares: null,
+    metadata: {}
+  };
+}
+var InstagramProvider = {
+  platform: "instagram" /* Instagram */,
+  auth: {
+    authorizationURL: ({ state, redirectURI, scopes }) => getInstagramAuthorizationURL(
+      state,
+      redirectURI,
+      scopes
+    ),
+    exchangeCode: async ({ code, redirectURI }) => {
+      const result = await getLongLivedInstagramToken(code, redirectURI);
+      if (!result) {
+        console.error("[naystack] Instagram code exchange returned no token");
+        return null;
+      }
+      return {
+        accessToken: result.accessToken,
+        platformUserId: result.userId || null,
+        expiresAt: expiresAt(result.expiresIn),
+        scopes: result.permissions
+      };
+    },
+    refresh: async ({ accessToken }) => {
+      const refreshed = await refreshInstagramAccessToken(accessToken);
+      if (!refreshed) return null;
+      return {
+        accessToken: refreshed.accessToken,
+        expiresAt: expiresAt(refreshed.expiresIn)
+      };
+    }
+  },
+  profileURL: (username) => `https://instagram.com/${username}`,
+  fetchProfile: async (accessToken) => {
+    const user = await getInstagramUser(
+      accessToken,
+      void 0,
+      PROFILE_FIELDS
+    );
+    if (!user?.username) return null;
+    return {
+      platform: "instagram" /* Instagram */,
+      // `user_id` is what the OAuth exchange hands back, so preferring it keeps
+      // one account's id identical however it was read.
+      platformUserId: user.user_id || user.id || null,
+      username: user.username,
+      displayName: user.name ?? null,
+      avatar: user.profile_picture_url ?? null,
+      followers: user.followers_count ?? 0,
+      contentCount: user.media_count ?? 0,
+      metadata: {}
+    };
+  },
+  fetchMedia: async (accessToken, options) => {
+    const result = await getInstagramMedia(
+      accessToken,
+      MEDIA_FIELDS,
+      options?.limit
+    );
+    if (!result?.data) return [];
+    return result.data.map(toPost);
+  }
+};
+
+// src/socials/utils/poll.ts
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function waitForContainer(getState, { intervalMS = 5e3, timeoutMS = 3e5 } = {}) {
+async function pollUntilReady(read, isPending, { intervalMS = 5e3, timeoutMS = 3e5 } = {}) {
   const deadline = Date.now() + timeoutMS;
-  let state = await getState();
+  let state = await read();
   if (!state) {
     await sleep(2e3);
     return null;
   }
-  while (state?.status === "IN_PROGRESS" && Date.now() < deadline) {
+  while (state && isPending(state) && Date.now() < deadline) {
     await sleep(intervalMS);
-    state = await getState();
+    state = await read();
   }
   return state;
 }
+async function withRetry(run, options = {}) {
+  const attempts = Math.max(1, options.attempts ?? 3);
+  const backoffMS = options.backoffMS ?? 2e3;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const result = await run(attempt);
+    if (result) return result;
+    if (attempt < attempts) {
+      const delayMS = backoffMS * 2 ** (attempt - 1);
+      options.onRetry?.(attempt, attempts, delayMS);
+      await sleep(delayMS);
+    }
+  }
+  return null;
+}
+
+// src/socials/meta/container.ts
 function createPublisher(platform) {
   const isReady = async (token, id, label, wait) => {
-    const state = await waitForContainer(
+    const state = await pollUntilReady(
       () => platform.getStatus(token, id),
+      (current) => current.status === "IN_PROGRESS",
       wait
     );
     if (state && state.status !== "FINISHED" && state.status !== "PUBLISHED") {
@@ -206,22 +522,21 @@ function createPublisher(platform) {
     }
     return true;
   };
-  const createReady = async (token, params, label, wait, retry) => {
-    const attempts = Math.max(1, retry?.attempts ?? 3);
-    const backoffMS = retry?.backoffMS ?? 2e3;
-    for (let attempt = 1; attempt <= attempts; attempt++) {
+  const createReady = (token, params, label, wait, retry) => withRetry(
+    async () => {
       const id = await platform.createContainer(token, params);
-      if (id && await isReady(token, id, label, wait)) return id;
-      if (attempt < attempts) {
-        const delay = backoffMS * 2 ** (attempt - 1);
+      if (!id || !await isReady(token, id, label, wait)) return null;
+      return id;
+    },
+    {
+      ...retry,
+      onRetry: (attempt, attempts, delayMS) => {
         console.warn(
-          `[naystack] ${platform.name} ${label} attempt ${attempt}/${attempts} failed \u2014 retrying in ${delay}ms`
+          `[naystack] ${platform.name} ${label} attempt ${attempt}/${attempts} failed \u2014 retrying in ${delayMS}ms`
         );
-        await sleep(delay);
       }
     }
-    return null;
-  };
+  );
   return {
     /** Creates a container, waits for it to finish processing, then publishes it. */
     publish: async (token, params, wait, retry) => {
@@ -384,11 +699,11 @@ var sendInstagramMessage = (token, to, text) => {
 };
 
 // src/socials/meta/webhook.ts
-var import_server = require("next/server");
+var import_server3 = require("next/server");
 var verifyWebhook = (secret) => (req) => {
   const params = req.nextUrl.searchParams;
   if (params.get("hub.verify_token") === secret) {
-    return new import_server.NextResponse(params.get("hub.challenge"));
+    return new import_server3.NextResponse(params.get("hub.challenge"));
   }
 };
 
@@ -522,11 +837,15 @@ var setupThreadsWebhook = (options) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  InstagramProvider,
   MetaMediaType,
+  SocialMediaKind,
+  SocialPlatform,
   canPublishToInstagram,
   createInstagramPost,
   createThread,
   createThreadsPost,
+  getInstagramAuthorizationURL,
   getInstagramConversation,
   getInstagramConversationByUser,
   getInstagramConversations,
@@ -535,13 +854,18 @@ var setupThreadsWebhook = (options) => {
   getInstagramMedia,
   getInstagramMessage,
   getInstagramUser,
+  getLongLivedInstagramToken,
   getThread,
   getThreads,
   getThreadsData,
   getThreadsReplies,
+  pollUntilReady,
   readGraphID,
+  refreshInstagramAccessToken,
   replyToInstagramComment,
   sendInstagramMessage,
   setupInstagramWebhook,
-  setupThreadsWebhook
+  setupSocialAuth,
+  setupThreadsWebhook,
+  withRetry
 });

package/dist/socials/index.d.mts

@@ -1,14 +1,20 @@
+export { SetupSocialAuthOptions, SocialConnection, setupSocialAuth } from './connect.mjs';
+export { InstagramProvider } from './instagram/adapter.mjs';
+export { InstagramScope, getInstagramAuthorizationURL, getLongLivedInstagramToken, refreshInstagramAccessToken } from './instagram/auth.mjs';
 export { canPublishToInstagram, getInstagramConversation, getInstagramConversationByUser, getInstagramConversations, getInstagramConversationsByUser, getInstagramMedia, getInstagramMessage, getInstagramUser } from './instagram/getters.mjs';
 export { createInstagramPost, replyToInstagramComment, sendInstagramMessage } from './instagram/setters.mjs';
 export { InstagramConversation, InstagramMedia, InstagramMessage, InstagramPostInput, InstagramPostMedia, InstagramUser } from './instagram/types.mjs';
 export { getInstagramData } from './instagram/utils.mjs';
 export { setupInstagramWebhook } from './instagram/webhook.mjs';
-export { RetryOptions, WaitForContainerOptions } from './meta/container.mjs';
+export { WaitForContainerOptions } from './meta/container.mjs';
 export { GraphClient, GraphRequestOptions, readGraphID } from './meta/request.mjs';
 export { GraphError, GraphParams, MetaMediaType } from './meta/types.mjs';
+export { SocialProvider } from './provider.mjs';
 export { getThread, getThreads, getThreadsReplies } from './threads/getters.mjs';
 export { createThread, createThreadsPost } from './threads/setters.mjs';
-export { getThreadsData } from './threads/utils.mjs';
 export { ThreadsPost, ThreadsPostInput, ThreadsPostMedia } from './threads/types.mjs';
+export { getThreadsData } from './threads/utils.mjs';
 export { setupThreadsWebhook } from './threads/webhook.mjs';
+export { SocialMediaKind, SocialPlatform, SocialPost, SocialProfile, SocialTokens } from './types.mjs';
+export { PollOptions, RetryOptions, pollUntilReady, withRetry } from './utils/poll.mjs';
 import 'next/server';

package/dist/socials/index.d.ts

@@ -1,14 +1,20 @@
+export { SetupSocialAuthOptions, SocialConnection, setupSocialAuth } from './connect.js';
+export { InstagramProvider } from './instagram/adapter.js';
+export { InstagramScope, getInstagramAuthorizationURL, getLongLivedInstagramToken, refreshInstagramAccessToken } from './instagram/auth.js';
 export { canPublishToInstagram, getInstagramConversation, getInstagramConversationByUser, getInstagramConversations, getInstagramConversationsByUser, getInstagramMedia, getInstagramMessage, getInstagramUser } from './instagram/getters.js';
 export { createInstagramPost, replyToInstagramComment, sendInstagramMessage } from './instagram/setters.js';
 export { InstagramConversation, InstagramMedia, InstagramMessage, InstagramPostInput, InstagramPostMedia, InstagramUser } from './instagram/types.js';
 export { getInstagramData } from './instagram/utils.js';
 export { setupInstagramWebhook } from './instagram/webhook.js';
-export { RetryOptions, WaitForContainerOptions } from './meta/container.js';
+export { WaitForContainerOptions } from './meta/container.js';
 export { GraphClient, GraphRequestOptions, readGraphID } from './meta/request.js';
 export { GraphError, GraphParams, MetaMediaType } from './meta/types.js';
+export { SocialProvider } from './provider.js';
 export { getThread, getThreads, getThreadsReplies } from './threads/getters.js';
 export { createThread, createThreadsPost } from './threads/setters.js';
-export { getThreadsData } from './threads/utils.js';
 export { ThreadsPost, ThreadsPostInput, ThreadsPostMedia } from './threads/types.js';
+export { getThreadsData } from './threads/utils.js';
 export { setupThreadsWebhook } from './threads/webhook.js';
+export { SocialMediaKind, SocialPlatform, SocialPost, SocialProfile, SocialTokens } from './types.js';
+export { PollOptions, RetryOptions, pollUntilReady, withRetry } from './utils/poll.js';
 import 'next/server';