@better-auth/electron 1.5.7-beta.1 → 1.6.0

package/dist/{client-D8BB_eSV.d.mts → client-D6xRwPM0.d.mts}

@@ -241,7 +241,14 @@ interface ElectronProxyClientOptions extends ElectronSharedClientOptions {
 //#region src/authenticate.d.ts
 declare const kElectron: unique symbol;
 declare const requestAuthOptionsSchema: z.ZodObject<{
-  [x: string]: any;
+  provider: z.ZodOptional<z.ZodString>;
+  callbackURL: z.ZodOptional<z.ZodString>;
+  newUserCallbackURL: z.ZodOptional<z.ZodString>;
+  errorCallbackURL: z.ZodOptional<z.ZodString>;
+  disableRedirect: z.ZodOptional<z.ZodBoolean>;
+  scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  requestSignUp: z.ZodOptional<z.ZodBoolean>;
+  additionalData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>;
 type ElectronRequestAuthOptions = z.infer<typeof requestAuthOptionsSchema>;
 /**
@@ -307,11 +314,13 @@ declare function handleDeepLink({
 //#region src/client.d.ts
 declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
   id: "electron";
+  version: string;
   fetchPlugins: {
     id: string;
     name: string;
     init(url: string, options: ({
       priority?: RequestPriority | undefined;
+      mode?: RequestMode | undefined;
       cache?: RequestCache | undefined;
       credentials?: RequestCredentials | undefined;
       headers?: (HeadersInit & (HeadersInit | {
@@ -322,7 +331,6 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
       integrity?: string | undefined;
       keepalive?: boolean | undefined;
       method?: string | undefined;
-      mode?: RequestMode | undefined;
       redirect?: RequestRedirect | undefined;
       referrer?: string | undefined;
       referrerPolicy?: ReferrerPolicy | undefined;
@@ -367,6 +375,7 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
       url: string;
       options: {
         priority?: RequestPriority | undefined;
+        mode?: RequestMode | undefined;
         cache?: RequestCache | undefined;
         credentials?: RequestCredentials | undefined;
         headers?: (HeadersInit & (HeadersInit | {
@@ -377,7 +386,6 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
         integrity?: string | undefined;
         keepalive?: boolean | undefined;
         method?: string | undefined;
-        mode?: RequestMode | undefined;
         redirect?: RequestRedirect | undefined;
         referrer?: string | undefined;
         referrerPolicy?: ReferrerPolicy | undefined;

package/dist/client.d.mts

@@ -1,2 +1,2 @@
-import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-D8BB_eSV.mjs";
+import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-D6xRwPM0.mjs";
 export { ElectronAuthenticateOptions, ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, ElectronSharedClientOptions, ElectronSharedOptions, ExposedBridges, FetchUserImageResult, SetupRendererConfig, Storage, authenticate, electronClient, fetchUserImage, handleDeepLink, kElectron, normalizeUserOutput, requestAuth, setupRenderer };

package/dist/client.mjs

@@ -1,4 +1,5 @@
-import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-CRzg_SlK.mjs";
+import { t as PACKAGE_VERSION } from "./version-Cf5gNNxE.mjs";
+import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-DxDKRT6e.mjs";
 import { BetterAuthError } from "@better-auth/core/error";
 import { base64, base64Url } from "@better-auth/utils/base64";
 import { APIError as APIError$1, getBaseURL, isDevelopment, isTest, safeJSONParse } from "better-auth";
@@ -596,6 +597,7 @@ const electronClient = (options) => {
 	if ((isDevelopment() || isTest()) && /^(?!\.)(?!.*\.\.)(?!.*\.$)[^.]+\.[^.]+$/.test(scheme)) console.warn("The provided scheme does not follow the reverse domain name notation. For example: `app.example.com` -> `com.example.app`.");
 	return {
 		id: "electron",
+		version: PACKAGE_VERSION,
 		fetchPlugins: [{
 			id: "electron",
 			name: "Electron",

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-D8BB_eSV.mjs";
+import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-D6xRwPM0.mjs";
 import * as better_auth0 from "better-auth";
+import * as z from "zod";
 import * as _better_auth_core0 from "@better-auth/core";
 import { HookEndpointContext } from "@better-auth/core";
 import * as better_call0 from "better-call";
@@ -14,16 +15,17 @@ declare module "@better-auth/core" {
 }
 declare const electron: (options?: ElectronOptions | undefined) => {
   id: "electron";
+  version: string;
   onRequest(request: Request, _ctx: better_auth0.AuthContext): Promise<{
     request: Request;
   } | undefined>;
   hooks: {
     after: ({
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<void>>;
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
     } | {
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<better_call0.MiddlewareContext<{
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
         returned?: unknown | undefined;
         responseHeaders?: Headers | undefined;
       } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
@@ -153,156 +155,171 @@ declare const electron: (options?: ElectronOptions | undefined) => {
         runInBackgroundOrAwait: (promise: Promise<unknown> | void) => better_auth0.Awaitable<unknown>;
       }> | {
         electron_authorization_code: string;
-      } | undefined>>;
+      } | undefined>;
     })[];
   };
   endpoints: {
-    electronToken: better_call0.Endpoint<"/electron/token", "POST", {
-      token: string;
-      state: string;
-      code_verifier: string;
-    }, Record<string, any> | undefined, [], {
-      token: string;
-      user: better_auth0.User & Record<string, any>;
-    }, {
-      scope: "http";
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    token: {
-                      type: string;
-                    };
-                    user: {
-                      type: string;
-                      $ref: string;
+    electronToken: better_call0.StrictEndpoint<"/electron/token", {
+      method: "POST";
+      body: z.ZodObject<{
+        token: z.ZodString;
+        state: z.ZodString;
+        code_verifier: z.ZodString;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      token: {
+                        type: string;
+                      };
+                      user: {
+                        type: string;
+                        $ref: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
-    electronInitOAuthProxy: better_call0.Endpoint<"/electron/init-oauth-proxy", "GET", undefined, {
-      provider: string;
-      state: string;
-      code_challenge: string;
-      code_challenge_method?: string | undefined;
-    }, [], {
-      url: string | undefined;
-      redirect: boolean;
-      user?: better_auth0.User & Record<string, any>;
-      token?: string;
-    } | undefined, {
-      scope: "http";
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    url: {
-                      type: string;
-                      nullable: boolean;
-                    };
-                    redirect: {
-                      type: string;
-                    };
-                    user: {
-                      type: string;
-                      $ref: string;
-                    };
-                    token: {
-                      type: string;
+    }, {
+      token: string;
+      user: better_auth0.User & Record<string, any>;
+    }>;
+    electronInitOAuthProxy: better_call0.StrictEndpoint<"/electron/init-oauth-proxy", {
+      method: "GET";
+      query: z.ZodObject<{
+        provider: z.ZodString;
+        state: z.ZodString;
+        code_challenge: z.ZodString;
+        code_challenge_method: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      url: {
+                        type: string;
+                        nullable: boolean;
+                      };
+                      redirect: {
+                        type: string;
+                      };
+                      user: {
+                        type: string;
+                        $ref: string;
+                      };
+                      token: {
+                        type: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
-    electronTransferUser: better_call0.Endpoint<"/electron/transfer-user", "POST", {
-      callbackURL?: string | undefined;
     }, {
-      client_id: string;
-      state: string;
-      code_challenge: string;
-      code_challenge_method?: string | undefined;
-    }, [better_call0.Middleware<(inputContext: Record<string, any>) => Promise<{
-      session: {
-        session: Record<string, any> & {
-          id: string;
-          createdAt: Date;
-          updatedAt: Date;
-          userId: string;
-          expiresAt: Date;
-          token: string;
-          ipAddress?: string | null | undefined;
-          userAgent?: string | null | undefined;
-        };
-        user: Record<string, any> & {
-          id: string;
-          createdAt: Date;
-          updatedAt: Date;
-          email: string;
-          emailVerified: boolean;
-          name: string;
-          image?: string | null | undefined;
-        };
-      };
-    }>>], {
-      url: string | null;
+      url: string | undefined;
       redirect: boolean;
-      electron_authorization_code: string;
-    }, {
-      openapi: {
-        description: string;
-        operationId: string;
-        responses: {
-          200: {
-            description: string;
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object";
-                  properties: {
-                    url: {
-                      type: string;
-                      nullable: boolean;
-                    };
-                    redirect: {
-                      type: string;
-                    };
-                    electron_authorization_code: {
-                      type: string;
+      user?: better_auth0.User & Record<string, any>;
+      token?: string;
+    } | undefined>;
+    electronTransferUser: better_call0.StrictEndpoint<"/electron/transfer-user", {
+      method: "POST";
+      query: z.ZodObject<{
+        client_id: z.ZodString;
+        state: z.ZodString;
+        code_challenge: z.ZodString;
+        code_challenge_method: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      body: z.ZodObject<{
+        callbackURL: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+        session: {
+          session: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          };
+          user: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        };
+      }>)[];
+      requireHeaders: true;
+      metadata: {
+        openapi: {
+          description: string;
+          operationId: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      url: {
+                        type: string;
+                        nullable: boolean;
+                      };
+                      redirect: {
+                        type: string;
+                      };
+                      electron_authorization_code: {
+                        type: string;
+                      };
                     };
+                    required: string[];
                   };
-                  required: string[];
                 };
               };
             };
           };
         };
       };
-    }, undefined>;
+    }, {
+      url: string | null;
+      redirect: boolean;
+      electron_authorization_code: string;
+    }>;
   };
   options: {
     codeExpiresIn: number;

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { t as PACKAGE_VERSION } from "./version-Cf5gNNxE.mjs";
 import { createAuthMiddleware } from "@better-auth/core/api";
 import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
 import { base64Url } from "@better-auth/utils/base64";
@@ -235,6 +236,7 @@ const electron = (options) => {
 	};
 	return {
 		id: "electron",
+		version: PACKAGE_VERSION,
 		async onRequest(request, _ctx) {
 			if (opts.disableOriginOverride || request.headers.get("origin")) return;
 			const electronOrigin = request.headers.get("electron-origin");