@better-auth/core 1.3.26 → 1.3.28

package/src/types/plugin-client.ts

@@ -0,0 +1,69 @@
+import type { BetterAuthPlugin } from "./plugin";
+import type {
+	BetterFetch,
+	BetterFetchOption,
+	BetterFetchPlugin,
+} from "@better-fetch/fetch";
+import type { LiteralString } from "./helper";
+import type { BetterAuthOptions } from "./init-options";
+import type { WritableAtom, Atom } from "nanostores";
+
+export interface ClientStore {
+	notify: (signal: string) => void;
+	listen: (signal: string, listener: () => void) => void;
+	atoms: Record<string, WritableAtom<any>>;
+}
+
+export type ClientAtomListener = {
+	matcher: (path: string) => boolean;
+	signal: "$sessionSignal" | Omit<string, "$sessionSignal">;
+};
+
+export interface BetterAuthClientOptions {
+	fetchOptions?: BetterFetchOption;
+	plugins?: BetterAuthClientPlugin[];
+	baseURL?: string;
+	basePath?: string;
+	disableDefaultFetchPlugins?: boolean;
+	$InferAuth?: BetterAuthOptions;
+}
+
+export 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[];
+}

package/src/types/plugin.ts

@@ -0,0 +1,134 @@
+import type { Migration } from "kysely";
+import type { AuthContext } from "./context";
+import type {
+	Endpoint,
+	EndpointContext,
+	InputContext,
+	Middleware,
+} from "better-call";
+import type { BetterAuthPluginDBSchema } from "../db";
+import type { LiteralString } from "./helper";
+import type { BetterAuthOptions } from "./init-options";
+import type { AuthMiddleware } from "../middleware";
+
+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;
+	};
+
+export type BetterAuthPlugin = {
+	id: LiteralString;
+	/**
+	 * The init function is called when the plugin is initialized.
+	 * You can return a new context or modify the existing context.
+	 */
+	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;
+		}[];
+	};
+	/**
+	 * 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.
+	 *
+	 * 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
+	 * ```
+	 */
+	schema?: BetterAuthPluginDBSchema;
+	/**
+	 * The migrations of the plugin. If you define schema that will automatically create
+	 * migrations for you.
+	 *
+	 * ⚠️ Only uses this if you dont't want to use the schema option and you disabled migrations for
+	 * the tables.
+	 */
+	migrations?: Record<string, Migration>;
+	/**
+	 * The options of the plugin
+	 */
+	options?: Record<string, any> | undefined;
+	/**
+	 * types to be inferred
+	 */
+	$Infer?: Record<string, any>;
+	/**
+	 * The rate limit rules to apply to specific paths.
+	 */
+	rateLimit?: {
+		window: number;
+		max: number;
+		pathMatcher: (path: string) => boolean;
+	}[];
+	/**
+	 * The error codes returned by the plugin
+	 */
+	$ERROR_CODES?: Record<string, string>;
+};

package/src/utils/error-codes.ts

@@ -0,0 +1,51 @@
+type UpperLetter =
+	| "A"
+	| "B"
+	| "C"
+	| "D"
+	| "E"
+	| "F"
+	| "G"
+	| "H"
+	| "I"
+	| "J"
+	| "K"
+	| "L"
+	| "M"
+	| "N"
+	| "O"
+	| "P"
+	| "Q"
+	| "R"
+	| "S"
+	| "T"
+	| "U"
+	| "V"
+	| "W"
+	| "X"
+	| "Y"
+	| "Z";
+type SpecialCharacter = "_";
+
+type IsValidUpperSnakeCase<S extends string> = S extends `${infer F}${infer R}`
+	? F extends UpperLetter | SpecialCharacter
+		? IsValidUpperSnakeCase<R>
+		: false
+	: true;
+
+type InvalidKeyError<K extends string> =
+	`Invalid error code key: "${K}" - must only contain uppercase letters (A-Z) and underscores (_)`;
+
+type ValidateErrorCodes<T> = {
+	[K in keyof T]: K extends string
+		? IsValidUpperSnakeCase<K> extends false
+			? InvalidKeyError<K>
+			: T[K]
+		: T[K];
+};
+
+export function defineErrorCodes<const T extends Record<string, string>>(
+	codes: ValidateErrorCodes<T>,
+): T {
+	return codes as T;
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { defineErrorCodes } from "./error-codes";