@rio.js/enterprise 1.4.0

package/dist/plugins.d.mts

@@ -0,0 +1 @@
+export * from "better-auth/plugins";

package/dist/plugins.mjs

@@ -0,0 +1,13 @@
+import { s as HIDE_METADATA } from "./json-oFuWgANh-O1U6k3bL.mjs";
+import "./env-DwlNAN_D-C1zHd0cf-Cdlw8sNp.mjs";
+import "./verify-CN5Qc0e-.mjs";
+import "./social-providers-DNfE9Ak7-Be5zMAEe.mjs";
+import { $ as jwt, A as apiKey, B as oAuthDiscoveryMetadata, C as captcha, D as API_KEY_TABLE_NAME, E as admin, F as getMCPProtectedResourceMetadata, G as AuthzedSyncClient, H as oneTimeToken, I as getMCPProviderMetadata, J as getMetadata, K as graph, M as assetsClient, O as ERROR_CODES, P as defaultKeyHasher, Q as getJwtToken, R as lastLoginMethod, S as customSession, T as anonymous, U as organization, V as oAuthProtectedResourceMetadata, W as withMcpAuth, X as createJwk, Y as oidcProvider, Z as generateExportedKeyPair, _ as okta, a as openAPI, b as deviceAuthorization, c as multiSession, d as auth0, et as verifyJWT, f as genericOAuth, ft as createAuthEndpoint, g as microsoftEntraId, h as line, i as phoneNumber, j as assets, k as agents, l as magicLink, m as keycloak, mt as optionsMiddleware, n as username, o as oneTap, p as hubspot, pt as createAuthMiddleware, q as getClient, r as siwe, rt as twoFactor, s as oAuthProxy, t as USERNAME_ERROR_CODES, tt as TWO_FACTOR_ERROR_CODES, u as haveIBeenPwned, v as slack, w as bearer, x as deviceAuthorizationOptionsSchema, y as emailOTP, z as mcp } from "./plugins-BNFht2HW.mjs";
+import "./esm-C5TuvtGn.mjs";
+import "./dialect-C6_pK3V9-CPJHWkYR.mjs";
+import "./dist-CygcgJYk.mjs";
+import "./misc-CbURQDlR-sLtUwwQY.mjs";
+import "./parser-bL7W2mQ0-YdTgjtji.mjs";
+import { a as role, r as createAccessControl, t as twoFactorClient } from "./client--1_AEBPu-8Ae9icC9.mjs";
+
+export { API_KEY_TABLE_NAME, AuthzedSyncClient, ERROR_CODES, HIDE_METADATA, TWO_FACTOR_ERROR_CODES, USERNAME_ERROR_CODES, admin, agents, anonymous, apiKey, assets, assetsClient, auth0, bearer, captcha, createAccessControl, createAuthEndpoint, createAuthMiddleware, createJwk, customSession, defaultKeyHasher, deviceAuthorization, deviceAuthorizationOptionsSchema, emailOTP, generateExportedKeyPair, genericOAuth, getClient, getJwtToken, getMCPProtectedResourceMetadata, getMCPProviderMetadata, getMetadata, graph, haveIBeenPwned, hubspot, jwt, keycloak, lastLoginMethod, line, magicLink, mcp, microsoftEntraId, multiSession, oAuthDiscoveryMetadata, oAuthProtectedResourceMetadata, oAuthProxy, oidcProvider, okta, oneTap, oneTimeToken, openAPI, optionsMiddleware, organization, phoneNumber, role, siwe, slack, twoFactor, twoFactorClient, username, verifyJWT, withMcpAuth };

package/dist/react--VZQu7s1.mjs

