@pleaseai/agent 0.1.16 → 0.1.18

package/.output/server/node_modules/better-auth/dist/plugins/username/index.mjs

@@ -0,0 +1,234 @@
+import { mergeSchema, parseUserOutput } from "../../db/schema.mjs";
+import "../../db/index.mjs";
+import { setSessionCookie } from "../../cookies/index.mjs";
+import { createEmailVerificationToken } from "../../api/routes/email-verification.mjs";
+import "../../api/index.mjs";
+import { USERNAME_ERROR_CODES } from "./error-codes.mjs";
+import { getSchema } from "./schema.mjs";
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+import { createAuthEndpoint, createAuthMiddleware } from "@better-auth/core/api";
+import * as z from "zod";
+
+//#region src/plugins/username/index.ts
+function defaultUsernameValidator(username) {
+	return /^[a-zA-Z0-9_.]+$/.test(username);
+}
+const signInUsernameBodySchema = z.object({
+	username: z.string().meta({ description: "The username of the user" }),
+	password: z.string().meta({ description: "The password of the user" }),
+	rememberMe: z.boolean().meta({ description: "Remember the user session" }).optional(),
+	callbackURL: z.string().meta({ description: "The URL to redirect to after email verification" }).optional()
+});
+const isUsernameAvailableBodySchema = z.object({ username: z.string().meta({ description: "The username to check" }) });
+const username = (options) => {
+	const normalizer = (username) => {
+		if (options?.usernameNormalization === false) return username;
+		if (options?.usernameNormalization) return options.usernameNormalization(username);
+		return username.toLowerCase();
+	};
+	const displayUsernameNormalizer = (displayUsername) => {
+		return options?.displayUsernameNormalization ? options.displayUsernameNormalization(displayUsername) : displayUsername;
+	};
+	return {
+		id: "username",
+		init(ctx) {
+			return { options: { databaseHooks: { user: {
+				create: { async before(user, context) {
+					const username = "username" in user ? user.username : null;
+					const displayUsername = "displayUsername" in user ? user.displayUsername : null;
+					return { data: {
+						...user,
+						...username ? { username: normalizer(username) } : {},
+						...displayUsername ? { displayUsername: displayUsernameNormalizer(displayUsername) } : {}
+					} };
+				} },
+				update: { async before(user, context) {
+					const username = "username" in user ? user.username : null;
+					const displayUsername = "displayUsername" in user ? user.displayUsername : null;
+					return { data: {
+						...user,
+						...username ? { username: normalizer(username) } : {},
+						...displayUsername ? { displayUsername: displayUsernameNormalizer(displayUsername) } : {}
+					} };
+				} }
+			} } } };
+		},
+		endpoints: {
+			signInUsername: createAuthEndpoint("/sign-in/username", {
+				method: "POST",
+				body: signInUsernameBodySchema,
+				metadata: { openapi: {
+					summary: "Sign in with username",
+					description: "Sign in with username",
+					responses: {
+						200: {
+							description: "Success",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: {
+									token: {
+										type: "string",
+										description: "Session token for the authenticated session"
+									},
+									user: { $ref: "#/components/schemas/User" }
+								},
+								required: ["token", "user"]
+							} } }
+						},
+						422: {
+							description: "Unprocessable Entity. Validation error",
+							content: { "application/json": { schema: {
+								type: "object",
+								properties: { message: { type: "string" } }
+							} } }
+						}
+					}
+				} }
+			}, async (ctx) => {
+				if (!ctx.body.username || !ctx.body.password) {
+					ctx.context.logger.error("Username or password not found");
+					throw APIError.from("UNAUTHORIZED", USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD);
+				}
+				const username = options?.validationOrder?.username === "pre-normalization" ? normalizer(ctx.body.username) : ctx.body.username;
+				const minUsernameLength = options?.minUsernameLength || 3;
+				const maxUsernameLength = options?.maxUsernameLength || 30;
+				if (username.length < minUsernameLength) {
+					ctx.context.logger.error("Username too short", { username });
+					throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.USERNAME_TOO_SHORT);
+				}
+				if (username.length > maxUsernameLength) {
+					ctx.context.logger.error("Username too long", { username });
+					throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.USERNAME_TOO_LONG);
+				}
+				if (!await (options?.usernameValidator || defaultUsernameValidator)(username)) throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.INVALID_USERNAME);
+				const user = await ctx.context.adapter.findOne({
+					model: "user",
+					where: [{
+						field: "username",
+						value: normalizer(username)
+					}]
+				});
+				if (!user) {
+					await ctx.context.password.hash(ctx.body.password);
+					ctx.context.logger.error("User not found", { username });
+					throw APIError.from("UNAUTHORIZED", USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD);
+				}
+				const account = await ctx.context.adapter.findOne({
+					model: "account",
+					where: [{
+						field: "userId",
+						value: user.id
+					}, {
+						field: "providerId",
+						value: "credential"
+					}]
+				});
+				if (!account) throw APIError.from("UNAUTHORIZED", USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD);
+				const currentPassword = account?.password;
+				if (!currentPassword) {
+					ctx.context.logger.error("Password not found", { username });
+					throw APIError.from("UNAUTHORIZED", USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD);
+				}
+				if (!await ctx.context.password.verify({
+					hash: currentPassword,
+					password: ctx.body.password
+				})) {
+					ctx.context.logger.error("Invalid password");
+					throw APIError.from("UNAUTHORIZED", USERNAME_ERROR_CODES.INVALID_USERNAME_OR_PASSWORD);
+				}
+				if (ctx.context.options?.emailAndPassword?.requireEmailVerification && !user.emailVerified) {
+					if (!ctx.context.options?.emailVerification?.sendVerificationEmail) throw APIError.from("FORBIDDEN", USERNAME_ERROR_CODES.EMAIL_NOT_VERIFIED);
+					if (ctx.context.options?.emailVerification?.sendOnSignIn) {
+						const token = await createEmailVerificationToken(ctx.context.secret, user.email, void 0, ctx.context.options.emailVerification?.expiresIn);
+						const url = `${ctx.context.baseURL}/verify-email?token=${token}&callbackURL=${ctx.body.callbackURL || "/"}`;
+						await ctx.context.runInBackgroundOrAwait(ctx.context.options.emailVerification.sendVerificationEmail({
+							user,
+							url,
+							token
+						}, ctx.request));
+					}
+					throw APIError.from("FORBIDDEN", USERNAME_ERROR_CODES.EMAIL_NOT_VERIFIED);
+				}
+				const session = await ctx.context.internalAdapter.createSession(user.id, ctx.body.rememberMe === false);
+				if (!session) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION);
+				await setSessionCookie(ctx, {
+					session,
+					user
+				}, ctx.body.rememberMe === false);
+				return ctx.json({
+					token: session.token,
+					user: parseUserOutput(ctx.context.options, user)
+				});
+			}),
+			isUsernameAvailable: createAuthEndpoint("/is-username-available", {
+				method: "POST",
+				body: isUsernameAvailableBodySchema
+			}, async (ctx) => {
+				const username = ctx.body.username;
+				if (!username) throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.INVALID_USERNAME);
+				const minUsernameLength = options?.minUsernameLength || 3;
+				const maxUsernameLength = options?.maxUsernameLength || 30;
+				if (username.length < minUsernameLength) throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.USERNAME_TOO_SHORT);
+				if (username.length > maxUsernameLength) throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.USERNAME_TOO_LONG);
+				if (!await (options?.usernameValidator || defaultUsernameValidator)(username)) throw APIError.from("UNPROCESSABLE_ENTITY", USERNAME_ERROR_CODES.INVALID_USERNAME);
+				if (await ctx.context.adapter.findOne({
+					model: "user",
+					where: [{
+						field: "username",
+						value: normalizer(username)
+					}]
+				})) return ctx.json({ available: false });
+				return ctx.json({ available: true });
+			})
+		},
+		schema: mergeSchema(getSchema({
+			username: normalizer,
+			displayUsername: displayUsernameNormalizer
+		}), options?.schema),
+		hooks: { before: [{
+			matcher(context) {
+				return context.path === "/sign-up/email" || context.path === "/update-user";
+			},
+			handler: createAuthMiddleware(async (ctx) => {
+				const username = typeof ctx.body.username === "string" && options?.validationOrder?.username === "post-normalization" ? normalizer(ctx.body.username) : ctx.body.username;
+				if (username !== void 0 && typeof username === "string") {
+					const minUsernameLength = options?.minUsernameLength || 3;
+					const maxUsernameLength = options?.maxUsernameLength || 30;
+					if (username.length < minUsernameLength) throw APIError.from("BAD_REQUEST", USERNAME_ERROR_CODES.USERNAME_TOO_SHORT);
+					if (username.length > maxUsernameLength) throw APIError.from("BAD_REQUEST", USERNAME_ERROR_CODES.USERNAME_TOO_LONG);
+					if (!await (options?.usernameValidator || defaultUsernameValidator)(username)) throw APIError.from("BAD_REQUEST", USERNAME_ERROR_CODES.INVALID_USERNAME);
+					const user = await ctx.context.adapter.findOne({
+						model: "user",
+						where: [{
+							field: "username",
+							value: username
+						}]
+					});
+					const blockChangeSignUp = ctx.path === "/sign-up/email" && user;
+					const blockChangeUpdateUser = ctx.path === "/update-user" && user && ctx.context.session && user.id !== ctx.context.session.session.userId;
+					if (blockChangeSignUp || blockChangeUpdateUser) throw APIError.from("BAD_REQUEST", USERNAME_ERROR_CODES.USERNAME_IS_ALREADY_TAKEN);
+				}
+				const displayUsername = typeof ctx.body.displayUsername === "string" && options?.validationOrder?.displayUsername === "post-normalization" ? displayUsernameNormalizer(ctx.body.displayUsername) : ctx.body.displayUsername;
+				if (displayUsername !== void 0 && typeof displayUsername === "string") {
+					if (options?.displayUsernameValidator) {
+						if (!await options.displayUsernameValidator(displayUsername)) throw APIError.from("BAD_REQUEST", USERNAME_ERROR_CODES.INVALID_DISPLAY_USERNAME);
+					}
+				}
+			})
+		}, {
+			matcher(context) {
+				return context.path === "/sign-up/email" || context.path === "/update-user";
+			},
+			handler: createAuthMiddleware(async (ctx) => {
+				if (ctx.body.username && !ctx.body.displayUsername) ctx.body.displayUsername = ctx.body.username;
+				if (ctx.body.displayUsername && !ctx.body.username) ctx.body.username = ctx.body.displayUsername;
+			})
+		}] },
+		options,
+		$ERROR_CODES: USERNAME_ERROR_CODES
+	};
+};
+
+//#endregion
+export { USERNAME_ERROR_CODES, username };
+//# sourceMappingURL=index.mjs.map

