@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

package/dist/server/mutations/retrieve.js

@@ -1,9 +1,9 @@
-import { LOG_LEVELS, logWithLevel, maybeRedact } from "../utils.js";
+import { LOG_LEVELS } from "../../shared/log.js";
 import { verify } from "../crypto.js";
 import { authDb } from "../db.js";
+import { log, maybeRedact } from "../log.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
 import { isSignInRateLimited, recordFailedSignIn, resetSignInRateLimit } from "../limits.js";
-import { Fx } from "@robelest/fx";
 import { v } from "convex/values";
 
 //#region src/server/mutations/retrieve.ts
@@ -14,40 +14,40 @@ const retrieveAccountWithCredentialsArgs = v.object({
 		secret: v.optional(v.string())
 	})
 });
-function retrieveAccountWithCredentialsImpl(ctx, args, getProviderOrThrow, config) {
+async function retrieveAccountWithCredentialsImpl(ctx, args, getProviderOrThrow, config) {
 	const { provider: providerId, account } = args;
 	const db = authDb(ctx, config);
-	logWithLevel(LOG_LEVELS.DEBUG, "retrieveAccountWithCredentialsImpl args:", {
+	log(LOG_LEVELS.DEBUG, "retrieveAccountWithCredentialsImpl args:", {
 		provider: providerId,
 		account: {
 			id: account.id,
 			secret: maybeRedact(account.secret ?? "")
 		}
 	});
-	return Fx.gen(function* () {
-		const existingAccount = yield* Fx.promise(() => db.accounts.get(providerId, account.id));
+	try {
+		const existingAccount = await db.accounts.get(providerId, account.id);
 		if (existingAccount === null) return "InvalidAccountId";
 		if (account.secret !== void 0) {
-			if (yield* isSignInRateLimited(ctx, existingAccount._id, config)) return "TooManyFailedAttempts";
-			if (!(yield* verify(getProviderOrThrow(providerId), account.secret, existingAccount.secret ?? ""))) {
-				yield* recordFailedSignIn(ctx, existingAccount._id, config);
+			const accountSecret = account.secret;
+			if (await isSignInRateLimited(ctx, existingAccount._id, config)) return "TooManyFailedAttempts";
+			if (!await verify(getProviderOrThrow(providerId), accountSecret, existingAccount.secret ?? "")) {
+				await recordFailedSignIn(ctx, existingAccount._id, config);
 				return "InvalidSecret";
 			}
-			yield* resetSignInRateLimit(ctx, existingAccount._id, config);
+			await resetSignInRateLimit(ctx, existingAccount._id, config);
 		}
-		const user = yield* Fx.promise(() => db.users.getById(existingAccount.userId));
+		const user = await db.users.getById(existingAccount.userId);
 		if (user === null) {
-			logWithLevel(LOG_LEVELS.ERROR, `Account ${existingAccount._id} is linked to missing user ${existingAccount.userId}`);
+			log(LOG_LEVELS.ERROR, `Account ${existingAccount._id} is linked to missing user ${existingAccount.userId}`);
 			return "InvalidAccountId";
 		}
 		return {
 			account: existingAccount,
 			user
 		};
-	}).pipe(Fx.fold({
-		ok: (v$1) => v$1,
-		err: () => "InvalidAccountId"
-	}));
+	} catch {
+		return "InvalidAccountId";
+	}
 }
 const callRetrieveAccountWithCredentials = async (ctx, args) => {
 	return ctx.runMutation(AUTH_STORE_REF, { args: {

package/dist/server/mutations/signature.js

@@ -1,30 +1,27 @@
 import { authDb } from "../db.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
-import { Fx } from "@robelest/fx";
-import { Cv } from "@robelest/fx/convex";
-import { v } from "convex/values";
+import { ConvexError, v } from "convex/values";
 
 //#region src/server/mutations/signature.ts
 const verifierSignatureArgs = v.object({
 	verifier: v.string(),
 	signature: v.string()
 });
-function verifierSignatureImpl(ctx, args, config) {
-	return Fx.gen(function* () {
-		const { verifier, signature } = args;
-		const db = authDb(ctx, config);
-		const verifierDoc = yield* Fx.from({
-			ok: () => db.verifiers.getById(verifier),
-			err: () => Cv.error({
-				code: "INVALID_VERIFIER",
-				message: "Invalid or expired verifier."
-			})
-		}).pipe(Fx.chain((doc) => doc === null ? Cv.fail({
-			code: "INVALID_VERIFIER",
-			message: "Invalid or expired verifier."
-		}) : Fx.succeed(doc)));
-		yield* Fx.promise(() => db.verifiers.patch(verifierDoc._id, { signature }));
+async function verifierSignatureImpl(ctx, args, config) {
+	const { verifier, signature } = args;
+	const db = authDb(ctx, config);
+	const invalidVerifierError = new ConvexError({
+		code: "INVALID_VERIFIER",
+		message: "Invalid or expired verifier."
 	});
+	let verifierDoc;
+	try {
+		verifierDoc = await db.verifiers.getById(verifier);
+	} catch {
+		throw invalidVerifierError;
+	}
+	if (verifierDoc == null) throw invalidVerifierError;
+	await db.verifiers.patch(verifierDoc._id, { signature });
 }
 const callVerifierSignature = async (ctx, args) => {
 	return ctx.runMutation(AUTH_STORE_REF, { args: {

package/dist/server/mutations/signin.js

@@ -1,6 +1,7 @@
-import { LOG_LEVELS, logWithLevel } from "../utils.js";
+import { LOG_LEVELS } from "../../shared/log.js";
+import { log } from "../log.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
-import { createNewAndDeleteExistingSession, maybeGenerateTokensForSession } from "../sessions.js";
+import { getAuthSessionId, issueSession } from "../sessions.js";
 import { v } from "convex/values";
 
 //#region src/server/mutations/signin.ts
@@ -10,10 +11,14 @@ const signInArgs = v.object({
 	generateTokens: v.boolean()
 });
 async function signInImpl(ctx, args, config) {
-	logWithLevel(LOG_LEVELS.DEBUG, "signInImpl args:", args);
+	log(LOG_LEVELS.DEBUG, "signInImpl args:", args);
 	const { userId, sessionId: existingSessionId, generateTokens } = args;
-	const typedUserId = userId;
-	return await maybeGenerateTokensForSession(ctx, config, typedUserId, existingSessionId ?? await createNewAndDeleteExistingSession(ctx, config, typedUserId), generateTokens);
+	return await issueSession(ctx, config, {
+		userId,
+		existingSessionId,
+		replaceSessionId: existingSessionId === void 0 ? await getAuthSessionId(ctx) ?? void 0 : void 0,
+		generateTokens
+	});
 }
 const callSignIn = async (ctx, args) => {
 	return ctx.runMutation(AUTH_STORE_REF, { args: {

package/dist/server/mutations/signout.js

@@ -1,22 +1,19 @@
 import { authDb } from "../db.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
 import { deleteSession, getAuthSessionId } from "../sessions.js";
-import { Fx } from "@robelest/fx";
 
 //#region src/server/mutations/signout.ts
-function signOutImpl(ctx, config) {
-	return Fx.gen(function* () {
-		const db = authDb(ctx, config);
-		const sessionId = yield* Fx.promise(() => getAuthSessionId(ctx));
-		if (sessionId === null) return null;
-		const session = yield* Fx.promise(() => db.sessions.getById(sessionId));
-		if (session === null) return null;
-		yield* Fx.promise(() => deleteSession(ctx, session, config));
-		return {
-			userId: session.userId,
-			sessionId: session._id
-		};
-	});
+async function signOutImpl(ctx, config) {
+	const db = authDb(ctx, config);
+	const sessionId = await getAuthSessionId(ctx);
+	if (sessionId == null) return null;
+	const session = await db.sessions.getById(sessionId);
+	if (session == null) return null;
+	await deleteSession(ctx, session, config);
+	return {
+		userId: session.userId,
+		sessionId: session._id
+	};
 }
 const callSignOut = async (ctx) => {
 	return ctx.runMutation(AUTH_STORE_REF, { args: { type: "signOut" } });

package/dist/server/mutations/store.js

@@ -1,17 +1,17 @@
-import { LOG_LEVELS, logWithLevel } from "../utils.js";
+import { LOG_LEVELS } from "../../shared/log.js";
+import { log } from "../log.js";
 import { modifyAccountArgs, modifyAccountImpl } from "./account.js";
 import { createVerificationCodeArgs, createVerificationCodeImpl } from "./code.js";
 import { invalidateSessionsArgs, invalidateSessionsImpl } from "./invalidate.js";
 import { userOAuthArgs, userOAuthImpl } from "./oauth.js";
-import { refreshSessionArgs, refreshSessionImpl } from "./refresh.js";
+import { refreshSessionArgs } from "./refresh.js";
 import { createAccountFromCredentialsArgs, createAccountFromCredentialsImpl } from "./register.js";
 import { retrieveAccountWithCredentialsArgs, retrieveAccountWithCredentialsImpl } from "./retrieve.js";
 import { verifierSignatureArgs, verifierSignatureImpl } from "./signature.js";
 import { signInArgs, signInImpl } from "./signin.js";
 import { signOutImpl } from "./signout.js";
-import { verifierImpl } from "./verifier.js";
+import { verifierArgs, verifierImpl } from "./verifier.js";
 import { verifyCodeAndSignInArgs, verifyCodeAndSignInImpl } from "./verify.js";
-import { Fx } from "@robelest/fx";
 import { v } from "convex/values";
 
 //#region src/server/mutations/store.ts
@@ -24,7 +24,10 @@ const storeArgs = v.object({ args: v.union(v.object({
 }), v.object({
 	type: v.literal("verifyCodeAndSignIn"),
 	...verifyCodeAndSignInArgs.fields
-}), v.object({ type: v.literal("verifier") }), v.object({
+}), v.object({
+	type: v.literal("verifier"),
+	...verifierArgs.fields
+}), v.object({
 	type: v.literal("verifierSignature"),
 	...verifierSignatureArgs.fields
 }), v.object({
@@ -46,23 +49,27 @@ const storeArgs = v.object({ args: v.union(v.object({
 	type: v.literal("invalidateSessions"),
 	...invalidateSessionsArgs.fields
 })) });
-const storeImpl = async (ctx, fnArgs, getProviderOrThrow, config) => {
+const storeImpl = async (ctx, fnArgs, services) => {
 	const args = fnArgs.args;
-	logWithLevel(LOG_LEVELS.INFO, `\`auth:store\` type: ${args.type}`);
-	return Fx.run(Fx.match(args, args.type, {
-		signIn: (a) => Fx.promise(() => signInImpl(ctx, a, config)),
+	const config = services.config;
+	const getProviderOrThrow = services.providerRegistry.getProviderOrThrow;
+	log(LOG_LEVELS.DEBUG, `\`auth:store\` type: ${args.type}`);
+	const handler = {
+		signIn: (a) => signInImpl(ctx, a, config),
 		signOut: () => signOutImpl(ctx, config),
-		refreshSession: (a) => Fx.promise(() => refreshSessionImpl(ctx, a, getProviderOrThrow, config)),
-		verifyCodeAndSignIn: (a) => Fx.promise(() => verifyCodeAndSignInImpl(ctx, a, getProviderOrThrow, config)),
-		verifier: () => verifierImpl(ctx, config),
-		verifierSignature: (a) => verifierSignatureImpl(ctx, a, config).pipe(Fx.recover((e) => Fx.fatal(e))),
-		userOAuth: (a) => userOAuthImpl(ctx, a, getProviderOrThrow, config).pipe(Fx.recover((e) => Fx.fatal(e))),
-		createVerificationCode: (a) => Fx.promise(() => createVerificationCodeImpl(ctx, a, getProviderOrThrow, config)),
-		createAccountFromCredentials: (a) => Fx.promise(() => createAccountFromCredentialsImpl(ctx, a, getProviderOrThrow, config)),
+		refreshSession: (a) => services.refresh.refresh(ctx, a),
+		verifyCodeAndSignIn: (a) => verifyCodeAndSignInImpl(ctx, a, getProviderOrThrow, config),
+		verifier: (a) => verifierImpl(ctx, a, config),
+		verifierSignature: (a) => verifierSignatureImpl(ctx, a, config),
+		userOAuth: (a) => userOAuthImpl(ctx, a, getProviderOrThrow, config),
+		createVerificationCode: (a) => createVerificationCodeImpl(ctx, a, getProviderOrThrow, config),
+		createAccountFromCredentials: (a) => createAccountFromCredentialsImpl(ctx, a, getProviderOrThrow, config),
 		retrieveAccountWithCredentials: (a) => retrieveAccountWithCredentialsImpl(ctx, a, getProviderOrThrow, config),
-		modifyAccount: (a) => modifyAccountImpl(ctx, a, getProviderOrThrow, config).pipe(Fx.recover((e) => Fx.fatal(e))),
+		modifyAccount: (a) => modifyAccountImpl(ctx, a, getProviderOrThrow, config),
 		invalidateSessions: (a) => invalidateSessionsImpl(ctx, a, config)
-	}));
+	}[args.type];
+	if (!handler) throw new Error(`Unknown store type: "${args.type}"`);
+	return await handler(args);
 };
 
 //#endregion

package/dist/server/mutations/verifier.js

@@ -1,18 +1,21 @@
 import { authDb } from "../db.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
 import { getAuthSessionId } from "../sessions.js";
-import { Fx } from "@robelest/fx";
+import { v } from "convex/values";
 
 //#region src/server/mutations/verifier.ts
-function verifierImpl(ctx, config) {
-	return Fx.gen(function* () {
-		return yield* Fx.promise(async () => authDb(ctx, config).verifiers.create(await getAuthSessionId(ctx) ?? void 0));
-	});
+const verifierArgs = v.object({ signature: v.optional(v.string()) });
+async function verifierImpl(ctx, args, config) {
+	const sessionId = await getAuthSessionId(ctx);
+	return await authDb(ctx, config).verifiers.create(sessionId ?? void 0, args.signature);
 }
-const callVerifier = async (ctx) => {
-	return ctx.runMutation(AUTH_STORE_REF, { args: { type: "verifier" } });
+const callVerifier = async (ctx, signature) => {
+	return ctx.runMutation(AUTH_STORE_REF, { args: {
+		type: "verifier",
+		...signature === void 0 ? {} : { signature }
+	} });
 };
 
 //#endregion
-export { callVerifier, verifierImpl };
+export { callVerifier, verifierArgs, verifierImpl };
 //# sourceMappingURL=verifier.js.map

package/dist/server/mutations/verify.js

@@ -1,54 +1,53 @@
-import { LOG_LEVELS, logWithLevel, requireEnv, sha256 } from "../utils.js";
+import { LOG_LEVELS } from "../../shared/log.js";
+import { sha256 } from "../random.js";
 import { authDb } from "../db.js";
+import { requireEnv } from "../env.js";
+import { log } from "../log.js";
 import { AUTH_STORE_REF } from "./store/refs.js";
-import { createNewAndDeleteExistingSession, getAuthSessionId, maybeGenerateTokensForSession } from "../sessions.js";
+import { getAuthSessionId, issueSession } from "../sessions.js";
 import { upsertUserAndAccount } from "../users.js";
-import { isEnterpriseProviderId } from "../enterprise/shared.js";
-import { createSyntheticOAuthMaterializedConfig } from "../enterprise/oidc.js";
+import { payloadRecordValidator } from "../payloads.js";
+import { isGroupProviderId } from "../sso/shared.js";
+import { createSyntheticOAuthMaterializedConfig } from "../sso/oidc.js";
 import { isSignInRateLimited, recordFailedSignIn, resetSignInRateLimit } from "../limits.js";
-import { Fx } from "@robelest/fx";
 import { v } from "convex/values";
 
 //#region src/server/mutations/verify.ts
 const verifyCodeAndSignInArgs = v.object({
-	params: v.any(),
+	params: payloadRecordValidator,
 	provider: v.optional(v.string()),
 	verifier: v.optional(v.string()),
 	generateTokens: v.boolean(),
 	allowExtraProviders: v.boolean()
 });
-/** A soft verification failure — logged and collapsed to null at the boundary. */
-var VerifyFailure = class {
-	_tag = "VerifyFailure";
-	constructor(reason) {
-		this.reason = reason;
-	}
-};
 async function verifyCodeAndSignInImpl(ctx, args, getProviderOrThrow, config) {
-	logWithLevel(LOG_LEVELS.DEBUG, "verifyCodeAndSignInImpl args:", {
-		params: {
-			email: args.params.email,
-			phone: args.params.phone
-		},
-		provider: args.provider,
-		verifier: args.verifier,
-		generateTokens: args.generateTokens,
-		allowExtraProviders: args.allowExtraProviders
-	});
+	const params = args.params;
 	const { generateTokens, provider, allowExtraProviders } = args;
-	if (generateTokens) {
-		requireEnv("JWT_PRIVATE_KEY");
-		requireEnv("JWKS");
-		requireEnv("CONVEX_SITE_URL");
-	}
-	const identifier = args.params.email ?? args.params.phone;
+	const identifier = typeof params.email === "string" ? params.email : typeof params.phone === "string" ? params.phone : void 0;
 	try {
+		log(LOG_LEVELS.DEBUG, "verifyCodeAndSignInImpl args:", {
+			params: {
+				email: params.email,
+				phone: params.phone
+			},
+			provider: args.provider,
+			verifier: args.verifier,
+			generateTokens: args.generateTokens,
+			allowExtraProviders: args.allowExtraProviders
+		});
+		if (generateTokens) {
+			requireEnv("JWT_PRIVATE_KEY");
+			requireEnv("JWKS");
+			requireEnv("CONVEX_SITE_URL");
+		}
 		if (identifier !== void 0) {
-			if (await Fx.run(isSignInRateLimited(ctx, identifier, config))) throw new VerifyFailure("Too many failed attempts to verify code for this email");
+			if (await isSignInRateLimited(ctx, identifier, config)) throw new VerifyFailure("Too many failed attempts to verify code for this email");
 		}
 		const db = authDb(ctx, config);
-		const { params, verifier } = args;
-		const hash = await sha256(params.code);
+		const verifier = args.verifier;
+		const codeValue = params.code;
+		if (typeof codeValue !== "string") throw new VerifyFailure("Invalid verification code");
+		const hash = await sha256(codeValue);
 		const code = await db.verificationCodes.getByCode(hash);
 		if (code === null) throw new VerifyFailure("Invalid verification code");
 		await db.verificationCodes.delete(code._id);
@@ -57,9 +56,9 @@ async function verifyCodeAndSignInImpl(ctx, args, getProviderOrThrow, config) {
 		if (provider !== void 0 && code.provider !== provider) throw new VerifyFailure(`Invalid provider "${provider}" for given \`code\``);
 		const account = await db.accounts.getById(code.accountId);
 		if (account === null) throw new VerifyFailure("Account associated with this email has been deleted");
-		const codeProvider = isEnterpriseProviderId(code.provider) ? createSyntheticOAuthMaterializedConfig(code.provider) : getProviderOrThrow(code.provider, allowExtraProviders);
-		if (codeProvider !== null && (codeProvider.type === "email" || codeProvider.type === "phone") && codeProvider.authorize !== void 0) await codeProvider.authorize(args.params, account);
-		const methodProvider = isEnterpriseProviderId(account.provider) ? createSyntheticOAuthMaterializedConfig(account.provider) : getProviderOrThrow(account.provider);
+		const codeProvider = isGroupProviderId(code.provider) ? createSyntheticOAuthMaterializedConfig(code.provider) : getProviderOrThrow(code.provider, allowExtraProviders);
+		if (codeProvider !== null && (codeProvider.type === "email" || codeProvider.type === "phone") && codeProvider.authorize !== void 0) await codeProvider.authorize(params, account);
+		const methodProvider = isGroupProviderId(account.provider) ? createSyntheticOAuthMaterializedConfig(account.provider) : getProviderOrThrow(account.provider);
 		const userId = methodProvider.type === "oauth" ? account.userId : (await upsertUserAndAccount(ctx, await getAuthSessionId(ctx), { existingAccount: account }, {
 			type: "verification",
 			provider: methodProvider,
@@ -74,18 +73,31 @@ async function verifyCodeAndSignInImpl(ctx, args, getProviderOrThrow, config) {
 				} : {}
 			}
 		}, config)).userId;
-		if (identifier !== void 0) await Fx.run(resetSignInRateLimit(ctx, identifier, config));
-		return await maybeGenerateTokensForSession(ctx, config, userId, await createNewAndDeleteExistingSession(ctx, config, userId), generateTokens);
+		if (identifier !== void 0) await resetSignInRateLimit(ctx, identifier, config);
+		return await issueSession(ctx, config, {
+			userId,
+			replaceSessionId: await getAuthSessionId(ctx) ?? void 0,
+			generateTokens
+		});
 	} catch (error) {
 		if (error instanceof VerifyFailure) {
-			logWithLevel(LOG_LEVELS.ERROR, error.reason);
-			if (identifier !== void 0) await Fx.run(recordFailedSignIn(ctx, identifier, config));
+			log(LOG_LEVELS.ERROR, error.reason);
+			if (identifier !== void 0) await recordFailedSignIn(ctx, identifier, config);
 			return null;
 		}
-		logWithLevel(LOG_LEVELS.ERROR, `verifyCodeAndSignInImpl failed: ${String(error)}`);
-		return null;
+		throw error;
 	}
 }
+/** A soft verification failure -- logged and collapsed to null at the boundary. */
+var VerifyFailure = class extends Error {
+	_tag = "VerifyFailure";
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+		this.name = "VerifyFailure";
+	}
+};
 const callVerifyCodeAndSignIn = async (ctx, args) => {
 	return ctx.runMutation(AUTH_STORE_REF, { args: {
 		type: "verifyCodeAndSignIn",

package/dist/server/oauth/factory.js

@@ -0,0 +1,44 @@
+//#region src/server/oauth/factory.ts
+function normalizeTokens(tokens) {
+	const raw = tokens.data;
+	const rawScopes = typeof raw.scope === "string" ? raw.scope : void 0;
+	return {
+		accessToken: typeof raw.access_token === "string" ? raw.access_token : void 0,
+		refreshToken: typeof raw.refresh_token === "string" ? raw.refresh_token : void 0,
+		idToken: typeof raw.id_token === "string" ? raw.id_token : void 0,
+		accessTokenExpiresAt: typeof tokens.accessTokenExpiresAt === "function" ? tokens.accessTokenExpiresAt() : typeof raw.expires_in === "number" ? new Date(Date.now() + raw.expires_in * 1e3) : void 0,
+		scopes: rawScopes ? rawScopes.split(/[,\s]+/).map((scope) => scope.trim()).filter((scope) => scope.length > 0) : void 0,
+		raw: tokens.data
+	};
+}
+function createArcticOAuthClient(provider, options) {
+	const pkce = options?.pkce ?? (provider.createAuthorizationURL.length >= 3 ? "required" : "never");
+	return {
+		pkce,
+		createAuthorizationURL({ state, codeVerifier, scopes, nonce }) {
+			const url = pkce === "required" ? provider.createAuthorizationURL(state, codeVerifier, scopes) : provider.createAuthorizationURL(state, scopes);
+			if (nonce !== void 0) url.searchParams.set("nonce", nonce);
+			return url;
+		},
+		async validateAuthorizationCode({ code, codeVerifier }) {
+			return normalizeTokens(pkce === "required" ? await provider.validateAuthorizationCode(code, codeVerifier) : await provider.validateAuthorizationCode(code));
+		}
+	};
+}
+function createOAuthProvider(config) {
+	if (!config.provider || typeof config.provider.createAuthorizationURL !== "function" || typeof config.provider.validateAuthorizationCode !== "function") throw new Error(`OAuth provider "${config.id}" must expose createAuthorizationURL() and validateAuthorizationCode().`);
+	return {
+		id: config.id,
+		type: "oauth",
+		provider: config.provider,
+		scopes: [...config.scopes],
+		profile: config.profile,
+		nonce: config.nonce,
+		validateTokens: config.validateTokens,
+		accountLinking: config.accountLinking
+	};
+}
+
+//#endregion
+export { createArcticOAuthClient, createOAuthProvider };
+//# sourceMappingURL=factory.js.map

package/dist/server/oauth/index.js

@@ -0,0 +1,12 @@
+import { createArcticOAuthClient as createArcticOAuthClient$1, createOAuthProvider as createOAuthProvider$1 } from "./factory.js";
+import { createOAuthAuthorizationURL as createOAuthAuthorizationURL$1, getAuthorizationSignature as getAuthorizationSignature$1, handleOAuthCallback as handleOAuthCallback$1 } from "./runtime.js";
+
+//#region src/server/oauth/index.ts
+const createArcticOAuthClient = createArcticOAuthClient$1;
+const createOAuthAuthorizationURL = createOAuthAuthorizationURL$1;
+const createOAuthProvider = createOAuthProvider$1;
+const getAuthorizationSignature = getAuthorizationSignature$1;
+const handleOAuthCallback = handleOAuthCallback$1;
+
+//#endregion
+export { createArcticOAuthClient, createOAuthAuthorizationURL, createOAuthProvider, getAuthorizationSignature, handleOAuthCallback };