@better-auth/electron 1.5.0-beta.13 → 1.5.0-beta.16

package/dist/browser-CCZQ2aoV.d.mts

@@ -0,0 +1,311 @@
+import * as z from "zod";
+import { BetterFetch, BetterFetchError, CreateFetchOption } from "@better-fetch/fetch";
+import electron from "electron";
+import { Awaitable, BetterAuthClientOptions } from "@better-auth/core";
+import { User } from "@better-auth/core/db";
+
+//#region src/types/options.d.ts
+interface ElectronSharedOptions {
+  /**
+   * Client ID to use for identifying the Electron client during authorization.
+   *
+   * @default "electron"
+   */
+  clientID?: string | undefined;
+}
+interface ElectronOptions extends ElectronSharedOptions {
+  /**
+   * The duration (in seconds) for which the authorization code remains valid.
+   *
+   * @default 300 (5 minutes)
+   */
+  codeExpiresIn?: number | undefined;
+  /**
+   * The duration (in seconds) for which the redirect cookie remains valid.
+   *
+   * @default 120 (2 minutes)
+   */
+  redirectCookieExpiresIn?: number | undefined;
+  /**
+   * The prefix to use for cookies set by the plugin.
+   *
+   * @default "better-auth"
+   */
+  cookiePrefix?: string | undefined;
+  /**
+   * Override the origin for Electron API routes.
+   * Enable this if you're facing cors origin issues with Electron API routes.
+   *
+   * @default false
+   */
+  disableOriginOverride?: boolean | undefined;
+}
+//#endregion
+//#region src/preload.d.ts
+type ExposedBridges<O extends ElectronClientOptions> = ReturnType<typeof exposeBridges<O>>["$InferBridges"];
+/**
+ * Exposes IPC bridges to the renderer process.
+ */
+declare function exposeBridges<O extends ElectronClientOptions>(opts: SetupRendererConfig<O>): {
+  $InferBridges: {
+    getUser: () => Promise<(O["sanitizeUser"] extends ((user: User & Record<string, any>) => Awaitable<User & Record<string, any>>) ? Awaited<ReturnType<O["sanitizeUser"]>> : {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+    } & Record<string, any>) | null>;
+    requestAuth: (options?: ElectronRequestAuthOptions) => Promise<void>;
+    signOut: () => Promise<void>;
+    authenticate: (data: {
+      token: string;
+    }) => Promise<void>;
+    onAuthenticated: (callback: (user: O["sanitizeUser"] extends ((user: User & Record<string, any>) => Awaitable<User & Record<string, any>>) ? Awaited<ReturnType<O["sanitizeUser"]>> : {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+    } & Record<string, any>) => unknown) => () => void;
+    onUserUpdated: (callback: (user: (O["sanitizeUser"] extends ((user: User & Record<string, any>) => Awaitable<User & Record<string, any>>) ? Awaited<ReturnType<O["sanitizeUser"]>> : {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined;
+    } & Record<string, any>) | null) => unknown) => () => void;
+    onAuthError: (callback: (context: BetterFetchError & {
+      path: string;
+    }) => unknown) => () => void;
+  };
+};
+interface SetupRendererConfig<O extends ElectronClientOptions = ElectronClientOptions> {
+  channelPrefix?: O["channelPrefix"] | undefined;
+}
+/**
+ * Sets up the renderer process.
+ *
+ * - Exposes IPC bridges to the renderer process.
+ */
+declare function setupRenderer(options?: SetupRendererConfig): void;
+//#endregion
+//#region src/user.d.ts
+type FetchUserImageResult = {
+  stream: ReadableStream<Uint8Array>;
+  mimeType: string;
+};
+declare function fetchUserImage(baseURL: string | undefined, url: string, options?: Pick<ElectronClientOptions, "userImageProxy"> | undefined): Promise<FetchUserImageResult | null>;
+declare function normalizeUserOutput<U extends User & Record<string, any>>(user: U, options?: ElectronClientOptions | undefined): U;
+//#endregion
+//#region src/types/client.d.ts
+interface Storage {
+  getItem: (name: string) => unknown | null;
+  setItem: (name: string, value: unknown) => void;
+}
+interface ElectronSharedClientOptions extends ElectronSharedOptions {
+  /**
+   * The protocol scheme to use for deep linking in Electron.
+   *
+   * Should follow the reverse domain name notation to ensure uniqueness.
+   *
+   * @see {@link https://datatracker.ietf.org/doc/html/rfc8252#section-7.1}
+   * @example "com.example.app"
+   */
+  protocol: string | {
+    scheme: string;
+  };
+  /**
+   * The callback path to use for authentication redirects.
+   *
+   * @default "/auth/callback"
+   */
+  callbackPath?: string;
+}
+interface ElectronClientOptions extends ElectronSharedClientOptions {
+  /**
+   * The URL to redirect to for authentication.
+   *
+   * @example "http://localhost:3000/sign-in"
+   */
+  signInURL: string | URL;
+  protocol: string | {
+    scheme: string;
+    privileges?: Electron.Privileges | undefined;
+  };
+  /**
+   * An instance of a storage solution (e.g., `conf`)
+   * to store session and cookie data.
+   *
+   * @example
+   * ```ts
+   * import { storage } from "@better-auth/electron/storage";
+   * electronClient({
+   *   storage: storage(),
+   * });
+   * ```
+   */
+  storage: Storage;
+  /**
+   * Prefix for local storage keys (e.g., "my-app_cookie", "my-app_session_data")
+   * @default "better-auth"
+   */
+  storagePrefix?: string | undefined;
+  /**
+   * A function to sanitize the user object before it is sent to the renderer process.
+   *
+   * @default undefined
+   */
+  sanitizeUser?: ((user: User & Record<string, any>) => Awaitable<User & Record<string, any>>) | undefined;
+  /**
+   * User image proxy configuration.
+   */
+  userImageProxy?: {
+    /**
+     * Whether to enable user image proxy.
+     *
+     * @default true
+     */
+    enabled?: boolean | undefined;
+    /**
+     * The protocol scheme to use for user image proxy.
+     *
+     * @default "user-image"
+     */
+    scheme?: string | undefined;
+    /**
+     * The maximum size of user images in bytes.
+     *
+     * @default 1024 * 1024 * 5 (5MB)
+     */
+    maxSize?: number | undefined;
+    /**
+     * Allowed image mime types that should be passed to Accept header.
+     *
+     * @default "image/*"
+     */
+    accept?: string | undefined;
+    /**
+     * Custom user image validator.
+     *
+     * Note: This will override the default validator, and can have security implications if not handled properly.
+     * Only use this if you know what you are doing.
+     *
+     * @param bytes The user image bytes.
+     * @returns The image mime type or null if the image is not valid.
+     */
+    customValidator?: (bytes: Uint8Array) => Awaitable<string | null>;
+  } | undefined;
+  /**
+   * Prefix(es) for server cookie names to filter (e.g., "better-auth.session_token")
+   * This is used to identify which cookies belong to better-auth to prevent
+   * infinite refetching when third-party cookies are set.
+   *
+   * Can be a single string or an array of strings to match multiple prefixes.
+   *
+   * @default "better-auth"
+   * @example "better-auth"
+   * @example ["better-auth", "my-app"]
+   */
+  cookiePrefix?: string | string[] | undefined;
+  /**
+   * Channel prefix for IPC bridges (e.g., "better-auth:request-auth")
+   *
+   * @default "better-auth"
+   */
+  channelPrefix?: string | undefined;
+  /**
+   * Whether to disable caching the session data locally.
+   *
+   * @default false
+   */
+  disableCache?: boolean | undefined;
+}
+interface ElectronProxyClientOptions extends ElectronSharedClientOptions {
+  /**
+   * The prefix to use for cookies set by the plugin.
+   *
+   * @default "better-auth"
+   */
+  cookiePrefix?: string | undefined;
+}
+//#endregion
+//#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>>;
+}, z.core.$strip>;
+type ElectronRequestAuthOptions = z.infer<typeof requestAuthOptionsSchema>;
+/**
+ * Opens the system browser to request user authentication.
+ */
+declare function requestAuth(clientOptions: BetterAuthClientOptions | undefined, options: ElectronClientOptions, cfg?: ElectronRequestAuthOptions | undefined): Promise<void>;
+interface ElectronAuthenticateOptions {
+  fetchOptions?: Omit<CreateFetchOption, "method"> | undefined;
+  token: string;
+}
+/**
+ * Exchanges the authorization code for a session.
+ */
+declare function authenticate({
+  $fetch,
+  options,
+  token,
+  getWindow,
+  fetchOptions
+}: ElectronAuthenticateOptions & {
+  $fetch: BetterFetch;
+  options: ElectronClientOptions;
+  getWindow: () => Electron.BrowserWindow | null | undefined;
+}): Promise<{
+  data: null;
+  error: {
+    message?: string | undefined;
+    status: number;
+    statusText: string;
+  };
+} | {
+  data: {
+    token: string;
+    user: User & Record<string, any>;
+  };
+  error: null;
+}>;
+//#endregion
+//#region src/browser.d.ts
+type SetupMainConfig = {
+  getWindow?: () => electron.BrowserWindow | null | undefined;
+  csp?: boolean | undefined;
+  bridges?: boolean | undefined;
+  scheme?: boolean | undefined;
+};
+/**
+ * Handles the deep link URL for authentication.
+ */
+declare function handleDeepLink({
+  $fetch,
+  options,
+  url,
+  getWindow,
+  clientOptions
+}: {
+  $fetch: BetterFetch;
+  options: ElectronClientOptions;
+  url: string;
+  getWindow?: SetupMainConfig["getWindow"] | undefined;
+  clientOptions?: BetterAuthClientOptions | undefined;
+}): Promise<void>;
+//#endregion
+export { ElectronOptions as _, kElectron as a, ElectronProxyClientOptions as c, FetchUserImageResult as d, fetchUserImage as f, setupRenderer as g, SetupRendererConfig as h, authenticate as i, ElectronSharedClientOptions as l, ExposedBridges as m, ElectronAuthenticateOptions as n, requestAuth as o, normalizeUserOutput as p, ElectronRequestAuthOptions as r, ElectronClientOptions as s, handleDeepLink as t, Storage as u, ElectronSharedOptions as v };