package/.output/server/node_modules/better-auth/dist/plugins/username/schema.mjs

@@ -0,0 +1,26 @@
+//#region src/plugins/username/schema.ts
+const getSchema = (normalizer) => {
+	return { user: { fields: {
+		username: {
+			type: "string",
+			required: false,
+			sortable: true,
+			unique: true,
+			returned: true,
+			transform: { input(value) {
+				return typeof value !== "string" ? value : normalizer.username(value);
+			} }
+		},
+		displayUsername: {
+			type: "string",
+			required: false,
+			transform: { input(value) {
+				return typeof value !== "string" ? value : normalizer.displayUsername(value);
+			} }
+		}
+	} } };
+};
+
+//#endregion
+export { getSchema };
+//# sourceMappingURL=schema.mjs.map

package/.output/server/node_modules/better-auth/dist/state.mjs

@@ -0,0 +1,107 @@
+import { generateRandomString } from "./crypto/random.mjs";
+import { symmetricDecrypt, symmetricEncrypt } from "./crypto/index.mjs";
+import { expireCookie } from "./cookies/index.mjs";
+import { BetterAuthError } from "@better-auth/core/error";
+import * as z from "zod";
+
+//#region src/state.ts
+const stateDataSchema = z.looseObject({
+	callbackURL: z.string(),
+	codeVerifier: z.string(),
+	errorURL: z.string().optional(),
+	newUserURL: z.string().optional(),
+	expiresAt: z.number(),
+	link: z.object({
+		email: z.string(),
+		userId: z.coerce.string()
+	}).optional(),
+	requestSignUp: z.boolean().optional()
+});
+var StateError = class extends BetterAuthError {
+	code;
+	details;
+	constructor(message, options) {
+		super(message, options);
+		this.code = options.code;
+		this.details = options.details;
+	}
+};
+async function generateGenericState(c, stateData, settings) {
+	const state = generateRandomString(32);
+	if (c.context.oauthConfig.storeStateStrategy === "cookie") {
+		const encryptedData = await symmetricEncrypt({
+			key: c.context.secretConfig,
+			data: JSON.stringify(stateData)
+		});
+		const stateCookie = c.context.createAuthCookie(settings?.cookieName ?? "oauth_state", { maxAge: 600 });
+		c.setCookie(stateCookie.name, encryptedData, stateCookie.attributes);
+		return {
+			state,
+			codeVerifier: stateData.codeVerifier
+		};
+	}
+	const stateCookie = c.context.createAuthCookie(settings?.cookieName ?? "state", { maxAge: 300 });
+	await c.setSignedCookie(stateCookie.name, state, c.context.secret, stateCookie.attributes);
+	const expiresAt = /* @__PURE__ */ new Date();
+	expiresAt.setMinutes(expiresAt.getMinutes() + 10);
+	const verification = await c.context.internalAdapter.createVerificationValue({
+		value: JSON.stringify(stateData),
+		identifier: state,
+		expiresAt
+	});
+	if (!verification) throw new StateError("Unable to create verification. Make sure the database adapter is properly working and there is a verification table in the database", { code: "state_generation_error" });
+	return {
+		state: verification.identifier,
+		codeVerifier: stateData.codeVerifier
+	};
+}
+async function parseGenericState(c, state, settings) {
+	const storeStateStrategy = c.context.oauthConfig.storeStateStrategy;
+	let parsedData;
+	if (storeStateStrategy === "cookie") {
+		const stateCookie = c.context.createAuthCookie(settings?.cookieName ?? "oauth_state");
+		const encryptedData = c.getCookie(stateCookie.name);
+		if (!encryptedData) throw new StateError("State mismatch: auth state cookie not found", {
+			code: "state_mismatch",
+			details: { state }
+		});
+		try {
+			const decryptedData = await symmetricDecrypt({
+				key: c.context.secretConfig,
+				data: encryptedData
+			});
+			parsedData = stateDataSchema.parse(JSON.parse(decryptedData));
+		} catch (error) {
+			throw new StateError("State invalid: Failed to decrypt or parse auth state", {
+				code: "state_invalid",
+				details: { state },
+				cause: error
+			});
+		}
+		expireCookie(c, stateCookie);
+	} else {
+		const data = await c.context.internalAdapter.findVerificationValue(state);
+		if (!data) throw new StateError("State mismatch: verification not found", {
+			code: "state_mismatch",
+			details: { state }
+		});
+		parsedData = stateDataSchema.parse(JSON.parse(data.value));
+		const stateCookie = c.context.createAuthCookie(settings?.cookieName ?? "state");
+		const stateCookieValue = await c.getSignedCookie(stateCookie.name, c.context.secret);
+		if (!c.context.oauthConfig.skipStateCookieCheck && (!stateCookieValue || stateCookieValue !== state)) throw new StateError("State mismatch: State not persisted correctly", {
+			code: "state_security_mismatch",
+			details: { state }
+		});
+		expireCookie(c, stateCookie);
+		await c.context.internalAdapter.deleteVerificationByIdentifier(state);
+	}
+	if (parsedData.expiresAt < Date.now()) throw new StateError("Invalid state: request expired", {
+		code: "state_mismatch",
+		details: { expiresAt: parsedData.expiresAt }
+	});
+	return parsedData;
+}
+
+//#endregion
+export { StateError, generateGenericState, parseGenericState };
+//# sourceMappingURL=state.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/boolean.mjs

