better-auth 1.3.8-beta.1 → 1.3.8-beta.3

package/dist/shared/better-auth.l2-e84v_.cjs

@@ -0,0 +1,491 @@
+'use strict';
+
+const index = require('./better-auth.ANpbi45u.cjs');
+const date = require('./better-auth.C1hdVENX.cjs');
+const env = require('./better-auth.B6fIklBU.cjs');
+const base64 = require('@better-auth/utils/base64');
+const hmac = require('@better-auth/utils/hmac');
+const json = require('./better-auth.vPQBmXQL.cjs');
+const url = require('./better-auth.DRmln2Nr.cjs');
+const binary = require('@better-auth/utils/binary');
+
+const JOSE_REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+const JOSE_MINUTE = 60;
+const JOSE_HOUR = JOSE_MINUTE * 60;
+const JOSE_DAY = JOSE_HOUR * 24;
+const JOSE_WEEK = JOSE_DAY * 7;
+const JOSE_YEAR = JOSE_DAY * 365.25;
+const createTime = (value, format) => {
+  const toMilliseconds = () => {
+    switch (format) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 1e3 * 60;
+      case "h":
+        return value * 1e3 * 60 * 60;
+      case "d":
+        return value * 1e3 * 60 * 60 * 24;
+      case "w":
+        return value * 1e3 * 60 * 60 * 24 * 7;
+      case "y":
+        return value * 1e3 * 60 * 60 * 24 * 365;
+    }
+  };
+  const time = {
+    t: `${value}${format}`,
+    value,
+    tFormat: format,
+    toMilliseconds,
+    toSeconds: () => time.toMilliseconds() / 1e3,
+    toMinutes: () => time.toSeconds() / 60,
+    toHours: () => time.toMinutes() / 60,
+    toDays: () => time.toHours() / 24,
+    toWeeks: () => time.toDays() / 7,
+    toYears: () => time.toDays() / 365,
+    getDate: () => new Date(Date.now() + time.toMilliseconds()),
+    add: (other) => {
+      const otherMs = typeof other === "string" ? parseTime(other).toMilliseconds() : other.toMilliseconds();
+      return createTime(time.toMilliseconds() + otherMs, "ms");
+    },
+    subtract: (other) => {
+      const otherMs = typeof other === "string" ? parseTime(other).toMilliseconds() : other.toMilliseconds();
+      return createTime(time.toMilliseconds() - otherMs, "ms");
+    },
+    multiply: (factor) => createTime(time.toMilliseconds() * factor, "ms"),
+    divide: (divisor) => createTime(time.toMilliseconds() / divisor, "ms"),
+    equals: (other) => {
+      const otherMs = typeof other === "string" ? parseTime(other).toMilliseconds() : other.toMilliseconds();
+      return time.toMilliseconds() === otherMs;
+    },
+    lessThan: (other) => {
+      const otherMs = typeof other === "string" ? parseTime(other).toMilliseconds() : other.toMilliseconds();
+      return time.toMilliseconds() < otherMs;
+    },
+    greaterThan: (other) => {
+      const otherMs = typeof other === "string" ? parseTime(other).toMilliseconds() : other.toMilliseconds();
+      return time.toMilliseconds() > otherMs;
+    },
+    format: (pattern) => {
+      const date = time.getDate();
+      return pattern.replace(/YYYY|MM|DD|HH|mm|ss/g, (match) => {
+        switch (match) {
+          case "YYYY":
+            return date.getFullYear().toString();
+          case "MM":
+            return (date.getMonth() + 1).toString().padStart(2, "0");
+          case "DD":
+            return date.getDate().toString().padStart(2, "0");
+          case "HH":
+            return date.getHours().toString().padStart(2, "0");
+          case "mm":
+            return date.getMinutes().toString().padStart(2, "0");
+          case "ss":
+            return date.getSeconds().toString().padStart(2, "0");
+          default:
+            return match;
+        }
+      });
+    },
+    fromNow: () => {
+      const ms = time.toMilliseconds();
+      if (ms < 0) return time.ago();
+      if (ms < 1e3) return "in a few seconds";
+      if (ms < 6e4) return `in ${Math.round(ms / 1e3)} seconds`;
+      if (ms < 36e5) return `in ${Math.round(ms / 6e4)} minutes`;
+      if (ms < 864e5) return `in ${Math.round(ms / 36e5)} hours`;
+      if (ms < 6048e5) return `in ${Math.round(ms / 864e5)} days`;
+      if (ms < 26298e5) return `in ${Math.round(ms / 6048e5)} weeks`;
+      if (ms < 315576e5) return `in ${Math.round(ms / 26298e5)} months`;
+      return `in ${Math.round(ms / 315576e5)} years`;
+    },
+    ago: () => {
+      const ms = -time.toMilliseconds();
+      if (ms < 0) return time.fromNow();
+      if (ms < 1e3) return "a few seconds ago";
+      if (ms < 6e4) return `${Math.round(ms / 1e3)} seconds ago`;
+      if (ms < 36e5) return `${Math.round(ms / 6e4)} minutes ago`;
+      if (ms < 864e5) return `${Math.round(ms / 36e5)} hours ago`;
+      if (ms < 6048e5) return `${Math.round(ms / 864e5)} days ago`;
+      if (ms < 26298e5) return `${Math.round(ms / 6048e5)} weeks ago`;
+      if (ms < 315576e5) return `${Math.round(ms / 26298e5)} months ago`;
+      return `${Math.round(ms / 315576e5)} years ago`;
+    }
+  };
+  return time;
+};
+const parseTime = (time) => {
+  const match = time.match(/^(\d+)(ms|s|m|h|d|w|y)$/);
+  if (!match) throw new Error("Invalid time format");
+  return createTime(parseInt(match[1]), match[2]);
+};
+const joseSecs = (str) => {
+  const matched = JOSE_REGEX.exec(str);
+  if (!matched || matched[4] && matched[1]) {
+    throw new TypeError("Invalid time period format");
+  }
+  const value = parseFloat(matched[2]);
+  const unit = matched[3].toLowerCase();
+  let numericDate;
+  switch (unit) {
+    case "sec":
+    case "secs":
+    case "second":
+    case "seconds":
+    case "s":
+      numericDate = Math.round(value);
+      break;
+    case "minute":
+    case "minutes":
+    case "min":
+    case "mins":
+    case "m":
+      numericDate = Math.round(value * JOSE_MINUTE);
+      break;
+    case "hour":
+    case "hours":
+    case "hr":
+    case "hrs":
+    case "h":
+      numericDate = Math.round(value * JOSE_HOUR);
+      break;
+    case "day":
+    case "days":
+    case "d":
+      numericDate = Math.round(value * JOSE_DAY);
+      break;
+    case "week":
+    case "weeks":
+    case "w":
+      numericDate = Math.round(value * JOSE_WEEK);
+      break;
+    // years matched
+    default:
+      numericDate = Math.round(value * JOSE_YEAR);
+      break;
+  }
+  if (matched[1] === "-" || matched[4] === "ago") {
+    return -numericDate;
+  }
+  return numericDate;
+};
+
+function parseSetCookieHeader(setCookie) {
+  const cookies = /* @__PURE__ */ new Map();
+  const cookieArray = setCookie.split(", ");
+  cookieArray.forEach((cookieString) => {
+    const parts = cookieString.split(";").map((part) => part.trim());
+    const [nameValue, ...attributes] = parts;
+    const [name, ...valueParts] = nameValue.split("=");
+    const value = valueParts.join("=");
+    if (!name || value === void 0) {
+      return;
+    }
+    const attrObj = { value };
+    attributes.forEach((attribute) => {
+      const [attrName, ...attrValueParts] = attribute.split("=");
+      const attrValue = attrValueParts.join("=");
+      const normalizedAttrName = attrName.trim().toLowerCase();
+      switch (normalizedAttrName) {
+        case "max-age":
+          attrObj["max-age"] = attrValue ? parseInt(attrValue.trim(), 10) : void 0;
+          break;
+        case "expires":
+          attrObj.expires = attrValue ? new Date(attrValue.trim()) : void 0;
+          break;
+        case "domain":
+          attrObj.domain = attrValue ? attrValue.trim() : void 0;
+          break;
+        case "path":
+          attrObj.path = attrValue ? attrValue.trim() : void 0;
+          break;
+        case "secure":
+          attrObj.secure = true;
+          break;
+        case "httponly":
+          attrObj.httponly = true;
+          break;
+        case "samesite":
+          attrObj.samesite = attrValue ? attrValue.trim().toLowerCase() : void 0;
+          break;
+        default:
+          attrObj[normalizedAttrName] = attrValue ? attrValue.trim() : true;
+          break;
+      }
+    });
+    cookies.set(name, attrObj);
+  });
+  return cookies;
+}
+function setCookieToHeader(headers) {
+  return (context) => {
+    const setCookieHeader = context.response.headers.get("set-cookie");
+    if (!setCookieHeader) {
+      return;
+    }
+    const cookieMap = /* @__PURE__ */ new Map();
+    const existingCookiesHeader = headers.get("cookie") || "";
+    existingCookiesHeader.split(";").forEach((cookie) => {
+      const [name, ...rest] = cookie.trim().split("=");
+      if (name && rest.length > 0) {
+        cookieMap.set(name, rest.join("="));
+      }
+    });
+    const setCookieHeaders = setCookieHeader.split(",");
+    setCookieHeaders.forEach((header) => {
+      const cookies = parseSetCookieHeader(header);
+      cookies.forEach((value, name) => {
+        cookieMap.set(name, value.value);
+      });
+    });
+    const updatedCookies = Array.from(cookieMap.entries()).map(([name, value]) => `${name}=${value}`).join("; ");
+    headers.set("cookie", updatedCookies);
+  };
+}
+
+function createCookieGetter(options) {
+  const secure = options.advanced?.useSecureCookies !== void 0 ? options.advanced?.useSecureCookies : options.baseURL !== void 0 ? options.baseURL.startsWith("https://") ? true : false : env.isProduction;
+  const secureCookiePrefix = secure ? "__Secure-" : "";
+  const crossSubdomainEnabled = !!options.advanced?.crossSubDomainCookies?.enabled;
+  const domain = crossSubdomainEnabled ? options.advanced?.crossSubDomainCookies?.domain || (options.baseURL ? new URL(options.baseURL).hostname : void 0) : void 0;
+  if (crossSubdomainEnabled && !domain) {
+    throw new index.BetterAuthError(
+      "baseURL is required when crossSubdomainCookies are enabled"
+    );
+  }
+  function createCookie(cookieName, overrideAttributes = {}) {
+    const prefix = options.advanced?.cookiePrefix || "better-auth";
+    const name = options.advanced?.cookies?.[cookieName]?.name || `${prefix}.${cookieName}`;
+    const attributes = options.advanced?.cookies?.[cookieName]?.attributes;
+    return {
+      name: `${secureCookiePrefix}${name}`,
+      attributes: {
+        secure: !!secureCookiePrefix,
+        sameSite: "lax",
+        path: "/",
+        httpOnly: true,
+        ...crossSubdomainEnabled ? { domain } : {},
+        ...options.advanced?.defaultCookieAttributes,
+        ...overrideAttributes,
+        ...attributes
+      }
+    };
+  }
+  return createCookie;
+}
+function getCookies(options) {
+  const createCookie = createCookieGetter(options);
+  const sessionMaxAge = options.session?.expiresIn || createTime(7, "d").toSeconds();
+  const sessionToken = createCookie("session_token", {
+    maxAge: sessionMaxAge
+  });
+  const sessionData = createCookie("session_data", {
+    maxAge: options.session?.cookieCache?.maxAge || 60 * 5
+  });
+  const dontRememberToken = createCookie("dont_remember");
+  return {
+    sessionToken: {
+      name: sessionToken.name,
+      options: sessionToken.attributes
+    },
+    /**
+     * This cookie is used to store the session data in the cookie
+     * This is useful for when you want to cache the session in the cookie
+     */
+    sessionData: {
+      name: sessionData.name,
+      options: sessionData.attributes
+    },
+    dontRememberToken: {
+      name: dontRememberToken.name,
+      options: dontRememberToken.attributes
+    }
+  };
+}
+async function setCookieCache(ctx, session) {
+  const shouldStoreSessionDataInCookie = ctx.context.options.session?.cookieCache?.enabled;
+  if (shouldStoreSessionDataInCookie) {
+    const filteredSession = Object.entries(session.session).reduce(
+      (acc, [key, value]) => {
+        const fieldConfig = ctx.context.options.session?.additionalFields?.[key];
+        if (!fieldConfig || fieldConfig.returned !== false) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {}
+    );
+    const sessionData = { session: filteredSession, user: session.user };
+    const expiresAtDate = date.getDate(
+      ctx.context.authCookies.sessionData.options.maxAge || 60,
+      "sec"
+    ).getTime();
+    const data = base64.base64Url.encode(
+      JSON.stringify({
+        session: sessionData,
+        expiresAt: expiresAtDate,
+        signature: await hmac.createHMAC("SHA-256", "base64urlnopad").sign(
+          ctx.context.secret,
+          JSON.stringify({
+            ...sessionData,
+            expiresAt: expiresAtDate
+          })
+        )
+      }),
+      {
+        padding: false
+      }
+    );
+    if (data.length > 4093) {
+      throw new index.BetterAuthError(
+        "Session data is too large to store in the cookie. Please disable session cookie caching or reduce the size of the session data"
+      );
+    }
+    ctx.setCookie(
+      ctx.context.authCookies.sessionData.name,
+      data,
+      ctx.context.authCookies.sessionData.options
+    );
+  }
+}
+async function setSessionCookie(ctx, session, dontRememberMe, overrides) {
+  const dontRememberMeCookie = await ctx.getSignedCookie(
+    ctx.context.authCookies.dontRememberToken.name,
+    ctx.context.secret
+  );
+  dontRememberMe = dontRememberMe !== void 0 ? dontRememberMe : !!dontRememberMeCookie;
+  const options = ctx.context.authCookies.sessionToken.options;
+  const maxAge = dontRememberMe ? void 0 : ctx.context.sessionConfig.expiresIn;
+  await ctx.setSignedCookie(
+    ctx.context.authCookies.sessionToken.name,
+    session.session.token,
+    ctx.context.secret,
+    {
+      ...options,
+      maxAge,
+      ...overrides
+    }
+  );
+  if (dontRememberMe) {
+    await ctx.setSignedCookie(
+      ctx.context.authCookies.dontRememberToken.name,
+      "true",
+      ctx.context.secret,
+      ctx.context.authCookies.dontRememberToken.options
+    );
+  }
+  await setCookieCache(ctx, session);
+  ctx.context.setNewSession(session);
+  if (ctx.context.options.secondaryStorage) {
+    await ctx.context.secondaryStorage?.set(
+      session.session.token,
+      JSON.stringify({
+        user: session.user,
+        session: session.session
+      }),
+      Math.floor(
+        (new Date(session.session.expiresAt).getTime() - Date.now()) / 1e3
+      )
+    );
+  }
+}
+function deleteSessionCookie(ctx, skipDontRememberMe) {
+  ctx.setCookie(ctx.context.authCookies.sessionToken.name, "", {
+    ...ctx.context.authCookies.sessionToken.options,
+    maxAge: 0
+  });
+  ctx.setCookie(ctx.context.authCookies.sessionData.name, "", {
+    ...ctx.context.authCookies.sessionData.options,
+    maxAge: 0
+  });
+  if (!skipDontRememberMe) {
+    ctx.setCookie(ctx.context.authCookies.dontRememberToken.name, "", {
+      ...ctx.context.authCookies.dontRememberToken.options,
+      maxAge: 0
+    });
+  }
+}
+function parseCookies(cookieHeader) {
+  const cookies = cookieHeader.split("; ");
+  const cookieMap = /* @__PURE__ */ new Map();
+  cookies.forEach((cookie) => {
+    const [name, value] = cookie.split("=");
+    cookieMap.set(name, value);
+  });
+  return cookieMap;
+}
+const getSessionCookie = (request, config) => {
+  if (config?.cookiePrefix) {
+    if (config.cookieName) {
+      config.cookiePrefix = `${config.cookiePrefix}-`;
+    } else {
+      config.cookiePrefix = `${config.cookiePrefix}.`;
+    }
+  }
+  const headers = "headers" in request ? request.headers : request;
+  const req = request instanceof Request ? request : void 0;
+  url.getBaseURL(req?.url, config?.path, req);
+  const cookies = headers.get("cookie");
+  if (!cookies) {
+    return null;
+  }
+  const { cookieName = "session_token", cookiePrefix = "better-auth." } = config || {};
+  const name = `${cookiePrefix}${cookieName}`;
+  const secureCookieName = `__Secure-${name}`;
+  const parsedCookie = parseCookies(cookies);
+  const sessionToken = parsedCookie.get(name) || parsedCookie.get(secureCookieName);
+  if (sessionToken) {
+    return sessionToken;
+  }
+  return null;
+};
+const getCookieCache = async (request, config) => {
+  const headers = request instanceof Headers ? request : request.headers;
+  const cookies = headers.get("cookie");
+  if (!cookies) {
+    return null;
+  }
+  const { cookieName = "session_data", cookiePrefix = "better-auth" } = config || {};
+  const name = config?.isSecure !== void 0 ? config.isSecure ? `__Secure-${cookiePrefix}.${cookieName}` : `${cookiePrefix}.${cookieName}` : env.isProduction ? `__Secure-${cookiePrefix}.${cookieName}` : `${cookiePrefix}.${cookieName}`;
+  const parsedCookie = parseCookies(cookies);
+  const sessionData = parsedCookie.get(name);
+  if (sessionData) {
+    const sessionDataPayload = json.safeJSONParse(binary.binary.decode(base64.base64Url.decode(sessionData)));
+    if (!sessionDataPayload) {
+      return null;
+    }
+    const secret = config?.secret || env.env.BETTER_AUTH_SECRET;
+    if (!secret) {
+      throw new index.BetterAuthError(
+        "getCookieCache requires a secret to be provided. Either pass it as an option or set the BETTER_AUTH_SECRET environment variable"
+      );
+    }
+    const isValid = await hmac.createHMAC("SHA-256", "base64urlnopad").verify(
+      secret,
+      JSON.stringify({
+        ...sessionDataPayload.session,
+        expiresAt: sessionDataPayload.expiresAt
+      }),
+      sessionDataPayload.signature
+    );
+    if (!isValid) {
+      return null;
+    }
+    return sessionDataPayload.session;
+  }
+  return null;
+};
+
+exports.createCookieGetter = createCookieGetter;
+exports.deleteSessionCookie = deleteSessionCookie;
+exports.getCookieCache = getCookieCache;
+exports.getCookies = getCookies;
+exports.getSessionCookie = getSessionCookie;
+exports.joseSecs = joseSecs;
+exports.parseCookies = parseCookies;
+exports.parseSetCookieHeader = parseSetCookieHeader;
+exports.setCookieCache = setCookieCache;
+exports.setCookieToHeader = setCookieToHeader;
+exports.setSessionCookie = setSessionCookie;