@masheev/better-auth 0.0.0-stage → 1.7.5

package/dist/plugins/one-time-token/index.d.mts

@@ -0,0 +1,132 @@
+import { Session, User } from "../../types/models.mjs";
+import { GenericEndpointContext } from "@better-auth/core";
+import * as _$better_call0 from "better-call";
+import * as z from "zod";
+
+//#region src/plugins/one-time-token/index.d.ts
+declare module "@better-auth/core" {
+  interface BetterAuthPluginRegistry<AuthOptions, Options> {
+    "one-time-token": {
+      creator: typeof oneTimeToken;
+    };
+  }
+}
+interface OneTimeTokenOptions {
+  /**
+   * Expires in minutes
+   *
+   * @default 3
+   */
+  expiresIn?: number | undefined;
+  /**
+   * Only allow server initiated requests
+   */
+  disableClientRequest?: boolean | undefined;
+  /**
+   * Generate a custom token
+   */
+  generateToken?: ((session: {
+    user: User & Record<string, any>;
+    session: Session & Record<string, any>;
+  }, ctx: GenericEndpointContext) => Promise<string>) | undefined;
+  /**
+   * Disable setting the session cookie when the token is verified
+   */
+  disableSetSessionCookie?: boolean;
+  /**
+   * This option allows you to configure how the token is stored in your database.
+   * Note: This will not affect the token that's sent, it will only affect the token stored in your database.
+   *
+   * @default "plain"
+   */
+  storeToken?: ("plain" | "hashed" | {
+    type: "custom-hasher";
+    hash: (token: string) => Promise<string>;
+  }) | undefined;
+  /**
+   * Set the OTT header on new sessions
+   */
+  setOttHeaderOnNewSession?: boolean;
+}
+declare const oneTimeToken: (options?: OneTimeTokenOptions | undefined) => {
+  id: "one-time-token";
+  version: string;
+  endpoints: {
+    /**
+     * ### Endpoint
+     *
+     * GET `/one-time-token/generate`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.generateOneTimeToken`
+     *
+     * **client:**
+     * `authClient.oneTimeToken.generate`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/one-time-token#api-method-one-time-token-generate)
+     */
+    generateOneTimeToken: _$better_call0.StrictEndpoint<"/one-time-token/generate", {
+      method: "GET";
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (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;
+          };
+        };
+      }>>[];
+    }, {
+      token: string;
+    }>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/one-time-token/verify`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.verifyOneTimeToken`
+     *
+     * **client:**
+     * `authClient.oneTimeToken.verify`
+     *
+     * @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/one-time-token#api-method-one-time-token-verify)
+     */
+    verifyOneTimeToken: _$better_call0.StrictEndpoint<"/one-time-token/verify", {
+      method: "POST";
+      body: z.ZodObject<{
+        token: z.ZodString;
+      }, z.core.$strip>;
+    }, {
+      session: Session & Record<string, any>;
+      user: User & Record<string, any>;
+    }>;
+  };
+  hooks: {
+    after: {
+      matcher: () => true;
+      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<void>>;
+    }[];
+  };
+  options: OneTimeTokenOptions | undefined;
+};
+//#endregion
+export { OneTimeTokenOptions, oneTimeToken };

package/dist/plugins/one-time-token/index.mjs

