naystack 1.8.18 → 1.9.0

package/dist/socials/connect.d.ts

@@ -0,0 +1,70 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SocialProvider } from './provider.js';
+import { SocialPlatform, SocialProfile, SocialTokens } from './types.js';
+
+/**
+ * A freshly connected account, handed to `onConnect`.
+ *
+ * @property userId - Your app's user id from the state token; `null` when that token was invalid or expired.
+ *
+ * @category Socials
+ */
+interface SocialConnection {
+    platform: SocialPlatform;
+    profile: SocialProfile;
+    tokens: SocialTokens;
+    userId: number | null;
+}
+/**
+ * Options for {@link setupSocialAuth}.
+ *
+ * @property endpoint - Base URL this route is mounted at, e.g. `"https://yourapp.com/api/social"`. Each provider's redirect URI is `<endpoint>/<platform>` and must be registered with that platform verbatim.
+ * @property onConnect - Return a string to show as an error (redirects to `errorRedirectURL`); return `void` on success.
+ * @property scopes - Per-platform permissions; each provider has its own default.
+ *
+ * @category Socials
+ */
+interface SetupSocialAuthOptions {
+    providers: SocialProvider[];
+    endpoint: string;
+    onConnect: (connection: SocialConnection) => Promise<string | void>;
+    redirectURL: string;
+    errorRedirectURL: string;
+    scopes?: Partial<Record<SocialPlatform, string[]>>;
+}
+/**
+ * One OAuth route for every platform a user can connect.
+ *
+ * Mount the GET handler on a dynamic segment — `app/api/social/[platform]/route.ts`
+ * — and `/api/social/instagram`, `/api/social/youtube`, … are the same handler. It
+ * serves both the connect entry point (`?state`, no code → 302 to the platform's
+ * authorize URL) and the callback (`?code`).
+ *
+ * @example
+ * ```ts
+ * // app/api/social/[platform]/route.ts
+ * import { InstagramProvider, setupSocialAuth } from "naystack/socials";
+ *
+ * export const { GET } = setupSocialAuth({
+ *   providers: [InstagramProvider],
+ *   endpoint: "https://yourapp.com/api/social",
+ *   redirectURL: "/profile",
+ *   errorRedirectURL: "/signup",
+ *   onConnect: async ({ platform, profile, tokens, userId }) => {
+ *     if (!userId) return "You are not logged in";
+ *     await saveSocialAccount(userId, platform, profile, tokens);
+ *   },
+ * });
+ * ```
+ *
+ * @category Socials
+ */
+declare function setupSocialAuth({ providers, endpoint, onConnect, redirectURL, errorRedirectURL, scopes, }: SetupSocialAuthOptions): {
+    GET: (req: NextRequest, ctx: {
+        params: Promise<{
+            platform: string;
+        }>;
+    }) => Promise<NextResponse<unknown>>;
+};
+
+export { type SetupSocialAuthOptions, type SocialConnection, setupSocialAuth };

package/dist/socials/connect.esm.js

@@ -0,0 +1,126 @@
+// src/socials/connect.ts
+import { NextResponse as NextResponse2 } from "next/server";
+
+// src/auth/email/token.ts
+import { compare } from "bcryptjs";
+import { JsonWebTokenError, sign, verify } from "jsonwebtoken";
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import { NextResponse } from "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 = verify(accessToken, getEnv("SIGNING_KEY" /* SIGNING_KEY */));
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/socials/connect.ts
+function setupSocialAuth({
+  providers,
+  endpoint,
+  onConnect,
+  redirectURL,
+  errorRedirectURL,
+  scopes
+}) {
+  const handleError = (message) => NextResponse2.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 NextResponse2.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 NextResponse2.redirect(redirectURL);
+  };
+  return { GET };
+}
+export {
+  setupSocialAuth
+};