package/dist/client.d.mts

@@ -1,3 +1,194 @@
-import { i as Storage, n as ElectronClientOptions, r as ElectronProxyClientOptions, t as ElectronRequestAuthOptions } from "./authenticate-CWAVJ4W8.mjs";
-import { n as handleDeepLink, t as electronClient } from "./client-BBp9yCmE.mjs";
-export { ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, Storage, electronClient, handleDeepLink };
+import { a as kElectron, c as ElectronProxyClientOptions, d as FetchUserImageResult, f as fetchUserImage, g as setupRenderer, h as SetupRendererConfig, i as authenticate, l as ElectronSharedClientOptions, m as ExposedBridges, n as ElectronAuthenticateOptions, o as requestAuth, p as normalizeUserOutput, r as ElectronRequestAuthOptions, s as ElectronClientOptions, t as handleDeepLink, u as Storage, v as ElectronSharedOptions } from "./browser-CCZQ2aoV.mjs";
+import * as better_auth0 from "better-auth";
+import { ClientStore } from "better-auth";
+import * as _better_fetch_fetch0 from "@better-fetch/fetch";
+import electron from "electron";
+
+//#region src/client.d.ts
+declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
+  id: "electron";
+  fetchPlugins: {
+    id: string;
+    name: string;
+    init(url: string, options: ({
+      cache?: RequestCache | undefined;
+      credentials?: RequestCredentials | undefined;
+      headers?: (HeadersInit & (HeadersInit | {
+        accept: "application/json" | "text/plain" | "application/octet-stream";
+        "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+        authorization: "Bearer" | "Basic";
+      })) | undefined;
+      integrity?: string | undefined;
+      keepalive?: boolean | undefined;
+      method?: string | undefined;
+      mode?: RequestMode | undefined;
+      priority?: RequestPriority | undefined;
+      redirect?: RequestRedirect | undefined;
+      referrer?: string | undefined;
+      referrerPolicy?: ReferrerPolicy | undefined;
+      signal?: (AbortSignal | null) | undefined;
+      window?: null | undefined;
+      onRequest?: (<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>) => Promise<_better_fetch_fetch0.RequestContext | void> | _better_fetch_fetch0.RequestContext | void) | undefined;
+      onResponse?: ((context: _better_fetch_fetch0.ResponseContext) => Promise<Response | void | _better_fetch_fetch0.ResponseContext> | Response | _better_fetch_fetch0.ResponseContext | void) | undefined;
+      onSuccess?: ((context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
+      onError?: ((context: _better_fetch_fetch0.ErrorContext) => Promise<void> | void) | undefined;
+      onRetry?: ((response: _better_fetch_fetch0.ResponseContext) => Promise<void> | void) | undefined;
+      hookOptions?: {
+        cloneResponse?: boolean;
+      } | undefined;
+      timeout?: number | undefined;
+      customFetchImpl?: _better_fetch_fetch0.FetchEsque | undefined;
+      plugins?: _better_fetch_fetch0.BetterFetchPlugin[] | undefined;
+      baseURL?: string | undefined;
+      throw?: boolean | undefined;
+      auth?: ({
+        type: "Bearer";
+        token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+      } | {
+        type: "Basic";
+        username: string | (() => string | undefined) | undefined;
+        password: string | (() => string | undefined) | undefined;
+      } | {
+        type: "Custom";
+        prefix: string | (() => string | undefined) | undefined;
+        value: string | (() => string | undefined) | undefined;
+      }) | undefined;
+      body?: any;
+      query?: any;
+      params?: any;
+      duplex?: "full" | "half" | undefined;
+      jsonParser?: ((text: string) => Promise<any> | any) | undefined;
+      retry?: _better_fetch_fetch0.RetryOptions | undefined;
+      retryAttempt?: number | undefined;
+      output?: (_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+      errorSchema?: _better_fetch_fetch0.StandardSchemaV1 | undefined;
+      disableValidation?: boolean | undefined;
+    } & Record<string, any>) | undefined): Promise<{
+      url: string;
+      options: {
+        cache?: RequestCache | undefined;
+        credentials?: RequestCredentials | undefined;
+        headers?: (HeadersInit & (HeadersInit | {
+          accept: "application/json" | "text/plain" | "application/octet-stream";
+          "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+          authorization: "Bearer" | "Basic";
+        })) | undefined;
+        integrity?: string | undefined;
+        keepalive?: boolean | undefined;
+        method?: string | undefined;
+        mode?: RequestMode | undefined;
+        priority?: RequestPriority | undefined;
+        redirect?: RequestRedirect | undefined;
+        referrer?: string | undefined;
+        referrerPolicy?: ReferrerPolicy | undefined;
+        signal?: (AbortSignal | null) | undefined;
+        window?: null | undefined;
+        onRequest?: (<T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>) => Promise<_better_fetch_fetch0.RequestContext | void> | _better_fetch_fetch0.RequestContext | void) | undefined;
+        onResponse?: ((context: _better_fetch_fetch0.ResponseContext) => Promise<Response | void | _better_fetch_fetch0.ResponseContext> | Response | _better_fetch_fetch0.ResponseContext | void) | undefined;
+        onSuccess?: ((context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
+        onError?: ((context: _better_fetch_fetch0.ErrorContext) => Promise<void> | void) | undefined;
+        onRetry?: ((response: _better_fetch_fetch0.ResponseContext) => Promise<void> | void) | undefined;
+        hookOptions?: {
+          cloneResponse?: boolean;
+        } | undefined;
+        timeout?: number | undefined;
+        customFetchImpl?: _better_fetch_fetch0.FetchEsque | undefined;
+        plugins?: _better_fetch_fetch0.BetterFetchPlugin[] | undefined;
+        baseURL?: string | undefined;
+        throw?: boolean | undefined;
+        auth?: ({
+          type: "Bearer";
+          token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+        } | {
+          type: "Basic";
+          username: string | (() => string | undefined) | undefined;
+          password: string | (() => string | undefined) | undefined;
+        } | {
+          type: "Custom";
+          prefix: string | (() => string | undefined) | undefined;
+          value: string | (() => string | undefined) | undefined;
+        }) | undefined;
+        body?: any;
+        query?: any;
+        params?: any;
+        duplex?: "full" | "half" | undefined;
+        jsonParser?: ((text: string) => Promise<any> | any) | undefined;
+        retry?: _better_fetch_fetch0.RetryOptions | undefined;
+        retryAttempt?: number | undefined;
+        output?: (_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: _better_fetch_fetch0.StandardSchemaV1 | undefined;
+        disableValidation?: boolean | undefined;
+      } & Record<string, any>;
+    }>;
+    hooks: {
+      onSuccess: (context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void>;
+      onError: (context: _better_fetch_fetch0.ErrorContext) => Promise<void>;
+    };
+  }[];
+  getActions: ($fetch: _better_fetch_fetch0.BetterFetch, $store: ClientStore, clientOptions: better_auth0.BetterAuthClientOptions | undefined) => {
+    /**
+     * Gets the stored cookie.
+     *
+     * You can use this to get the cookie stored in
+     * the device and use it in your fetch requests.
+     *
+     * @example
+     * ```ts
+     * const cookie = client.getCookie();
+     * await fetch("https://api.example.com", {
+     *   headers: {
+     *    cookie,
+     *   },
+     * });
+     * ```
+     */
+    getCookie: () => string;
+    /**
+     * Exchanges the authorization code for a session.
+     *
+     * Use this when you need to manually complete the exchange
+     * (e.g., when another app registered the scheme or deep linking fails).
+     *
+     * The authorization code is returned when the user is authorized in the browser. (`electron_authorization_code`)
+     *
+     * Note: Must be called after `requestAuth`, since the code verifier and state are stored when the auth flow is initiated.
+     */
+    authenticate: (data: ElectronAuthenticateOptions) => Promise<{
+      data: null;
+      error: {
+        message?: string | undefined;
+        status: number;
+        statusText: string;
+      };
+    } | {
+      data: {
+        token: string;
+        user: better_auth0.User & Record<string, any>;
+      };
+      error: null;
+    }>;
+    /**
+     * Initiates the authentication process.
+     * Opens the system's default browser for user authentication.
+     */
+    requestAuth: (options?: ElectronRequestAuthOptions | undefined) => Promise<void>;
+    /**
+     * Sets up the main process.
+     *
+     * - Registers custom protocol scheme.
+     * - Registers IPC bridge handlers.
+     * - Handles content security policy if needed.
+     */
+    setupMain: (cfg?: {
+      csp?: boolean | undefined;
+      bridges?: boolean | undefined;
+      scheme?: boolean | undefined;
+      getWindow?: () => electron.BrowserWindow | null | undefined;
+    }) => void;
+    $Infer: {
+      Bridges: ExposedBridges<O>;
+    };
+  };
+};
+//#endregion
+export { ElectronAuthenticateOptions, ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, ElectronSharedClientOptions, ElectronSharedOptions, ExposedBridges, FetchUserImageResult, SetupRendererConfig, Storage, authenticate, electronClient, fetchUserImage, handleDeepLink, kElectron, normalizeUserOutput, requestAuth, setupRenderer };