@@ -0,0 +1,8 @@
+//#region src/utils/boolean.ts
+function toBoolean(value) {
+	return value === "true" || value === true;
+}
+
+//#endregion
+export { toBoolean };
+//# sourceMappingURL=boolean.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/constants.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/constants.ts
+const DEFAULT_SECRET = "better-auth-secret-12345678901234567890";
+
+//#endregion
+export { DEFAULT_SECRET };
+//# sourceMappingURL=constants.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/date.mjs

@@ -0,0 +1,8 @@
+//#region src/utils/date.ts
+const getDate = (span, unit = "ms") => {
+	return new Date(Date.now() + (unit === "sec" ? span * 1e3 : span));
+};
+
+//#endregion
+export { getDate };
+//# sourceMappingURL=date.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/get-request-ip.mjs

@@ -0,0 +1,23 @@
+import { isDevelopment, isTest } from "@better-auth/core/env";
+import { isValidIP, normalizeIP } from "@better-auth/core/utils/ip";
+
+//#region src/utils/get-request-ip.ts
+const LOCALHOST_IP = "127.0.0.1";
+function getIp(req, options) {
+	if (options.advanced?.ipAddress?.disableIpTracking) return null;
+	const headers = "headers" in req ? req.headers : req;
+	const ipHeaders = options.advanced?.ipAddress?.ipAddressHeaders || ["x-forwarded-for"];
+	for (const key of ipHeaders) {
+		const value = "get" in headers ? headers.get(key) : headers[key];
+		if (typeof value === "string") {
+			const ip = value.split(",")[0].trim();
+			if (isValidIP(ip)) return normalizeIP(ip, { ipv6Subnet: options.advanced?.ipAddress?.ipv6Subnet });
+		}
+	}
+	if (isTest() || isDevelopment()) return LOCALHOST_IP;
+	return null;
+}
+
+//#endregion
+export { getIp };
+//# sourceMappingURL=get-request-ip.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/hashing.mjs