@@ -0,0 +1,560 @@
+import { n as createFetch } from "./dist-CygcgJYk.mjs";
+import { r as getBaseURL, t as parseJSON } from "./parser-bL7W2mQ0-YdTgjtji.mjs";
+import { atom, listenKeys, onMount } from "nanostores";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+
+//#region ../better-auth/dist/proxy-Cm3asZSg.mjs
+const kBroadcastChannel = Symbol.for("better-auth:broadcast-channel");
+const now$1 = () => Math.floor(Date.now() / 1e3);
+var WindowBroadcastChannel = class {
+	listeners = /* @__PURE__ */ new Set();
+	name;
+	constructor(name = "better-auth.message") {
+		this.name = name;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	post(message) {
+		if (typeof window === "undefined") return;
+		try {
+			localStorage.setItem(this.name, JSON.stringify({
+				...message,
+				timestamp: now$1()
+			}));
+		} catch {}
+	}
+	setup() {
+		if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {};
+		const handler = (event) => {
+			if (event.key !== this.name) return;
+			const message = JSON.parse(event.newValue ?? "{}");
+			if (message?.event !== "session" || !message?.data) return;
+			this.listeners.forEach((listener) => listener(message));
+		};
+		window.addEventListener("storage", handler);
+		return () => {
+			window.removeEventListener("storage", handler);
+		};
+	}
+};
+function getGlobalBroadcastChannel(name = "better-auth.message") {
+	if (!globalThis[kBroadcastChannel]) globalThis[kBroadcastChannel] = new WindowBroadcastChannel(name);
+	return globalThis[kBroadcastChannel];
+}
+const kFocusManager = Symbol.for("better-auth:focus-manager");
+var WindowFocusManager = class {
+	listeners = /* @__PURE__ */ new Set();
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	setFocused(focused) {
+		this.listeners.forEach((listener) => listener(focused));
+	}
+	setup() {
+		if (typeof window === "undefined" || typeof document === "undefined" || typeof window.addEventListener === "undefined") return () => {};
+		const visibilityHandler = () => {
+			if (document.visibilityState === "visible") this.setFocused(true);
+		};
+		document.addEventListener("visibilitychange", visibilityHandler, false);
+		return () => {
+			document.removeEventListener("visibilitychange", visibilityHandler, false);
+		};
+	}
+};
+function getGlobalFocusManager() {
+	if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new WindowFocusManager();
+	return globalThis[kFocusManager];
+}
+const kOnlineManager = Symbol.for("better-auth:online-manager");
+var WindowOnlineManager = class {
+	listeners = /* @__PURE__ */ new Set();
+	isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	setOnline(online) {
+		this.isOnline = online;
+		this.listeners.forEach((listener) => listener(online));
+	}
+	setup() {
+		if (typeof window === "undefined" || typeof window.addEventListener === "undefined") return () => {};
+		const onOnline = () => this.setOnline(true);
+		const onOffline = () => this.setOnline(false);
+		window.addEventListener("online", onOnline, false);
+		window.addEventListener("offline", onOffline, false);
+		return () => {
+			window.removeEventListener("online", onOnline, false);
+			window.removeEventListener("offline", onOffline, false);
+		};
+	}
+};
+function getGlobalOnlineManager() {
+	if (!globalThis[kOnlineManager]) globalThis[kOnlineManager] = new WindowOnlineManager();
+	return globalThis[kOnlineManager];
+}
+const isServer = () => typeof window === "undefined";
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+	const value = atom({
+		data: null,
+		error: null,
+		isPending: true,
+		isRefetching: false,
+		refetch: (queryParams) => fn(queryParams)
+	});
+	const fn = async (queryParams) => {
+		return new Promise((resolve) => {
+			const opts = typeof options === "function" ? options({
+				data: value.get().data,
+				error: value.get().error,
+				isPending: value.get().isPending
+			}) : options;
+			$fetch(path, {
+				...opts,
+				query: {
+					...opts?.query,
+					...queryParams?.query
+				},
+				async onSuccess(context) {
+					value.set({
+						data: context.data,
+						error: null,
+						isPending: false,
+						isRefetching: false,
+						refetch: value.value.refetch
+					});
+					await opts?.onSuccess?.(context);
+				},
+				async onError(context) {
+					const { request } = context;
+					const retryAttempts = typeof request.retry === "number" ? request.retry : request.retry?.attempts;
+					const retryAttempt = request.retryAttempt || 0;
+					if (retryAttempts && retryAttempt < retryAttempts) return;
+					value.set({
+						error: context.error,
+						data: null,
+						isPending: false,
+						isRefetching: false,
+						refetch: value.value.refetch
+					});
+					await opts?.onError?.(context);
+				},
+				async onRequest(context) {
+					const currentValue = value.get();
+					value.set({
+						isPending: currentValue.data === null,
+						data: currentValue.data,
+						error: null,
+						isRefetching: true,
+						refetch: value.value.refetch
+					});
+					await opts?.onRequest?.(context);
+				}
+			}).catch((error) => {
+				value.set({
+					error,
+					data: null,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+			}).finally(() => {
+				resolve(void 0);
+			});
+		});
+	};
+	initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+	let isMounted = false;
+	for (const initAtom of initializedAtom) initAtom.subscribe(async () => {
+		if (isServer()) return;
+		if (isMounted) await fn();
+		else onMount(value, () => {
+			const timeoutId = setTimeout(async () => {
+				if (!isMounted) {
+					await fn();
+					isMounted = true;
+				}
+			}, 0);
+			return () => {
+				value.off();
+				initAtom.off();
+				clearTimeout(timeoutId);
+			};
+		});
+	});
+	return value;
+};
+const now = () => Math.floor(Date.now() / 1e3);
+/**
+* Rate limit: don't refetch on focus if a session request was made within this many seconds
+*/
+const FOCUS_REFETCH_RATE_LIMIT_SECONDS = 5;
+function createSessionRefreshManager(opts) {
+	const { sessionAtom, sessionSignal, $fetch, options = {} } = opts;
+	const refetchInterval = options.sessionOptions?.refetchInterval ?? 0;
+	const refetchOnWindowFocus = options.sessionOptions?.refetchOnWindowFocus ?? true;
+	const refetchWhenOffline = options.sessionOptions?.refetchWhenOffline ?? false;
+	const state = {
+		lastSync: 0,
+		lastSessionRequest: 0,
+		cachedSession: void 0
+	};
+	const shouldRefetch = () => {
+		return refetchWhenOffline || getGlobalOnlineManager().isOnline;
+	};
+	const triggerRefetch = (event) => {
+		if (!shouldRefetch()) return;
+		if (event?.event === "storage") {
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+			return;
+		}
+		const currentSession = sessionAtom.get();
+		if (event?.event === "poll") {
+			state.lastSessionRequest = now();
+			$fetch("/get-session").then((res) => {
+				sessionAtom.set({
+					...currentSession,
+					data: res.data,
+					error: res.error || null
+				});
+				state.lastSync = now();
+				sessionSignal.set(!sessionSignal.get());
+			}).catch(() => {});
+			return;
+		}
+		if (event?.event === "visibilitychange") {
+			if (now() - state.lastSessionRequest < FOCUS_REFETCH_RATE_LIMIT_SECONDS && currentSession?.data !== null && currentSession?.data !== void 0) return;
+		}
+		if (currentSession?.data === null || currentSession?.data === void 0 || event?.event === "visibilitychange") {
+			if (event?.event === "visibilitychange") state.lastSessionRequest = now();
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+		}
+	};
+	const broadcastSessionUpdate = (trigger) => {
+		getGlobalBroadcastChannel().post({
+			event: "session",
+			data: { trigger },
+			clientId: Math.random().toString(36).substring(7)
+		});
+	};
+	const setupPolling = () => {
+		if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
+			if (sessionAtom.get()?.data) triggerRefetch({ event: "poll" });
+		}, refetchInterval * 1e3);
+	};
+	const setupBroadcast = () => {
+		state.unsubscribeBroadcast = getGlobalBroadcastChannel().subscribe(() => {
+			triggerRefetch({ event: "storage" });
+		});
+	};
+	const setupFocusRefetch = () => {
+		if (!refetchOnWindowFocus) return;
+		state.unsubscribeFocus = getGlobalFocusManager().subscribe(() => {
+			triggerRefetch({ event: "visibilitychange" });
+		});
+	};
+	const setupOnlineRefetch = () => {
+		state.unsubscribeOnline = getGlobalOnlineManager().subscribe((online) => {
+			if (online) triggerRefetch({ event: "visibilitychange" });
+		});
+	};
+	const init = () => {
+		setupPolling();
+		setupBroadcast();
+		setupFocusRefetch();
+		setupOnlineRefetch();
+		getGlobalBroadcastChannel().setup();
+		getGlobalFocusManager().setup();
+		getGlobalOnlineManager().setup();
+	};
+	const cleanup = () => {
+		if (state.pollInterval) {
+			clearInterval(state.pollInterval);
+			state.pollInterval = void 0;
+		}
+		if (state.unsubscribeBroadcast) {
+			state.unsubscribeBroadcast();
+			state.unsubscribeBroadcast = void 0;
+		}
+		if (state.unsubscribeFocus) {
+			state.unsubscribeFocus();
+			state.unsubscribeFocus = void 0;
+		}
+		if (state.unsubscribeOnline) {
+			state.unsubscribeOnline();
+			state.unsubscribeOnline = void 0;
+		}
+		state.lastSync = 0;
+		state.lastSessionRequest = 0;
+		state.cachedSession = void 0;
+	};
+	return {
+		init,
+		cleanup,
+		triggerRefetch,
+		broadcastSessionUpdate
+	};
+}
+const redirectPlugin = {
+	id: "redirect",
+	name: "Redirect",
+	hooks: { onSuccess(context) {
+		if (context.data?.url && context.data?.redirect) {
+			if (typeof window !== "undefined" && window.location) {
+				if (window.location) try {
+					window.location.href = context.data.url;
+				} catch {}
+			}
+		}
+	} }
+};
+const userAgentPlugin = {
+	id: "user-agent",
+	name: "UserAgent",
+	hooks: { onRequest(context) {
+		context.headers.append("user-agent", "better-auth");
+	} }
+};
+function getSessionAtom($fetch, options) {
+	const $signal = atom(false);
+	const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
+	onMount(session, () => {
+		const refreshManager = createSessionRefreshManager({
+			sessionAtom: session,
+			sessionSignal: $signal,
+			$fetch,
+			options
+		});
+		refreshManager.init();
+		return () => {
+			refreshManager.cleanup();
+		};
+	});
+	return {
+		session,
+		$sessionSignal: $signal
+	};
+}
+const getClientConfig = (options, loadEnv) => {
+	const isCredentialsSupported = "credentials" in Request.prototype;
+	const baseURL = getBaseURL(options?.baseURL, options?.basePath, void 0, loadEnv) ?? "/api/auth";
+	const pluginsFetchPlugins = options?.plugins?.flatMap((plugin) => plugin.fetchPlugins).filter((pl) => pl !== void 0) || [];
+	const lifeCyclePlugin = {
+		id: "lifecycle-hooks",
+		name: "lifecycle-hooks",
+		hooks: {
+			onSuccess: options?.fetchOptions?.onSuccess,
+			onError: options?.fetchOptions?.onError,
+			onRequest: options?.fetchOptions?.onRequest,
+			onResponse: options?.fetchOptions?.onResponse
+		}
+	};
+	const { onSuccess, onError, onRequest, onResponse, ...restOfFetchOptions } = options?.fetchOptions || {};
+	const $fetch = createFetch({
+		baseURL,
+		...isCredentialsSupported ? { credentials: "include" } : {},
+		method: "GET",
+		jsonParser(text) {
+			if (!text) return null;
+			return parseJSON(text, { strict: false });
+		},
+		customFetchImpl: fetch,
+		...restOfFetchOptions,
+		plugins: [
+			lifeCyclePlugin,
+			...restOfFetchOptions.plugins || [],
+			...options?.disableDefaultFetchPlugins ? [] : [userAgentPlugin, redirectPlugin],
+			...pluginsFetchPlugins
+		]
+	});
+	const { $sessionSignal, session } = getSessionAtom($fetch, options);
+	const plugins = options?.plugins || [];
+	let pluginsActions = {};
+	let pluginsAtoms = {
+		$sessionSignal,
+		session
+	};
+	let pluginPathMethods = {
+		"/sign-out": "POST",
+		"/revoke-sessions": "POST",
+		"/revoke-other-sessions": "POST",
+		"/delete-user": "POST"
+	};
+	const atomListeners = [{
+		signal: "$sessionSignal",
+		matcher(path) {
+			return path === "/sign-out" || path === "/update-user" || path === "/sign-up/email" || path === "/sign-in/email" || path === "/delete-user" || path === "/verify-email" || path === "/revoke-sessions" || path === "/revoke-session" || path === "/change-email";
+		}
+	}];
+	for (const plugin of plugins) {
+		if (plugin.getAtoms) Object.assign(pluginsAtoms, plugin.getAtoms?.($fetch));
+		if (plugin.pathMethods) Object.assign(pluginPathMethods, plugin.pathMethods);
+		if (plugin.atomListeners) atomListeners.push(...plugin.atomListeners);
+	}
+	const $store = {
+		notify: (signal) => {
+			pluginsAtoms[signal].set(!pluginsAtoms[signal].get());
+		},
+		listen: (signal, listener) => {
+			pluginsAtoms[signal].subscribe(listener);
+		},
+		atoms: pluginsAtoms
+	};
+	for (const plugin of plugins) if (plugin.getActions) Object.assign(pluginsActions, plugin.getActions?.($fetch, $store, options));
+	return {
+		get baseURL() {
+			return baseURL;
+		},
+		pluginsActions,
+		pluginsAtoms,
+		pluginPathMethods,
+		atomListeners,
+		$fetch,
+		$store
+	};
+};
+function isAtom(value) {
+	return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function" && "lc" in value && typeof value.lc === "number";
+}
+function getMethod(path, knownPathMethods, args) {
+	const method = knownPathMethods[path];
+	const { fetchOptions, query, ...body } = args || {};
+	if (method) return method;
+	if (fetchOptions?.method) return fetchOptions.method;
+	if (body && Object.keys(body).length > 0) return "POST";
+	return "GET";
+}
+function createDynamicPathProxy(routes, client, knownPathMethods, atoms, atomListeners) {
+	function createProxy(path = []) {
+		return new Proxy(function() {}, {
+			get(_, prop) {
+				if (typeof prop !== "string") return;
+				if (prop === "then" || prop === "catch" || prop === "finally") return;
+				const fullPath = [...path, prop];
+				let current = routes;
+				for (const segment of fullPath) if (current && typeof current === "object" && segment in current) current = current[segment];
+				else {
+					current = void 0;
+					break;
+				}
+				if (typeof current === "function") return current;
+				if (isAtom(current)) return current;
+				return createProxy(fullPath);
+			},
+			apply: async (_, __, args) => {
+				const routePath = "/" + path.map((segment) => segment.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)).join("/");
+				const arg = args[0] || {};
+				const fetchOptions = args[1] || {};
+				const { query, fetchOptions: argFetchOptions, ...body } = arg;
+				const options = {
+					...fetchOptions,
+					...argFetchOptions
+				};
+				const method = getMethod(routePath, knownPathMethods, arg);
+				return await client(routePath, {
+					...options,
+					body: method === "GET" ? void 0 : {
+						...body,
+						...options?.body || {}
+					},
+					query: query || options?.query,
+					method,
+					async onSuccess(context) {
+						await options?.onSuccess?.(context);
+						if (!atomListeners || options.disableSignal) return;
+						/**
+						* We trigger listeners
+						*/
+						const matches = atomListeners.filter((s) => s.matcher(routePath));
+						if (!matches.length) return;
+						for (const match of matches) {
+							const signal = atoms[match.signal];
+							if (!signal) return;
+							/**
+							* To avoid race conditions we set the signal in a setTimeout
+							*/
+							const val = signal.get();
+							setTimeout(() => {
+								signal.set(!val);
+							}, 10);
+						}
+					}
+				});
+			}
+		});
+	}
+	return createProxy();
+}
+
+//#endregion
+//#region ../better-auth/dist/client/react/index.mjs
+/**
+* Subscribe to store changes and get store's value.
+*
+* Can be used with store builder too.
+*
+* ```js
+* import { useStore } from 'nanostores/react'
+*
+* import { router } from '../store/router'
+*
+* export const Layout = () => {
+*   let page = useStore(router)
+*   if (page.route === 'home') {
+*     return <HomePage />
+*   } else {
+*     return <Error404 />
+*   }
+* }
+* ```
+*
+* @param store Store instance.
+* @returns Store value.
+*/
+function useStore(store, options = {}) {
+	let snapshotRef = useRef(store.get());
+	const { keys, deps = [store, keys] } = options;
+	let subscribe = useCallback((onChange) => {
+		const emitChange = (value) => {
+			if (snapshotRef.current === value) return;
+			snapshotRef.current = value;
+			onChange();
+		};
+		emitChange(store.value);
+		if (keys?.length) return listenKeys(store, keys, emitChange);
+		return store.listen(emitChange);
+	}, deps);
+	let get = () => snapshotRef.current;
+	return useSyncExternalStore(subscribe, get, get);
+}
+function getAtomKey(str) {
+	return `use${capitalizeFirstLetter(str)}`;
+}
+function capitalizeFirstLetter(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, $fetch, $store, atomListeners } = getClientConfig(options);
+	let resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+
+//#endregion
+export { useAuthQuery as i, createAuthClient as n, useStore as r, capitalizeFirstLetter as t };

