@better-auth/core 1.3.27 → 1.3.29

package/dist/index.d.ts

@@ -1,124 +1,179 @@
-import { L as LiteralUnion, M as Models } from './shared/core.CnvFgghY.js';
-export { a as LiteralString } from './shared/core.CnvFgghY.js';
-import { CookieOptions } from 'better-call';
+import { L as LiteralString } from './shared/core.CajxAutx.js';
+export { a as LiteralUnion } from './shared/core.CajxAutx.js';
+import { A as AuthContext, B as BetterAuthOptions, a as AuthMiddleware } from './shared/core.Bshk2o_x.js';
+export { b as BetterAuthAdvancedOptions, d as BetterAuthCookies, c as BetterAuthRateLimitOptions, G as GenerateIdFn, e as GenericEndpointContext, I as InternalAdapter } from './shared/core.Bshk2o_x.js';
+import { Migration } from 'kysely';
+import { Endpoint, Middleware, EndpointContext, InputContext } from 'better-call';
+import { B as BetterAuthPluginDBSchema } from './shared/core.Bqe5IGAi.js';
+import { BetterFetch, BetterFetchOption, BetterFetchPlugin } from '@better-fetch/fetch';
+import { WritableAtom, Atom } from 'nanostores';
 import 'zod';
+import './shared/core.Dl-70uns.js';
+import 'bun:sqlite';
+import 'node:sqlite';
+import './social-providers/index.js';
+import '@better-auth/core/oauth2';
+import './shared/core.DkdZ1o38.js';
+import './shared/core.BwoNUcJQ.js';
+import '@better-auth/core';
 
