@postrun/react 0.2.0 → 1.0.0

package/dist/index.js

@@ -1,9 +1,11 @@
 "use client";
 import { createContext, memo, useMemo, useState, useEffect, Fragment as Fragment$1, useRef, createElement, useContext, useCallback } from 'react';
 import { useInfiniteQuery, useQuery, useMutation, QueryClient } from '@tanstack/react-query';
-import { createPostrunClient, profilesList, profilesGet, profilesCreate, profilesUpdate, profilesDelete, connectionsConnect, connectionsListByProfile, connectionsGet, connectionsListAccounts, connectionsSelect, connectionsDelete, mediaCreate, mediaGet, mediaList, mediaUpdate, mediaDelete, postsList, postsGet, postsCreate, buildCreatePost, isPostPlatform, postsUpdate, postsDelete } from '@postrun/js';
+import { createPostrunClient, profilesList, profilesGet, profilesCreate, profilesUpdate, profilesDelete, connectionsConnect, connectionsListByProfile, connectionsGet, connectionsListAccounts, connectionsSelect, connectionsDelete, mediaGet, mediaList, mediaUpdate, mediaDelete, postsList, postsGet, postsCreate, buildCreatePost, isPostPlatform, postsUpdate, postsDelete, mediaCreate, PostrunError } from '@postrun/js';
+import Nango, { AuthError } from '@nangohq/frontend';
+import pWaitFor, { TimeoutError } from 'p-wait-for';
+import pLimit from 'p-limit';
 import pRetry, { AbortError } from 'p-retry';
-import pWaitFor from 'p-wait-for';
 import axios, { isAxiosError } from 'axios';
 import { enrichTweet, TweetContainer, TweetHeader, TweetInReplyTo, TweetBody, TweetMedia, QuotedTweet } from 'react-tweet';
 import { FiMessageCircle, FiRepeat, FiHeart, FiBarChart2, FiShare, FiGlobe, FiUsers, FiThumbsUp, FiMessageSquare, FiSend } from 'react-icons/fi';
@@ -194,29 +196,245 @@ function useDeleteProfile() {
     queryClient
   );
 }