@@ -0,0 +1,21 @@
+import { utf8ToBytes } from "@noble/hashes/utils.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+
+//#region src/utils/hashing.ts
+/**
+* TS implementation of ERC-55 ("Mixed-case checksum address encoding") using @noble/hashes
+* @param address - The address to convert to a checksum address
+* @returns The checksummed address
+*/
+function toChecksumAddress(address) {
+	address = address.toLowerCase().replace("0x", "");
+	const hash = [...keccak_256(utf8ToBytes(address))].map((v) => v.toString(16).padStart(2, "0")).join("");
+	let ret = "0x";
+	for (let i = 0; i < 40; i++) if (parseInt(hash[i], 16) >= 8) ret += address[i].toUpperCase();
+	else ret += address[i];
+	return ret;
+}
+
+//#endregion
+export { toChecksumAddress };
+//# sourceMappingURL=hashing.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/hide-metadata.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/hide-metadata.ts
+const HIDE_METADATA = { scope: "server" };
+
+//#endregion
+export { HIDE_METADATA };
+//# sourceMappingURL=hide-metadata.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/index.mjs

@@ -0,0 +1,6 @@
+import { getBaseURL, getHost, getHostFromRequest, getOrigin, getProtocol, getProtocolFromRequest, isDynamicBaseURLConfig, matchesHostPattern, resolveBaseURL, resolveDynamicBaseURL } from "./url.mjs";
+import { generateGenericState, parseGenericState } from "../state.mjs";
+import { generateState, parseState } from "../oauth2/state.mjs";
+import { HIDE_METADATA } from "./hide-metadata.mjs";
+
+export {  };