package/dist/react.d.mts

@@ -0,0 +1 @@
+export * from "better-auth/react";

package/dist/react.mjs

@@ -0,0 +1,6 @@
+import "./env-DwlNAN_D-C1zHd0cf-Cdlw8sNp.mjs";
+import "./dist-CygcgJYk.mjs";
+import "./parser-bL7W2mQ0-YdTgjtji.mjs";
+import { n as createAuthClient, r as useStore, t as capitalizeFirstLetter } from "./react--VZQu7s1.mjs";
+
+export { capitalizeFirstLetter, createAuthClient, useStore };

package/dist/server.d.mts

@@ -0,0 +1,10 @@
+import "dotenv/config";
+import * as elysia0 from "elysia";
+
+//#region src/server.d.ts
+declare const _default: {
+  fetch: (request: Request) => elysia0.MaybePromise<Response>;
+  port: number;
+};
+//#endregion
+export { _default as default };

package/dist/server.mjs

@@ -0,0 +1,45 @@
+import { n as db } from "./db-BVXTgOd3.mjs";
+import "./json-oFuWgANh-O1U6k3bL.mjs";
+import "./env-DwlNAN_D-C1zHd0cf-Cdlw8sNp.mjs";
+import "./verify-CN5Qc0e-.mjs";
+import "./social-providers-DNfE9Ak7-Be5zMAEe.mjs";
+import "./plugins-BNFht2HW.mjs";
+import "./esm-C5TuvtGn.mjs";
+import "./dialect-C6_pK3V9-CPJHWkYR.mjs";
+import "./dist-CygcgJYk.mjs";
+import "./misc-CbURQDlR-sLtUwwQY.mjs";
+import "./parser-bL7W2mQ0-YdTgjtji.mjs";
+import "./client--1_AEBPu-8Ae9icC9.mjs";
+import "./db-schema.final-DWleoQm0.mjs";
+import "./adapter-factory-BTRALCLD-kJBwe70v.mjs";
+import { t as auth } from "./better-auth-CqfhQJYE.mjs";
+import "dotenv/config";
+import { cors } from "@elysiajs/cors";
+import { jwt } from "@elysiajs/jwt";
+import openapi from "@elysiajs/openapi";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { Elysia } from "elysia";
+
+//#region src/server.ts
+await migrate(db, {
+	migrationsFolder: "./drizzle",
+	migrationsSchema: "enterprise",
+	migrationsTable: "_migrations"
+});
+await import("./init-D8lwWc90.mjs");
+const app = new Elysia().use(openapi({ path: "/openapi" })).use(jwt({
+	name: "jwt",
+	secret: "Fischl von Luftschloss Narfidort"
+})).use(cors()).all("/api/auth/*", (context) => {
+	if (["POST", "GET"].includes(context.request.method)) return auth.handler(context.request);
+	else throw new Error("Method not allowed");
+}).get("/", () => "Hello Elysia");
+var server_default = {
+	fetch: app.fetch.bind(app),
+	port: 3001
+};
+console.log("Server is running on port 3001");
+console.log("Playground: http://localhost:3001/api/auth/reference");
+
+//#endregion
+export { server_default as default };