-type GenerateIdFn = (options: {
-    model: LiteralUnion<Models, string>;
-    size?: number;
-}) => string | false;
-type BetterAuthAdvancedOptions = {
+type Awaitable<T> = T | Promise<T>;
+type DeepPartial<T> = T extends Function ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+type HookEndpointContext = EndpointContext<string, any> & Omit<InputContext<string, any>, "method"> & {
+    context: AuthContext & {
+        returned?: unknown;
+        responseHeaders?: Headers;
+    };
+    headers?: Headers;
+};
+type BetterAuthPlugin = {
+    id: LiteralString;
     /**
-     * Ip address configuration
+     * The init function is called when the plugin is initialized.
+     * You can return a new context or modify the existing context.
      */
-    ipAddress?: {
-        /**
-         * List of headers to use for ip address
-         *
-         * Ip address is used for rate limiting and session tracking
-         *
-         * @example ["x-client-ip", "x-forwarded-for", "cf-connecting-ip"]
-         *
-         * @default
-         * @link https://github.com/better-auth/better-auth/blob/main/packages/better-auth/src/utils/get-request-ip.ts#L8
-         */
-        ipAddressHeaders?: string[];
-        /**
-         * Disable ip tracking
-         *
-         * ⚠︎ This is a security risk and it may expose your application to abuse
-         */
-        disableIpTracking?: boolean;
+    init?: (ctx: AuthContext) => Awaitable<{
+        context?: DeepPartial<Omit<AuthContext, "options">>;
+        options?: Partial<BetterAuthOptions>;
+    }> | void | Promise<void>;
+    endpoints?: {
+        [key: string]: Endpoint;
+    };
+    middlewares?: {
+        path: string;
+        middleware: Middleware;
+    }[];
+    onRequest?: (request: Request, ctx: AuthContext) => Promise<{
+        response: Response;
+    } | {
+        request: Request;
+    } | void>;
+    onResponse?: (response: Response, ctx: AuthContext) => Promise<{
+        response: Response;
+    } | void>;
+    hooks?: {
+        before?: {
+            matcher: (context: HookEndpointContext) => boolean;
+            handler: AuthMiddleware;
+        }[];
+        after?: {
+            matcher: (context: HookEndpointContext) => boolean;
+            handler: AuthMiddleware;
+        }[];
     };
     /**
-     * Use secure cookies
+     * Schema the plugin needs
+     *
+     * This will also be used to migrate the database. If the fields are dynamic from the plugins
+     * configuration each time the configuration is changed a new migration will be created.
      *
-     * @default false
+     * NOTE: If you want to create migrations manually using
+     * migrations option or any other way you
+     * can disable migration per table basis.
+     *
+     * @example
+     * ```ts
+     * schema: {
+     * 	user: {
+     * 		fields: {
+     * 			email: {
+     * 				 type: "string",
+     * 			},
+     * 			emailVerified: {
+     * 				type: "boolean",
+     * 				defaultValue: false,
+     * 			},
+     * 		},
+     * 	}
+     * } as AuthPluginSchema
+     * ```
      */
-    useSecureCookies?: boolean;
+    schema?: BetterAuthPluginDBSchema;
     /**
-     * Disable trusted origins check
+     * The migrations of the plugin. If you define schema that will automatically create
+     * migrations for you.
      *
-     * ⚠︎ This is a security risk and it may expose your application to CSRF attacks
+     * ⚠️ Only uses this if you dont't want to use the schema option and you disabled migrations for
+     * the tables.
      */
-    disableCSRFCheck?: boolean;
+    migrations?: Record<string, Migration>;
     /**
-     * Configure cookies to be cross subdomains
+     * The options of the plugin
      */
-    crossSubDomainCookies?: {
-        /**
-         * Enable cross subdomain cookies
-         */
-        enabled: boolean;
-        /**
-         * Additional cookies to be shared across subdomains
-         */
-        additionalCookies?: string[];
-        /**
-         * The domain to use for the cookies
-         *
-         * By default, the domain will be the root
-         * domain from the base URL.
-         */
-        domain?: string;
-    };
-    cookies?: {
-        [key: string]: {
-            name?: string;
-            attributes?: CookieOptions;
-        };
-    };
-    defaultCookieAttributes?: CookieOptions;
+    options?: Record<string, any> | undefined;
     /**
-     * Prefix for cookies. If a cookie name is provided
-     * in cookies config, this will be overridden.
-     *
-     * @default
-     * ```txt
-     * "appName" -> which defaults to "better-auth"
-     * ```
+     * types to be inferred
      */
-    cookiePrefix?: string;
+    $Infer?: Record<string, any>;
     /**
-     * Database configuration.
+     * The rate limit rules to apply to specific paths.
      */
-    database?: {
-        /**
-         * The default number of records to return from the database
-         * when using the `findMany` adapter method.
-         *
-         * @default 100
-         */
-        defaultFindManyLimit?: number;
-        /**
-         * If your database auto increments number ids, set this to `true`.
-         *
-         * Note: If enabled, we will not handle ID generation (including if you use `generateId`), and it would be expected that your database will provide the ID automatically.
-         *
-         * @default false
-         */
-        useNumberId?: boolean;
-        /**
-         * Custom generateId function.
-         *
-         * If not provided, random ids will be generated.
-         * If set to false, the database's auto generated id will be used.
-         */
-        generateId?: GenerateIdFn | false;
-    };
+    rateLimit?: {
+        window: number;
+        max: number;
+        pathMatcher: (path: string) => boolean;
+    }[];
     /**
-     * Custom generateId function.
-     *
-     * If not provided, random ids will be generated.
-     * If set to false, the database's auto generated id will be used.
-     *
-     * @deprecated Please use `database.generateId` instead. This will be potentially removed in future releases.
+     * The error codes returned by the plugin
      */
-    generateId?: GenerateIdFn | false;
+    $ERROR_CODES?: Record<string, string>;
 };
 
-interface BetterAuthMutators<O, C> {
+interface ClientStore {
+    notify: (signal: string) => void;
+    listen: (signal: string, listener: () => void) => void;
+    atoms: Record<string, WritableAtom<any>>;
+}
+type ClientAtomListener = {
+    matcher: (path: string) => boolean;
+    signal: "$sessionSignal" | Omit<string, "$sessionSignal">;
+};
+interface BetterAuthClientOptions {
+    fetchOptions?: BetterFetchOption;
+    plugins?: BetterAuthClientPlugin[];
+    baseURL?: string;
+    basePath?: string;
+    disableDefaultFetchPlugins?: boolean;
+    $InferAuth?: BetterAuthOptions;
+}
+interface BetterAuthClientPlugin {
+    id: LiteralString;
+    /**
+     * only used for type inference. don't pass the
+     * actual plugin
+     */
+    $InferServerPlugin?: BetterAuthPlugin;
+    /**
+     * Custom actions
+     */
+    getActions?: ($fetch: BetterFetch, $store: ClientStore, 
+    /**
+     * better-auth client options
+     */
+    options: BetterAuthClientOptions | undefined) => Record<string, any>;
+    /**
+     * State atoms that'll be resolved by each framework
+     * auth store.
+     */
+    getAtoms?: ($fetch: BetterFetch) => Record<string, Atom<any>>;
+    /**
+     * specify path methods for server plugin inferred
+     * endpoints to force a specific method.
+     */
+    pathMethods?: Record<string, "POST" | "GET">;
+    /**
+     * Better fetch plugins
+     */
+    fetchPlugins?: BetterFetchPlugin[];
+    /**
+     * a list of recaller based on a matcher function.
+     * The signal name needs to match a signal in this
+     * plugin or any plugin the user might have added.
+     */
+    atomListeners?: ClientAtomListener[];
 }
 
-export { LiteralUnion };
-export type { BetterAuthAdvancedOptions, BetterAuthMutators, GenerateIdFn };
+export { AuthContext, BetterAuthOptions, LiteralString };
+export type { BetterAuthClientOptions, BetterAuthClientPlugin, BetterAuthPlugin, ClientAtomListener, ClientStore };

package/dist/middleware/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const betterCall = require('better-call');
+
+const optionsMiddleware = betterCall.createMiddleware(async () => {
+  return {};
+});
+const createAuthMiddleware = betterCall.createMiddleware.create({
+  use: [
+    optionsMiddleware,
+    /**
+     * Only use for post hooks
+     */
+    betterCall.createMiddleware(async () => {
+      return {};
+    })
+  ]
+});
+const createAuthEndpoint = betterCall.createEndpoint.create({
+  use: [optionsMiddleware]
+});
+
+exports.createAuthEndpoint = createAuthEndpoint;
+exports.createAuthMiddleware = createAuthMiddleware;
+exports.optionsMiddleware = optionsMiddleware;

package/dist/middleware/index.d.cts

@@ -0,0 +1,13 @@
+import 'better-call';
+import '../shared/core.CajxAutx.cjs';
+export { n as AuthEndpoint, a as AuthMiddleware, m as createAuthEndpoint, l as createAuthMiddleware, o as optionsMiddleware } from '../shared/core.CfqdiZTu.cjs';
+import 'zod';
+import 'kysely';
+import '../shared/core.Dl-70uns.cjs';
+import 'bun:sqlite';
+import 'node:sqlite';
+import '../social-providers/index.cjs';
+import '@better-auth/core/oauth2';
+import '../shared/core.DyEdx0m7.cjs';
+import '../shared/core.BwoNUcJQ.cjs';
+import '@better-auth/core';

package/dist/middleware/index.d.mts

@@ -0,0 +1,13 @@
+import 'better-call';
+import '../shared/core.CajxAutx.mjs';
+export { n as AuthEndpoint, a as AuthMiddleware, m as createAuthEndpoint, l as createAuthMiddleware, o as optionsMiddleware } from '../shared/core.C6_2xGyf.mjs';
+import 'zod';
+import 'kysely';
+import '../shared/core.Dl-70uns.mjs';
+import 'bun:sqlite';
+import 'node:sqlite';
+import '../social-providers/index.mjs';
+import '@better-auth/core/oauth2';
+import '../shared/core.Bl6TpxyD.mjs';
+import '../shared/core.BwoNUcJQ.mjs';
+import '@better-auth/core';

package/dist/middleware/index.d.ts

@@ -0,0 +1,13 @@
+import 'better-call';
+import '../shared/core.CajxAutx.js';
+export { n as AuthEndpoint, a as AuthMiddleware, m as createAuthEndpoint, l as createAuthMiddleware, o as optionsMiddleware } from '../shared/core.Bshk2o_x.js';
+import 'zod';
+import 'kysely';
+import '../shared/core.Dl-70uns.js';
+import 'bun:sqlite';
+import 'node:sqlite';
+import '../social-providers/index.js';
+import '@better-auth/core/oauth2';
+import '../shared/core.DkdZ1o38.js';
+import '../shared/core.BwoNUcJQ.js';
+import '@better-auth/core';

package/dist/middleware/index.mjs

@@ -0,0 +1,21 @@
+import { createMiddleware, createEndpoint } from 'better-call';
+
+const optionsMiddleware = createMiddleware(async () => {
+  return {};
+});
+const createAuthMiddleware = createMiddleware.create({
+  use: [
+    optionsMiddleware,
+    /**
+     * Only use for post hooks
+     */
+    createMiddleware(async () => {
+      return {};
+    })
+  ]
+});
+const createAuthEndpoint = createEndpoint.create({
+  use: [optionsMiddleware]
+});
+
+export { createAuthEndpoint, createAuthMiddleware, optionsMiddleware };