-
-// src/navigate.ts
-function navigate(url) {
-  window.location.assign(url);
+var PENDING = { status: "connected_pending" };
+var CANCELLED = { status: "cancelled" };
+var active = (connection) => ({
+  status: "active",
+  connection
+});
+var failed = (reason) => ({
+  status: "error",
+  reason
+});
+function outcomeForAuthError(error) {
+  switch (error.type) {
+    case "window_closed":
+      return CANCELLED;
+    case "blocked_by_browser":
+      return failed("popup_blocked");
+    case "missing_auth_token":
+    case "invalid_host_url":
+    case "missing_credentials":
+    case "connection_test_failed":
+    case "missing_connect_session_token":
+    case "connection_validation_failed":
+    case "resource_capped":
+    case "unknown_error":
+      return failed("auth_failed");
+  }
+}
+async function grant(authorize) {
+  try {
+    return { ok: true, connectionId: await authorize() };
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return { ok: false, outcome: outcomeForAuthError(error) };
+    }
+    return { ok: false, outcome: failed("auth_failed") };
+  }
+}
+async function awaitGrantedConnection(deps, nangoConnectionId) {
+  try {
+    return await pWaitFor(
+      async () => {
+        const rows = await deps.listByNangoConnectionId(nangoConnectionId);
+        const match = rows[0];
+        return match ? pWaitFor.resolveWith(match) : false;
+      },
+      { interval: deps.pollIntervalMs, timeout: deps.pollTimeoutMs }
+    );
+  } catch (error) {
+    if (error instanceof TimeoutError) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function bindPendingConnection(deps, connection) {
+  let accounts;
+  try {
+    accounts = await deps.discoverAccounts(connection.id);
+  } catch (error) {
+    if (error instanceof PostrunError && error.code === "not_implemented") {
+      return PENDING;
+    }
+    throw error;
+  }
+  if (accounts.length === 0) {
+    return PENDING;
+  }
+  const chosen = await deps.chooseAccount(accounts);
+  try {
+    return active(await deps.selectAccount(connection.id, chosen));
+  } catch (error) {
+    if (error instanceof PostrunError) {
+      return error.code === "connection_reauth_required" ? failed("reauth_required") : failed("select_failed");
+    }
+    throw error;
+  }
+}
+async function runEmbeddedConnect(deps) {
+  const granted = await grant(deps.authorize);
+  if (!granted.ok) {
+    return granted.outcome;
+  }
+  let connection;
+  try {
+    connection = await awaitGrantedConnection(deps, granted.connectionId);
+  } catch {
+    return failed("connection_not_found");
+  }
+  if (connection === null) {
+    return PENDING;
+  }
+  if (connection.external_account_id !== null) {
+    return active(connection);
+  }
+  try {
+    return await bindPendingConnection(deps, connection);
+  } catch {
+    return failed("select_failed");
+  }
 }
 
 // src/connections.ts
-function useConnect() {
-  const { client, queryClient } = usePostrun();
-  return useMutation(
-    {
-      mutationFn: async ({ profileId, platform }) => {
-        const session = (await connectionsConnect({
+var POLL_INTERVAL_MS = 1500;
+var POLL_TIMEOUT_MS = 15e3;
+function useConnect({
+  profileId,
+  platform,
+  onConnected
+}) {
+  const { client } = usePostrun();
+  const [state, setState] = useState({ phase: "preparing" });
+  const [remintNonce, setRemintNonce] = useState(0);
+  const sessionRef = useRef(null);
+  const pickRef = useRef(null);
+  const inFlightRef = useRef(false);
+  const flowGenRef = useRef(0);
+  const onConnectedRef = useRef(onConnected);
+  useEffect(() => {
+    onConnectedRef.current = onConnected;
+  }, [onConnected]);
+  const abandonFlow = useCallback(() => {
+    flowGenRef.current += 1;
+    inFlightRef.current = false;
+    const pick = pickRef.current;
+    pickRef.current = null;
+    pick?.reject(new Error("connect flow abandoned"));
+  }, []);
+  useEffect(() => {
+    let abandoned = false;
+    setState({ phase: "preparing" });
+    sessionRef.current = null;
+    connectionsConnect({ client, path: { id: profileId }, body: { platform } }).then(({ data }) => {
+      if (abandoned || !data) return;
+      sessionRef.current = {
+        token: data.connect_session_token,
+        providerConfigKey: data.provider_config_key,
+        host: data.nango_host
+      };
+      setState({ phase: "idle" });
+    }).catch(() => {
+      if (!abandoned) setState({ phase: "error", reason: "auth_failed" });
+    });
+    return () => {
+      abandoned = true;
+      abandonFlow();
+    };
+  }, [client, profileId, platform, remintNonce, abandonFlow]);
+  const start = useCallback(() => {
+    const session = sessionRef.current;
+    if (!session || inFlightRef.current) return;
+    inFlightRef.current = true;
+    const gen = flowGenRef.current;
+    const isCurrent = () => flowGenRef.current === gen;
+    setState({ phase: "connecting" });
+    void runEmbeddedConnect({
+      // Nango lives INSIDE `authorize` so a SYNCHRONOUS throw (invalid host /
+      // missing token — the Nango SDK throws `AuthError` synchronously) becomes a
+      // promise rejection that `grant()` maps to `auth_failed`, never an uncaught
+      // throw escaping the click and wedging `inFlightRef`. Gesture timing still
+      // holds: `authorize()` is invoked SYNCHRONOUSLY down the
+      // start → runEmbeddedConnect → grant chain (each `await`'s operand is
+      // evaluated before it suspends), so `nango.auth()`'s `window.open` fires
+      // inside the user gesture, with no `await` before it.
+      authorize: async () => {
+        const nango = new Nango({
+          host: session.host,
+          connectSessionToken: session.token
+        });
+        const result = await nango.auth(session.providerConfigKey, {
+          detectClosedAuthWindow: true
+        });
+        return result.connectionId;
+      },
+      chooseAccount: (accounts) => new Promise((resolve, reject) => {
+        if (!isCurrent()) {
+          reject(new Error("connect flow abandoned"));
+          return;
+        }
+        pickRef.current = { resolve, reject };
+        setState({ phase: "picking", accounts });
+      }),
+      listByNangoConnectionId: async (nangoConnectionId) => {
+        const { data } = await connectionsListByProfile({
           client,
           path: { id: profileId },
-          body: { platform }
-        })).data;
-        navigate(session.hosted_connect_url);
-        return session;
+          query: { nango_connection_id: nangoConnectionId }
+        });
+        return data?.data ?? [];
+      },
+      discoverAccounts: async (connectionId) => {
+        const { data } = await connectionsListAccounts({
+          client,
+          path: { id: connectionId }
+        });
+        return data?.data ?? [];
+      },
+      selectAccount: async (connectionId, externalAccountId) => {
+        const { data } = await connectionsSelect({
+          client,
+          path: { id: connectionId },
+          body: { external_account_id: externalAccountId }
+        });
+        if (!data) throw new Error("select returned no connection");
+        return data;
+      },
+      pollIntervalMs: POLL_INTERVAL_MS,
+      pollTimeoutMs: POLL_TIMEOUT_MS
+    }).then((outcome) => {
+      if (!isCurrent()) return;
+      inFlightRef.current = false;
+      pickRef.current = null;
+      switch (outcome.status) {
+        case "active":
+          setState({ phase: "active", connection: outcome.connection });
+          onConnectedRef.current?.(outcome.connection);
+          return;
+        case "connected_pending":
+          setState({ phase: "connected_pending" });
+          return;
+        case "cancelled":
+          setState({ phase: "cancelled" });
+          return;
+        case "error":
+          setState({ phase: "error", reason: outcome.reason });
+          return;
       }
-    },
-    queryClient
-  );
+    });
+  }, [client, profileId]);
+  const select = useCallback((externalAccountId) => {
+    const pick = pickRef.current;
+    if (!pick) return;
+    pickRef.current = null;
+    setState({ phase: "connecting" });
+    pick.resolve(externalAccountId);
+  }, []);
+  const reset = useCallback(() => {
+    setRemintNonce((n) => n + 1);
+  }, []);
+  return { state, start, select, reset };
 }
 function useConnections(profileId, filter) {
   const { client, queryClient } = usePostrun();
@@ -282,6 +500,17 @@ function useDisconnect() {
     queryClient
   );
 }
+
+// src/Connect.tsx
+function Connect({
+  profileId,
+  platform,
+  onConnected,
+  children
+}) {
+  const api = useConnect({ profileId, platform, onConnected });
+  return children(api);
+}
 var UploadError = class extends Error {
   status;
   constructor(status, message) {
@@ -322,17 +551,7 @@ async function uploadBytes(target, file, options = {}) {
 }
 
 // src/media.ts
-var DOCUMENT_MIME = /^application\/(pdf|msword|vnd\.(openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation)|ms-powerpoint))$/;
-function inferKind(contentType) {
-  if (contentType === "image/gif") return "gif";
-  if (contentType.startsWith("image/")) return "image";
-  if (contentType.startsWith("video/")) return "video";
-  if (DOCUMENT_MIME.test(contentType)) return "document";
-  throw new Error(
-    `Could not infer media kind from "${contentType}". Pass { kind } explicitly.`
-  );
-}
-async function pollUntilSettled(client, id, signal) {
+async function pollUntilSettled(client, id, signal, onTick) {
   let latest;
   await pWaitFor(
     async () => {
@@ -340,6 +559,7 @@ async function pollUntilSettled(client, id, signal) {
         throw new DOMException("Upload aborted", "AbortError");
       }
       latest = (await mediaGet({ client, path: { id } })).data;
+      onTick?.(latest);
       return latest.status === "ready" || latest.status === "failed";
     },
     { interval: 1500, timeout: 3e5 }
@@ -349,93 +569,134 @@ async function pollUntilSettled(client, id, signal) {
   }
   return latest;
 }
-function useMediaUpload() {
-  const { client, queryClient } = usePostrun();
-  const [status, setStatus] = useState("idle");
-  const [progress, setProgress] = useState(0);
-  const [media, setMedia] = useState(null);
-  const [error, setError] = useState(null);
-  const abortRef = useRef(null);
-  const upload = useCallback(
-    async (file, options) => {
-      const contentType = options.contentType || file.type;
-      if (!contentType) {
-        throw new Error(
-          "Could not determine the file's content type. Pass { contentType } explicitly."
-        );
-      }
-      const kind = options.kind ?? inferKind(contentType);
-      abortRef.current?.abort();
-      const controller = new AbortController();
-      abortRef.current = controller;
-      setStatus("uploading");
-      setProgress(0);
-      setMedia(null);
-      setError(null);
-      try {
-        const created = (await mediaCreate({
-          client,
-          body: {
-            profile_id: options.profileId,
-            kind,
-            content_type: contentType,
-            targets: options.targets,
-            raw: options.raw,
-            alt_text: options.altText,
-            external_id: options.externalId,
-            metadata: options.metadata
+async function runUpload(client, file, options, signal, callbacks) {
+  const created = (await mediaCreate({
+    client,
+    body: {
+      profile_id: options.profileId,
+      kind: options.kind,
+      content_type: options.contentType,
+      targets: options.targets,
+      raw: options.raw,
+      alt_text: options.altText,
+      external_id: options.externalId,
+      metadata: options.metadata
+    }
+  })).data;
+  if (created.upload) {
+    const target = created.upload;
+    await pRetry(
+      async () => {
+        try {
+          await uploadBytes(target, file, {
+            onProgress: callbacks.onProgress,
+            signal
+          });
+        } catch (uploadError) {
+          if (uploadError instanceof UploadError && uploadError.status >= 400 && uploadError.status < 500) {
+            throw new AbortError(uploadError);
           }
-        })).data;
-        if (created.upload) {
-          const target = created.upload;
-          await pRetry(
-            async () => {
-              try {
-                await uploadBytes(target, file, {
-                  onProgress: setProgress,
-                  signal: controller.signal
-                });
-              } catch (uploadError) {
-                if (uploadError instanceof UploadError && uploadError.status >= 400 && uploadError.status < 500) {
-                  throw new AbortError(uploadError);
-                }
-                throw uploadError;
-              }
-            },
-            { retries: 3, signal: controller.signal }
-          );
-        }
-        setStatus("processing");
-        const settled = await pollUntilSettled(
-          client,
-          created.id,
-          controller.signal
-        );
-        queryClient.setQueryData(mediaKeys.detail(created.id), settled);
-        void queryClient.invalidateQueries({ queryKey: mediaKeys.lists() });
-        setMedia(settled);
-        setStatus(settled.status === "failed" ? "failed" : "ready");
-        return settled;
-      } catch (caught) {
-        setError(caught);
-        setStatus("failed");
-        throw caught;
-      } finally {
-        if (abortRef.current === controller) {
-          abortRef.current = null;
+          throw uploadError;
         }
+      },
+      { retries: 3, signal }
+    );
+  }
+  callbacks.onProcessing();
+  return pollUntilSettled(client, created.id, signal, callbacks.onPoll);
+}
+function toFileArray(files) {
+  if (files instanceof File) return [files];
+  return Array.from(files);
+}
+function useMediaUpload(options) {
+  const { client, queryClient } = usePostrun();
+  const [items, setItems] = useState([]);
+  const controllers = useRef(/* @__PURE__ */ new Map());
+  const limitRef = useRef(null);
+  if (!limitRef.current) {
+    limitRef.current = pLimit(options?.concurrency ?? 3);
+  }
+  const patch = useCallback(
+    (id, changes) => {
+      setItems(
+        (current) => current.map(
+          (item) => item.id === id ? { ...item, ...changes } : item
+        )
+      );
+    },
+    []
+  );
+  const add = useCallback(
+    (files, uploadOptions) => {
+      const queued = toFileArray(files).map((file) => ({
+        id: crypto.randomUUID(),
+        file,
+        status: "uploading",
+        progress: 0,
+        media: null,
+        error: null
+      }));
+      setItems((current) => [...current, ...queued]);
+      const limit = limitRef.current;
+      if (!limit) {
+        return Promise.resolve([]);
       }
+      const settlements = queued.map((item) => {
+        const controller = new AbortController();
+        controllers.current.set(item.id, controller);
+        return limit(() => {
+          if (controller.signal.aborted) {
+            throw new DOMException("Upload aborted", "AbortError");
+          }
+          return runUpload(client, item.file, uploadOptions, controller.signal, {
+            onProgress: (progress) => patch(item.id, { progress }),
+            onProcessing: () => patch(item.id, { status: "processing" }),
+            // Live server progress (stage + percent) each poll tick.
+            onPoll: (media) => patch(item.id, { media })
+          });
+        }).then((settled) => {
+          patch(item.id, {
+            status: settled.status === "failed" ? "failed" : "ready",
+            media: settled,
+            progress: 1
+          });
+          queryClient.setQueryData(mediaKeys.detail(settled.id), settled);
+          void queryClient.invalidateQueries({ queryKey: mediaKeys.lists() });
+          return settled;
+        }).catch((error) => {
+          if (controller.signal.aborted) {
+            return null;
+          }
+          patch(item.id, { status: "failed", error });
+          return null;
+        }).finally(() => {
+          controllers.current.delete(item.id);
+        });
+      });
+      return Promise.all(settlements).then(
+        (results) => results.filter((result) => result !== null)
+      );
     },
-    [client, queryClient]
+    [client, queryClient, patch]
   );
-  const cancel = useCallback(() => abortRef.current?.abort(), []);
+  const remove = useCallback((id) => {
+    controllers.current.get(id)?.abort();
+    controllers.current.delete(id);
+    setItems((current) => current.filter((item) => item.id !== id));
+  }, []);
   const reset = useCallback(() => {
-    setStatus("idle");
-    setProgress(0);
-    setMedia(null);
-    setError(null);
+    controllers.current.forEach((controller) => controller.abort());
+    controllers.current.clear();
+    setItems([]);
   }, []);
-  return { upload, cancel, reset, status, progress, media, error };
+  const ready = items.flatMap(
+    (item) => item.status === "ready" && item.media ? [item.media] : []
+  );
+  const isUploading = items.some(
+    (item) => item.status === "uploading" || item.status === "processing"
+  );
+  return { items, ready, isUploading, add, remove, reset };
 }
 function useMedia(id) {
   const { client, queryClient } = usePostrun();
@@ -1317,6 +1578,6 @@ function LinkedInPostPreviewImpl({
 }
 var LinkedInPostPreview = memo(LinkedInPostPreviewImpl);
 
-export { LinkedInPostPreview, PostrunProvider, UploadError, XPostPreview, connectionKeys, mediaKeys, postKeys, profileKeys, useCalendar, useConnect, useConnection, useConnections, useCreatePost, useCreateProfile, useDeleteMedia, useDeletePost, useDeleteProfile, useDisconnect, useDiscoverableAccounts, useInfiniteList, useMedia, useMediaInfinite, useMediaList, useMediaUpload, usePost, usePostrun, usePosts, usePostsInfinite, useProfile, useProfiles, useProfilesInfinite, useSelectAccount, useUpdateMedia, useUpdatePost, useUpdateProfile };
+export { Connect, LinkedInPostPreview, PostrunProvider, UploadError, XPostPreview, connectionKeys, mediaKeys, postKeys, profileKeys, useCalendar, useConnect, useConnection, useConnections, useCreatePost, useCreateProfile, useDeleteMedia, useDeletePost, useDeleteProfile, useDisconnect, useDiscoverableAccounts, useInfiniteList, useMedia, useMediaInfinite, useMediaList, useMediaUpload, usePost, usePostrun, usePosts, usePostsInfinite, useProfile, useProfiles, useProfilesInfinite, useSelectAccount, useUpdateMedia, useUpdatePost, useUpdateProfile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map