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

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

@@ -241,14 +241,7 @@ interface ElectronProxyClientOptions extends ElectronSharedClientOptions {
 //#region src/authenticate.d.ts
 declare const kElectron: unique symbol;
 declare const requestAuthOptionsSchema: z.ZodObject<{
-  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>>;
+  [x: string]: any;
 }, z.core.$strip>;
 type ElectronRequestAuthOptions = z.infer<typeof requestAuthOptionsSchema>;
 /**

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-DVs5eLfi.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-D8BB_eSV.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,4 @@
-import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-DecLU66o.mjs";
+import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-CRzg_SlK.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";
@@ -11,7 +11,6 @@ import { parseSetCookieHeader } from "better-auth/cookies";
 import electron, { shell } from "electron";
 import { isDevelopment as isDevelopment$1 } from "@better-auth/core/env";
 import { resolve } from "node:path";
-
 //#region src/user.ts
 const { net } = electron;
 const DEFAULT_MAX_BYTES = 1024 * 1024 * 5;
@@ -151,7 +150,6 @@ function detectImageType(bytes) {
 	if (brand === "heix" || brand === "hevc" || brand === "mif1" || brand === "msf1") return "image/heic";
 	return null;
 }
-
 //#endregion
 //#region src/authenticate.ts
 const kElectron = Symbol.for("better-auth:electron");
@@ -224,7 +222,6 @@ async function authenticate({ $fetch, options, token, getWindow, fetchOptions })
 		}
 	});
 }
-
 //#endregion
 //#region src/browser.ts
 const { app: app$1, session, protocol, BrowserWindow, ipcMain, webContents: webContents$1 } = electron;
@@ -467,7 +464,6 @@ function setupUserImageProxy(ctx, opts, clientOptions) {
 		});
 	});
 }
-
 //#endregion
 //#region src/cookies.ts
 function getSetCookie(header, prevCookie) {
@@ -553,7 +549,6 @@ function hasBetterAuthCookies(setCookieHeader, cookiePrefix) {
 	}
 	return false;
 }
-
 //#endregion
 //#region src/client.ts
 const { app, safeStorage, webContents } = electron;
@@ -683,6 +678,5 @@ const electronClient = (options) => {
 		}
 	};
 };
-
 //#endregion
-export { electronClient, handleDeepLink, normalizeUserOutput };
+export { electronClient, handleDeepLink, normalizeUserOutput };

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-DVs5eLfi.mjs";
+import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-D8BB_eSV.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";
@@ -21,10 +20,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
   hooks: {
     after: ({
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<void>>;
     } | {
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
+      handler: better_call0.Middleware<(inputContext: Record<string, any>) => Promise<better_call0.MiddlewareContext<{
         returned?: unknown | undefined;
         responseHeaders?: Headers | undefined;
       } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
@@ -154,171 +153,156 @@ 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.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[];
-                  };
-                };
-              };
-            };
-          };
-        };
-      };
-    }, {
+    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>;
-    }>;
-    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;
-                      };
+    }, {
+      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>;
-    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;
-                      };
+    } | 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;
                     };
-                    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;
       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;
+                    };
+                  };
+                  required: string[];
+                };
+              };
+            };
+          };
+        };
+      };
+    }, undefined>;
   };
   options: {
     codeExpiresIn: number;

package/dist/index.mjs

@@ -13,7 +13,6 @@ import { betterFetch } from "@better-fetch/fetch";
 import { createAuthEndpoint, sessionMiddleware } from "better-auth/api";
 import { setSessionCookie } from "better-auth/cookies";
 import { parseUserOutput } from "better-auth/db";
-
 //#region src/error-codes.ts
 const ELECTRON_ERROR_CODES = defineErrorCodes({
 	INVALID_CLIENT_ID: "Invalid client ID",
@@ -24,7 +23,6 @@ const ELECTRON_ERROR_CODES = defineErrorCodes({
 	MISSING_STATE: "state is required",
 	MISSING_PKCE: "pkce is required"
 });
-
 //#endregion
 //#region src/routes.ts
 const electronTokenBodySchema = z.object({
@@ -191,7 +189,6 @@ const electronTransferUser = (_opts, { handleTransfer }) => createAuthEndpoint("
 		electron_authorization_code: identifier
 	});
 });
-
 //#endregion
 //#region src/index.ts
 const electron = (options) => {
@@ -298,6 +295,5 @@ const electron = (options) => {
 		$ERROR_CODES: ELECTRON_ERROR_CODES
 	};
 };
-
 //#endregion
-export { electron };
+export { electron };