/opt/canhelp/node_modules/better-auth/dist/context
Edit: /opt/canhelp/node_modules/better-auth/dist/context/helpers.mjs (4087B)
import { getBaseURL, isDynamicBaseURLConfig } from "../utils/url.mjs";
import { createInternalAdapter } from "../db/internal-adapter.mjs";
import "../db/index.mjs";
import { isPromise } from "../utils/is-promise.mjs";
import { env } from "@better-auth/core/env";
import { defu as defu$1 } from "defu";
//#region src/context/helpers.ts
async function runPluginInit(context) {
let options = context.options;
const plugins = options.plugins || [];
const pluginTrustedOrigins = [];
const dbHooks = [];
for (const plugin of plugins) if (plugin.init) {
const initPromise = plugin.init(context);
let result;
if (isPromise(initPromise)) result = await initPromise;
else result = initPromise;
if (typeof result === "object") {
if (result.options) {
const { databaseHooks, trustedOrigins, ...restOpts } = result.options;
if (databaseHooks) dbHooks.push({
source: `plugin:${plugin.id}`,
hooks: databaseHooks
});
if (trustedOrigins) pluginTrustedOrigins.push(trustedOrigins);
options = defu$1(options, restOpts);
}
if (result.context) Object.assign(context, result.context);
}
}
if (pluginTrustedOrigins.length > 0) {
const allSources = [...options.trustedOrigins ? [options.trustedOrigins] : [], ...pluginTrustedOrigins];
const staticOrigins = allSources.filter(Array.isArray).flat();
const dynamicOrigins = allSources.filter((s) => typeof s === "function");
if (dynamicOrigins.length > 0) options.trustedOrigins = async (request) => {
const resolved = await Promise.all(dynamicOrigins.map((fn) => fn(request)));
return [...staticOrigins, ...resolved.flat()].filter((v) => typeof v === "string" && v !== "");
};
else options.trustedOrigins = staticOrigins;
}
if (options.databaseHooks) dbHooks.push({
source: "user",
hooks: options.databaseHooks
});
context.internalAdapter = createInternalAdapter(context.adapter, {
options,
logger: context.logger,
hooks: dbHooks,
generateId: context.generateId
});
context.options = options;
}
function getInternalPlugins(options) {
const plugins = [];
if (options.advanced?.crossSubDomainCookies?.enabled) {}
return plugins;
}
async function getTrustedOrigins(options, request) {
const trustedOrigins = [];
if (isDynamicBaseURLConfig(options.baseURL)) {
const allowedHosts = options.baseURL.allowedHosts;
for (const host of allowedHosts) if (!host.includes("://")) {
trustedOrigins.push(`https://${host}`);
if (host.includes("localhost") || host.includes("127.0.0.1")) trustedOrigins.push(`http://${host}`);
} else trustedOrigins.push(host);
if (options.baseURL.fallback) try {
trustedOrigins.push(new URL(options.baseURL.fallback).origin);
} catch {}
} else {
const baseURL = getBaseURL(typeof options.baseURL === "string" ? options.baseURL : void 0, options.basePath, request);
if (baseURL) trustedOrigins.push(new URL(baseURL).origin);
}
if (options.trustedOrigins) {
if (Array.isArray(options.trustedOrigins)) trustedOrigins.push(...options.trustedOrigins);
if (typeof options.trustedOrigins === "function") {
const validOrigins = await options.trustedOrigins(request);
trustedOrigins.push(...validOrigins);
}
}
const envTrustedOrigins = env.BETTER_AUTH_TRUSTED_ORIGINS;
if (envTrustedOrigins) trustedOrigins.push(...envTrustedOrigins.split(","));
return trustedOrigins.filter((v) => Boolean(v));
}
async function getAwaitableValue(arr, item) {
if (!arr) return void 0;
for (const val of arr) {
const value = typeof val === "function" ? await val() : val;
if (value[item.field ?? "id"] === item.value) return value;
}
}
async function getTrustedProviders(options, request) {
const trustedProviders = options.account?.accountLinking?.trustedProviders;
if (!trustedProviders) return [];
if (Array.isArray(trustedProviders)) return trustedProviders.filter((v) => Boolean(v));
return (await trustedProviders(request) ?? []).filter((v) => Boolean(v));
}
//#endregion
export { getAwaitableValue, getInternalPlugins, getTrustedOrigins, getTrustedProviders, runPluginInit };
//# sourceMappingURL=helpers.mjs.map