@@ -0,0 +1,107 @@
+import { generateRandomString } from "../../crypto/random.mjs";
+import { setSessionCookie } from "../../cookies/index.mjs";
+import { sessionMiddleware } from "../../api/routes/session.mjs";
+import { PACKAGE_VERSION } from "../../version.mjs";
+import { defaultKeyHasher } from "./utils.mjs";
+import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api";
+import * as z from "zod";
+//#region src/plugins/one-time-token/index.ts
+const verifyOneTimeTokenBodySchema = z.object({ token: z.string().meta({ description: "The token to verify. Eg: \"some-token\"" }) });
+const oneTimeToken = (options) => {
+	const opts = {
+		storeToken: "plain",
+		...options
+	};
+	async function storeToken(ctx, token) {
+		if (opts.storeToken === "hashed") return await defaultKeyHasher(token);
+		if (typeof opts.storeToken === "object" && "type" in opts.storeToken && opts.storeToken.type === "custom-hasher") return await opts.storeToken.hash(token);
+		return token;
+	}
+	async function generateToken(c, session) {
+		const token = opts?.generateToken ? await opts.generateToken(session, c) : generateRandomString(32);
+		const expiresAt = new Date(Date.now() + (opts?.expiresIn ?? 3) * 60 * 1e3);
+		const storedToken = await storeToken(c, token);
+		await c.context.internalAdapter.createVerificationValue({
+			value: session.session.token,
+			identifier: `one-time-token:${storedToken}`,
+			expiresAt
+		});
+		return token;
+	}
+	return {
+		id: "one-time-token",
+		version: PACKAGE_VERSION,
+		endpoints: {
+			/**
+			* ### Endpoint
+			*
+			* GET `/one-time-token/generate`
+			*
+			* ### API Methods
+			*
+			* **server:**
+			* `auth.api.generateOneTimeToken`
+			*
+			* **client:**
+			* `authClient.oneTimeToken.generate`
+			*
+			* @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/one-time-token#api-method-one-time-token-generate)
+			*/
+			generateOneTimeToken: createAuthEndpoint("/one-time-token/generate", {
+				method: "GET",
+				use: [sessionMiddleware]
+			}, async (c) => {
+				if (opts?.disableClientRequest && c.request) throw c.error("BAD_REQUEST", { message: "Client requests are disabled" });
+				const session = c.context.session;
+				const token = await generateToken(c, session);
+				return c.json({ token });
+			}),
+			/**
+			* ### Endpoint
+			*
+			* POST `/one-time-token/verify`
+			*
+			* ### API Methods
+			*
+			* **server:**
+			* `auth.api.verifyOneTimeToken`
+			*
+			* **client:**
+			* `authClient.oneTimeToken.verify`
+			*
+			* @see [Read our docs to learn more.](https://better-auth.com/docs/plugins/one-time-token#api-method-one-time-token-verify)
+			*/
+			verifyOneTimeToken: createAuthEndpoint("/one-time-token/verify", {
+				method: "POST",
+				body: verifyOneTimeTokenBodySchema
+			}, async (c) => {
+				const { token } = c.body;
+				const storedToken = await storeToken(c, token);
+				const verificationValue = await c.context.internalAdapter.consumeVerificationValue(`one-time-token:${storedToken}`);
+				if (!verificationValue) throw c.error("BAD_REQUEST", { message: "Invalid token" });
+				const session = await c.context.internalAdapter.findSession(verificationValue.value);
+				if (!session) throw c.error("BAD_REQUEST", { message: "Session not found" });
+				if (!opts?.disableSetSessionCookie) await setSessionCookie(c, session);
+				if (session.session.expiresAt < /* @__PURE__ */ new Date()) throw c.error("BAD_REQUEST", { message: "Session expired" });
+				return c.json(session);
+			})
+		},
+		hooks: { after: [{
+			matcher: () => true,
+			handler: createAuthMiddleware(async (ctx) => {
+				if (ctx.context.newSession) {
+					if (!opts?.setOttHeaderOnNewSession) return;
+					const exposedHeaders = ctx.context.responseHeaders?.get("access-control-expose-headers") || "";
+					const headersSet = new Set(exposedHeaders.split(",").map((header) => header.trim()).filter(Boolean));
+					headersSet.add("set-ott");
+					const token = await generateToken(ctx, ctx.context.newSession);
+					ctx.setHeader("set-ott", token);
+					ctx.setHeader("Access-Control-Expose-Headers", Array.from(headersSet).join(", "));
+				}
+			})
+		}] },
+		options
+	};
+};
+//#endregion
+export { oneTimeToken };

package/dist/plugins/one-time-token/utils.mjs

@@ -0,0 +1,9 @@
+import { base64Url } from "@better-auth/utils/base64";
+import { createHash } from "@better-auth/utils/hash";
+//#region src/plugins/one-time-token/utils.ts
+const defaultKeyHasher = async (token) => {
+	const hash = await createHash("SHA-256").digest(new TextEncoder().encode(token));
+	return base64Url.encode(new Uint8Array(hash), { padding: false });
+};
+//#endregion
+export { defaultKeyHasher };

package/dist/plugins/open-api/generator.d.mts

