@bigio/better-auth-electron 1.0.3 → 1.0.5

package/dist/server.js

@@ -2,7 +2,7 @@ import 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { createAuthEndpoint, sessionMiddleware, APIError, createAuthMiddleware } from 'better-auth/api';
-import z from 'zod';
+import z, { boolean } from 'zod';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -27,7 +27,8 @@ var defaultServerPluginOptions = {
   TICKET_NAME_IN_URL: "ticket",
   SCHEME_NAME_IN_URL: "scheme",
   PROVIDER_NAME_IN_URL: "provider",
-  CHALLENGE_NAME_IN_URL: "electron_challenge",
+  CHALLENGE_NAME_IN_URL: "electron-challenge",
+  AUTH_STATUS_NAME_IN_URL: "electron-status",
   TICKET_TTL_SEC: 60 * 5,
   ELECTRON_SESSION_DURATION: 7 * 24 * 60 * 60 * 1e3
   // customPreactJS: customPreactJS,
@@ -567,6 +568,7 @@ var AES_ALGO = { name: "AES-GCM", length: 128 };
 var secretKeyCache = /* @__PURE__ */ new Map();
 var MAX_CACHE_SIZE = 50;
 var GLOBAL_ENCODER = new TextEncoder();
+var GLOBAL_DECODER = new TextDecoder();
 async function getCachedKey(secret) {
   const checkSecret = okOr(secret, {
     msg: "Invalid secret input for getCachedKey",
@@ -766,7 +768,7 @@ async function decryptTicket(ticket, secret) {
       ctx: { ivLength: iv.byteLength, dataLength: data.byteLength }
     }
   );
-  const decodedString = new TextDecoder().decode(decryptedBuffer);
+  const decodedString = GLOBAL_DECODER.decode(decryptedBuffer);
   const rawJson = safeTry(() => JSON.parse(decodedString), {
     msg: "JSON Parsing Decrypted payload Failed",
     ctx: { len: decodedString.length, prefix: decodedString.slice(0, 10) }
@@ -812,15 +814,22 @@ async function pkceGenerateChallenge(verifier) {
   return encode64(hashBuffer);
 }
 var REGEX_BASE64_URL = /^[a-zA-Z0-9\-_]+=*$/;
-function SearchParamsZod(ELECTRON_SCHEME, PROVIDERS) {
+function RequiredSearchParamsBuilder(ELECTRON_SCHEME, PROVIDERS) {
   return z.object({
     scheme: z.string().min(1, "Scheme cannot be empty").regex(REGEX_BASE64_URL).refine((scheme) => scheme === ELECTRON_SCHEME, {
       message: "Invalid scheme provided"
     }),
     provider: z.enum(PROVIDERS),
-    challenge: z.string().length(43, "Challenge must be exactly 43 characters").regex(REGEX_BASE64_URL)
+    challenge: z.string().length(43, "Challenge must be exactly 43 characters").regex(REGEX_BASE64_URL),
+    status: z.enum(["succeed", "error", "newUser"]).optional()
   });
 }
+z.object({
+  scopes: z.array(z.string()).optional(),
+  loginHint: z.string().optional(),
+  additionalData: z.record(z.string(), z.any()).optional(),
+  requestSignUp: boolean().optional()
+});
 
 // src/server/electron-server-plugin.ts
 var REGEX_SAMESITE_LAX = /(?:^|;)\s*SameSite\s*=\s*Lax/gi;
@@ -871,11 +880,12 @@ var electronServerPlugin = (options) => {
     SCHEME_NAME_IN_URL,
     PROVIDER_NAME_IN_URL,
     CHALLENGE_NAME_IN_URL,
+    AUTH_STATUS_NAME_IN_URL,
     TICKET_TTL_SEC,
     ELECTRON_SESSION_DURATION,
     PROVIDERS,
     ELECTRON_APP_HOST} = config;
-  const searchParamsZod = SearchParamsZod(ELECTRON_SCHEME, PROVIDERS);
+  const searchParamsZod = RequiredSearchParamsBuilder(ELECTRON_SCHEME, PROVIDERS);
   const ticketZod = searchParamsZod.extend({
     userid: z.string().min(1, "User id cannot be empty").regex(REGEX_BASE64_URL2)
   });
@@ -905,24 +915,39 @@ var electronServerPlugin = (options) => {
                 return false;
               }
               const dummyURL = new URL(location, "http://dummy");
-              if (!dummyURL.pathname.includes(WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME)) {
+              console.log(dummyURL.pathname);
+              if (dummyURL.pathname !== `/${WEB_OAUTH_SIGNIN_CALLBACK_PATHNAME}`) {
                 return false;
               }
               const searchParams = safeTry(
                 () => searchParamsZod.parse({
                   scheme: dummyURL.searchParams.get(SCHEME_NAME_IN_URL),
                   provider: dummyURL.searchParams.get(PROVIDER_NAME_IN_URL),
-                  challenge: dummyURL.searchParams.get(CHALLENGE_NAME_IN_URL)
+                  challenge: dummyURL.searchParams.get(CHALLENGE_NAME_IN_URL),
+                  status: dummyURL.searchParams.get(AUTH_STATUS_NAME_IN_URL)
                 }),
                 new APIError("BAD_REQUEST", {
                   message: "Invalid OAuth callback parameters"
                 })
               );
-              const { scheme, provider, challenge } = searchParams;
-              const currentProvider = okOr(requestUrl.pathname.split("/").pop(), {
-                ctx: requestUrl
-              });
-              console.log(currentProvider, provider);
+              const { scheme, provider, challenge, status } = searchParams;
+              if (!status) {
+                return false;
+              }
+              const deepLinkURL = new URL(
+                `${ELECTRON_SCHEME}://${ELECTRON_CALLBACK_HOST_PATH}`
+              );
+              deepLinkURL.searchParams.set(AUTH_STATUS_NAME_IN_URL, status);
+              deepLinkURL.searchParams.set(CHALLENGE_NAME_IN_URL, challenge);
+              if (status === "error") {
+                return deepLinkURL;
+              }
+              const currentProvider = okOr(
+                requestUrl.pathname.split("/").filter(Boolean).pop(),
+                {
+                  ctx: requestUrl
+                }
+              );
               if (provider !== currentProvider) {
                 throw new APIError("FORBIDDEN", {
                   message: "CurrentProvider not match electron OAuth provider"
@@ -937,6 +962,7 @@ var electronServerPlugin = (options) => {
                 () => requireSetCookies(responseHeaders),
                 true
               );
+              responseHeaders.delete("set-cookie");
               const tokenMatch = okOr(
                 setCookieHeader.map((c) => c.match(SESSION_TOKEN_REGEX)).find((m) => m !== null),
                 new APIError("BAD_REQUEST", {
@@ -962,7 +988,8 @@ var electronServerPlugin = (options) => {
                       userid: userSession.user.id,
                       scheme,
                       provider,
-                      challenge
+                      challenge,
+                      status
                     },
                     ctx.context.secret,
                     TICKET_TTL_SEC
@@ -973,11 +1000,7 @@ var electronServerPlugin = (options) => {
                   message: "Failed to sign ticket"
                 })
               );
-              const deepLinkURL = new URL(
-                `${ELECTRON_SCHEME}://${ELECTRON_CALLBACK_HOST_PATH}`
-              );
               deepLinkURL.searchParams.set(TICKET_NAME_IN_URL, ticket);
-              deepLinkURL.searchParams.set(CHALLENGE_NAME_IN_URL, challenge);
               consoleLog("Deeplink URL:", deepLinkURL);
               return deepLinkURL;
             });
@@ -1008,7 +1031,6 @@ var electronServerPlugin = (options) => {
             if (!responseHeaders) {
               return;
             }
-            console.log(responseHeaders);
             const setCookieResult = safeTry(() => requireSetCookies(responseHeaders));
             if (!setCookieResult.data && setCookieResult.error) {
               return;
@@ -1129,7 +1151,7 @@ var electronServerPlugin = (options) => {
             })
           );
           const tokenConfig = ctx.context.authCookies.sessionToken;
-          const signIt = await safeTry(
+          await safeTry(
             ctx.setSignedCookie(
               tokenConfig.name,
               sessionForElectron.token,
@@ -1148,7 +1170,6 @@ var electronServerPlugin = (options) => {
               message: "Failed to set session cookie"
             })
           );
-          consoleLog("Signed Cookie: ", signIt);
           return ctx.json({
             session: {
               createdAt: sessionForElectron.createdAt,