package/.output/server/node_modules/better-auth/dist/utils/is-api-error.mjs

@@ -0,0 +1,11 @@
+import { APIError } from "@better-auth/core/error";
+import { APIError as APIError$1 } from "better-call";
+
+//#region src/utils/is-api-error.ts
+function isAPIError(error) {
+	return error instanceof APIError$1 || error instanceof APIError || error?.name === "APIError";
+}
+
+//#endregion
+export { isAPIError };
+//# sourceMappingURL=is-api-error.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/is-atom.mjs

@@ -0,0 +1,8 @@
+//#region src/utils/is-atom.ts
+function isAtom(value) {
+	return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+
+//#endregion
+export { isAtom };
+//# sourceMappingURL=is-atom.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/is-promise.mjs

@@ -0,0 +1,8 @@
+//#region src/utils/is-promise.ts
+function isPromise(obj) {
+	return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+
+//#endregion
+export { isPromise };
+//# sourceMappingURL=is-promise.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/middleware-response.mjs

@@ -0,0 +1,9 @@
+//#region src/utils/middleware-response.ts
+const middlewareResponse = ({ message, status, code }) => ({ response: new Response(JSON.stringify({
+	message,
+	code
+}), { status }) });
+
+//#endregion
+export { middlewareResponse };
+//# sourceMappingURL=middleware-response.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/password.mjs

@@ -0,0 +1,26 @@
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+
+//#region src/utils/password.ts
+async function validatePassword(ctx, data) {
+	const credentialAccount = (await ctx.context.internalAdapter.findAccounts(data.userId))?.find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword) return false;
+	return await ctx.context.password.verify({
+		hash: currentPassword,
+		password: data.password
+	});
+}
+async function checkPassword(userId, c) {
+	const credentialAccount = (await c.context.internalAdapter.findAccounts(userId))?.find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword || !c.body.password) throw APIError.from("BAD_REQUEST", BASE_ERROR_CODES.CREDENTIAL_ACCOUNT_NOT_FOUND);
+	if (!await c.context.password.verify({
+		hash: currentPassword,
+		password: c.body.password
+	})) throw APIError.from("BAD_REQUEST", BASE_ERROR_CODES.INVALID_PASSWORD);
+	return true;
+}
+
+//#endregion
+export { checkPassword, validatePassword };
+//# sourceMappingURL=password.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/plugin-helper.mjs