@@ -0,0 +1,126 @@
+import { AuthContext, BetterAuthOptions } from "@better-auth/core";
+import { DBFieldAttributeConfig, DBFieldType } from "@better-auth/core/db";
+import { OpenAPIParameter, OpenAPISchemaType } from "better-call";
+
+//#region src/plugins/open-api/generator.d.ts
+interface Path {
+  get?: OpenAPIOperation | undefined;
+  post?: OpenAPIOperation | undefined;
+  put?: OpenAPIOperation | undefined;
+  patch?: OpenAPIOperation | undefined;
+  delete?: OpenAPIOperation | undefined;
+}
+type OpenAPISchemaPrimitiveType = OpenAPISchemaType | "null";
+type OpenAPISchema = {
+  type?: OpenAPISchemaPrimitiveType | OpenAPISchemaPrimitiveType[];
+  properties?: Record<string, OpenAPISchema>;
+  required?: string[];
+  $ref?: string;
+  description?: string;
+  default?: unknown;
+  readOnly?: boolean;
+  format?: string;
+  deprecated?: boolean;
+  enum?: unknown[];
+  items?: OpenAPISchema;
+  minLength?: number;
+  maxLength?: number;
+  minimum?: number;
+  maximum?: number;
+  additionalProperties?: boolean | OpenAPISchema;
+  propertyNames?: OpenAPISchema;
+  allOf?: OpenAPISchema[];
+  anyOf?: OpenAPISchema[];
+  oneOf?: OpenAPISchema[];
+  const?: unknown;
+  example?: unknown;
+};
+type OpenAPIParameter$1 = Omit<OpenAPIParameter, "schema"> & {
+  schema?: OpenAPISchema;
+};
+type OpenAPIMediaTypeObject = {
+  schema?: OpenAPISchema;
+};
+type OpenAPIResponseContent = {
+  "application/json"?: OpenAPIMediaTypeObject;
+  "text/plain"?: OpenAPIMediaTypeObject;
+  "text/html"?: OpenAPIMediaTypeObject;
+  [contentType: string]: OpenAPIMediaTypeObject | undefined;
+};
+type OpenAPIResponse = {
+  description?: string;
+  content?: OpenAPIResponseContent;
+};
+type OpenAPIRequestBody = {
+  required?: boolean;
+  content: {
+    "application/json": {
+      schema: OpenAPISchema;
+    };
+  };
+};
+type OpenAPIOperation = {
+  tags?: string[];
+  operationId?: string;
+  description?: string;
+  security?: [{
+    bearerAuth: string[];
+  }];
+  parameters?: OpenAPIParameter$1[];
+  requestBody?: OpenAPIRequestBody;
+  responses?: Record<string, OpenAPIResponse>;
+};
+type FieldSchema = {
+  type: DBFieldType | "array"; /** Element schema for `type: "array"` (JSON Schema / OpenAPI array shape). */
+  items?: {
+    type: string;
+  };
+  default?: DBFieldAttributeConfig["defaultValue"] | undefined;
+  readOnly?: boolean | undefined;
+  format?: string;
+};
+type OpenAPIModelSchema = {
+  type: "object";
+  properties: Record<string, FieldSchema>;
+  required?: string[] | undefined;
+};
+declare function generator(ctx: AuthContext, options: BetterAuthOptions): Promise<{
+  openapi: string;
+  info: {
+    title: string;
+    description: string;
+    version: string;
+  };
+  components: {
+    securitySchemes: {
+      apiKeyCookie: {
+        type: string;
+        in: string;
+        name: string;
+        description: string;
+      };
+      bearerAuth: {
+        type: string;
+        scheme: string;
+        description: string;
+      };
+    };
+    schemas: {
+      [x: string]: OpenAPIModelSchema;
+    };
+  };
+  security: {
+    apiKeyCookie: never[];
+    bearerAuth: never[];
+  }[];
+  servers: {
+    url: string;
+  }[];
+  tags: {
+    name: string;
+    description: string;
+  }[];
+  paths: Record<string, Path>;
+}>;
+//#endregion
+export { FieldSchema, OpenAPIModelSchema, OpenAPIParameter$1 as OpenAPIParameter, OpenAPISchema, Path, generator };