@@ -0,0 +1,17 @@
+import { isAPIError } from "./is-api-error.mjs";
+
+//#region src/utils/plugin-helper.ts
+const getEndpointResponse = async (ctx) => {
+	const returned = ctx.context.returned;
+	if (!returned) return null;
+	if (returned instanceof Response) {
+		if (returned.status !== 200) return null;
+		return await returned.clone().json();
+	}
+	if (isAPIError(returned)) return null;
+	return returned;
+};
+
+//#endregion
+export { getEndpointResponse };
+//# sourceMappingURL=plugin-helper.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/shim.mjs

@@ -0,0 +1,24 @@
+//#region src/utils/shim.ts
+const shimContext = (originalObject, newContext) => {
+	const shimmedObj = {};
+	for (const [key, value] of Object.entries(originalObject)) {
+		shimmedObj[key] = (ctx) => {
+			return value({
+				...ctx,
+				context: {
+					...newContext,
+					...ctx.context
+				}
+			});
+		};
+		shimmedObj[key].path = value.path;
+		shimmedObj[key].method = value.method;
+		shimmedObj[key].options = value.options;
+		shimmedObj[key].headers = value.headers;
+	}
+	return shimmedObj;
+};
+
+//#endregion
+export { shimContext };
+//# sourceMappingURL=shim.mjs.map

package/.output/server/node_modules/better-auth/dist/utils/time.mjs

@@ -0,0 +1,100 @@
+//#region src/utils/time.ts
+const SEC = 1e3;
+const MIN = SEC * 60;
+const HOUR = MIN * 60;
+const DAY = HOUR * 24;
+const WEEK = DAY * 7;
+const MONTH = DAY * 30;
+const YEAR = DAY * 365.25;
+const REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|months?|mo|years?|yrs?|y)(?: (ago|from now))?$/i;
+function parse(value) {
+	const match = REGEX.exec(value);
+	if (!match || match[4] && match[1]) throw new TypeError(`Invalid time string format: "${value}". Use formats like "7d", "30m", "1 hour", etc.`);
+	const n = parseFloat(match[2]);
+	const unit = match[3].toLowerCase();
+	let result;
+	switch (unit) {
+		case "years":
+		case "year":
+		case "yrs":
+		case "yr":
+		case "y":
+			result = n * YEAR;
+			break;
+		case "months":
+		case "month":
+		case "mo":
+			result = n * MONTH;
+			break;
+		case "weeks":
+		case "week":
+		case "w":
+			result = n * WEEK;
+			break;
+		case "days":
+		case "day":
+		case "d":
+			result = n * DAY;
+			break;
+		case "hours":
+		case "hour":
+		case "hrs":
+		case "hr":
+		case "h":
+			result = n * HOUR;
+			break;
+		case "minutes":
+		case "minute":
+		case "mins":
+		case "min":
+		case "m":
+			result = n * MIN;
+			break;
+		case "seconds":
+		case "second":
+		case "secs":
+		case "sec":
+		case "s":
+			result = n * SEC;
+			break;
+		default: throw new TypeError(`Unknown time unit: "${unit}"`);
+	}
+	if (match[1] === "-" || match[4] === "ago") return -result;
+	return result;
+}
+/**
+* Parse a time string and return the value in milliseconds.
+*
+* @param value - A time string like "7d", "30m", "1 hour", "2 hours ago"
+* @returns The parsed value in milliseconds
+* @throws TypeError if the string format is invalid
+*
+* @example
+* ms("1d")          // 86400000
+* ms("2 hours")     // 7200000
+* ms("30s")         // 30000
+* ms("2 hours ago") // -7200000
+*/
+function ms(value) {
+	return parse(value);
+}
+/**
+* Parse a time string and return the value in seconds.
+*
+* @param value - A time string like "7d", "30m", "1 hour", "2 hours ago"
+* @returns The parsed value in seconds (rounded)
+* @throws TypeError if the string format is invalid
+*
+* @example
+* sec("1d")          // 86400
+* sec("2 hours")     // 7200
+* sec("-30s")        // -30
+* sec("2 hours ago") // -7200
+*/
+function sec(value) {
+	return Math.round(parse(value) / 1e3);
+}
+
+//#endregion
+export { ms, sec };
+//# sourceMappingURL=time.mjs.map