@revojs/auth 0.1.58

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+import { type Route } from "@revojs/server";
+import { type Scope } from "revojs";
+import type { Awaitable } from "revojs/shared";
+import { type InferInput } from "valibot";
+export type Principal = InferInput<typeof principalSchema>;
+export type PasswordMethod = InferInput<typeof passwordMethodSchema>;
+export type PasskeyMethod = InferInput<typeof passkeyMethodSchema>;
+export type ProviderMethod = InferInput<typeof providerMethodSchema>;
+export type Method = InferInput<typeof methodSchema>;
+export type Providers = "apple" | "github" | "google" | "microsoft";
+export interface Token {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token?: string;
+    id_token?: string;
+}
+export interface ProviderEndpoint {
+    url: string;
+    parameters?: Record<string, string>;
+    headers?: Record<string, string>;
+}
+export interface ProviderUserInfo {
+    sub?: string | number | null;
+    id?: string | number | null;
+    email?: string | null;
+    email_verified?: boolean | null;
+    given_name?: string | null;
+    first_name?: string | null;
+    name?: string | null;
+    family_name?: string | null;
+    last_name?: string | null;
+    picture?: string | null;
+    avatar_url?: string | null;
+    preferred_username?: string | null;
+    login?: string | null;
+    username?: string | null;
+}
+export interface AuthProviderOptions {
+    issuer: string;
+    scope: string;
+    clientKey: string;
+    clientSecret: string;
+    authorize: ProviderEndpoint;
+    token: ProviderEndpoint;
+    userInfo: ProviderEndpoint;
+    toPrincipal?: (principal: ProviderUserInfo) => Principal;
+}
+export interface AuthProvider {
+    setup: (scope: Scope) => AuthProviderOptions;
+}
+export declare function useAuth(scope: Scope): {
+    signInWithCredentials(credential: PasswordMethod | PasskeyMethod): Promise<unknown>;
+    signInWithProvider(provider: Providers | (string & {}), redirectUrl: string): Promise<void>;
+    signOut(): Promise<unknown>;
+};
+export declare function requireSession<T>(scope: Scope, redirectUrl: string): Promise<T>;
+export declare function getCryptoKey(scope: Scope): Promise<CryptoKey>;
+export declare function getSession<T>(scope: Scope): Promise<T | undefined>;
+export declare function setSession<T>(scope: Scope, session: T): Promise<void>;
+export declare function clearSession(scope: Scope): void;
+export declare function defineAuthProvider(provider: AuthProvider): Route;
+export declare const GET_PRINCIPAL_HOOK: import("revojs").Descriptor<(method: Method) => Awaitable<Principal | undefined>>;
+export declare const CREATE_PRINCIPAL_HOOK: import("revojs").Descriptor<(method: Method) => Awaitable<Principal | undefined>>;
+export declare const CREATE_SESSION_HOOK: import("revojs").Descriptor<(principal: Principal) => Awaitable<unknown>>;
+export declare const DELETE_SESSION_HOOK: import("revojs").Descriptor<(session: any) => Awaitable<unknown>>;
+export declare const registerAuthHooks: (scope: Scope, hooks: import("revojs").Hooks<{
+    getPrincipal: import("revojs").Descriptor<(method: Method) => Awaitable<Principal | undefined>>;
+    createPrincipal: import("revojs").Descriptor<(method: Method) => Awaitable<Principal | undefined>>;
+    createSession: import("revojs").Descriptor<(principal: Principal) => Awaitable<unknown>>;
+    deleteSession: import("revojs").Descriptor<(session: any) => Awaitable<unknown>>;
+}>) => void;
+export declare const principalSchema: import("valibot").ObjectSchema<{
+    readonly sub: import("valibot").StringSchema<undefined>;
+    readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly email_verified: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly given_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly family_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly picture: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly preferred_username: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const passwordMethodSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PASSWORD", undefined>;
+    readonly email: import("valibot").StringSchema<undefined>;
+    readonly password: import("valibot").StringSchema<undefined>;
+    readonly register: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, true>;
+}, undefined>;
+export declare const passkeyMethodSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PASSKEY", undefined>;
+}, undefined>;
+export declare const providerMethodSchema: import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PROVIDER", undefined>;
+    readonly issuer: import("valibot").StringSchema<undefined>;
+    readonly principal: import("valibot").ObjectSchema<{
+        readonly sub: import("valibot").StringSchema<undefined>;
+        readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly email_verified: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly given_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly family_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly picture: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly preferred_username: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const methodSchema: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PASSWORD", undefined>;
+    readonly email: import("valibot").StringSchema<undefined>;
+    readonly password: import("valibot").StringSchema<undefined>;
+    readonly register: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, true>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PASSKEY", undefined>;
+}, undefined>, import("valibot").ObjectSchema<{
+    readonly type: import("valibot").LiteralSchema<"PROVIDER", undefined>;
+    readonly issuer: import("valibot").StringSchema<undefined>;
+    readonly principal: import("valibot").ObjectSchema<{
+        readonly sub: import("valibot").StringSchema<undefined>;
+        readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly email_verified: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly given_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly family_name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly picture: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly preferred_username: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>], undefined>;

package/dist/index.js

@@ -0,0 +1,190 @@
+import options from "#config/auth";
+import { isClient, isServer } from "#variables";
+import { deleteCookie, fetch, sendRedirect, setCookie, useCookies, useHeaders, useQuery, useUrl, withQuery } from "@revojs/server";
+import { createRegisterHooks, defineHook, dispatchHookSingle, useVariables } from "revojs";
+import { boolean, literal, nullish, number, object, optional, parse, pipe, string, transform, union } from "valibot";
+//#region src/index.ts
+function useAuth(scope) {
+	return {
+		async signInWithCredentials(credential) {
+			return await fetch(scope, `/auth/sessions`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(credential)
+			});
+		},
+		async signInWithProvider(provider, redirectUrl) {
+			globalThis.location.href = `/auth/provider/${provider}?redirect=${encodeURIComponent(redirectUrl)}`;
+		},
+		async signOut() {
+			return await fetch(scope, `/auth/sessions`, { method: "DELETE" });
+		}
+	};
+}
+async function requireSession(scope, redirectUrl) {
+	if (isClient) {
+		const { pathname } = useUrl(scope);
+		try {
+			return await fetch(scope, "/auth/sessions", {
+				method: "GET",
+				headers: useHeaders(scope)
+			});
+		} catch {
+			if (redirectUrl !== pathname) globalThis.location.href = redirectUrl;
+		}
+	}
+	if (isServer) {
+		const session = await getSession(scope);
+		if (session) return session;
+		throw sendRedirect(scope, redirectUrl);
+	}
+	throw new Error("Session is unavailable");
+}
+async function getCryptoKey(scope) {
+	const { sessionSecret } = useVariables(scope);
+	return crypto.subtle.importKey("raw", encoder.encode(sessionSecret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign", "verify"]);
+}
+async function getSession(scope) {
+	const session = useCookies(scope)[options.session.name];
+	if (session) {
+		const index = session.lastIndexOf(".");
+		if (index > 0) try {
+			const payload = session.slice(0, index);
+			if (await crypto.subtle.verify("HMAC", await getCryptoKey(scope), Uint8Array.fromBase64(session.slice(index + 1), BASE64_VERIFY), Uint8Array.fromBase64(payload, BASE64_VERIFY))) return JSON.parse(decoder.decode(Uint8Array.fromBase64(payload, BASE64_VERIFY)));
+		} catch {}
+	}
+}
+async function setSession(scope, session) {
+	const value = encoder.encode(JSON.stringify(session));
+	const cookie = value.toBase64(BASE64_SIGN) + "." + new Uint8Array(await crypto.subtle.sign("HMAC", await getCryptoKey(scope), value)).toBase64(BASE64_SIGN);
+	setCookie(scope, options.session.name, cookie, options.session.cookie);
+}
+function clearSession(scope) {
+	deleteCookie(scope, options.session.name, options.session.cookie);
+}
+function defineAuthProvider(provider) {
+	return { async fetch(scope) {
+		const options = provider.setup(scope);
+		const { origin } = useUrl(scope);
+		const { code, state, redirect } = useQuery(scope);
+		const target = state ?? redirect ?? "/";
+		const redirectUri = `${origin}/auth/provider/${options.issuer}`;
+		const successPath = target.startsWith("/") && !target.startsWith("//") ? target : "/";
+		if (code) {
+			const token = await fetch(scope, options.token.url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded",
+					...options.token.headers
+				},
+				body: new URLSearchParams({
+					grant_type: "authorization_code",
+					client_id: options.clientKey,
+					client_secret: options.clientSecret,
+					redirect_uri: redirectUri,
+					code,
+					...options.token.parameters
+				})
+			});
+			const method = {
+				type: "PROVIDER",
+				issuer: options.issuer,
+				principal: (options.toPrincipal ?? ((user) => parse(userInfoSchema, user)))(await fetch(scope, options.userInfo.url, { headers: {
+					Authorization: `Bearer ${token.access_token}`,
+					...options.userInfo.headers
+				} }))
+			};
+			const principal = await dispatchHookSingle(scope, GET_PRINCIPAL_HOOK, method) ?? await dispatchHookSingle(scope, CREATE_PRINCIPAL_HOOK, method);
+			if (principal) {
+				const session = await dispatchHookSingle(scope, CREATE_SESSION_HOOK, principal);
+				if (session) {
+					await setSession(scope, session);
+					return sendRedirect(scope, successPath);
+				}
+			}
+		}
+		return sendRedirect(scope, withQuery(scope, options.authorize.url, {
+			response_type: "code",
+			client_id: options.clientKey,
+			redirect_uri: redirectUri,
+			scope: options.scope,
+			state: successPath,
+			...options.authorize.parameters
+		}));
+	} };
+}
+var GET_PRINCIPAL_HOOK = defineHook("GET_PRINCIPAL_HOOK");
+var CREATE_PRINCIPAL_HOOK = defineHook("CREATE_PRINCIPAL_HOOK");
+var CREATE_SESSION_HOOK = defineHook("CREATE_SESSION_HOOK");
+var DELETE_SESSION_HOOK = defineHook("DELETE_SESSION_HOOK");
+var registerAuthHooks = createRegisterHooks({
+	getPrincipal: GET_PRINCIPAL_HOOK,
+	createPrincipal: CREATE_PRINCIPAL_HOOK,
+	createSession: CREATE_SESSION_HOOK,
+	deleteSession: DELETE_SESSION_HOOK
+});
+var principalSchema = object({
+	sub: string(),
+	email: optional(string()),
+	email_verified: optional(boolean()),
+	given_name: optional(string()),
+	family_name: optional(string()),
+	picture: optional(string()),
+	preferred_username: optional(string())
+});
+var passwordMethodSchema = object({
+	type: literal("PASSWORD"),
+	email: string(),
+	password: string(),
+	register: optional(boolean(), true)
+});
+var passkeyMethodSchema = object({ type: literal("PASSKEY") });
+var providerMethodSchema = object({
+	type: literal("PROVIDER"),
+	issuer: string(),
+	principal: principalSchema
+});
+var methodSchema = union([
+	passwordMethodSchema,
+	passkeyMethodSchema,
+	providerMethodSchema
+]);
+var nullableStringSchema = nullish(string());
+var nullableIdentifierSchema = nullish(union([string(), number()]));
+var nullableBooleanSchema = nullish(boolean());
+var userInfoSchema = pipe(object({
+	sub: nullableIdentifierSchema,
+	id: nullableIdentifierSchema,
+	email: nullableStringSchema,
+	email_verified: nullableBooleanSchema,
+	given_name: nullableStringSchema,
+	first_name: nullableStringSchema,
+	name: nullableStringSchema,
+	family_name: nullableStringSchema,
+	last_name: nullableStringSchema,
+	picture: nullableStringSchema,
+	avatar_url: nullableStringSchema,
+	preferred_username: nullableStringSchema,
+	login: nullableStringSchema,
+	username: nullableStringSchema
+}), transform((user) => ({
+	sub: String(user.sub ?? user.id ?? ""),
+	email: user.email ?? void 0,
+	email_verified: user.email_verified ?? void 0,
+	given_name: user.given_name ?? user.first_name ?? user.name ?? void 0,
+	family_name: user.family_name ?? user.last_name ?? void 0,
+	picture: user.picture ?? user.avatar_url ?? void 0,
+	preferred_username: user.preferred_username ?? user.login ?? user.username ?? void 0
+})));
+var BASE64_SIGN = {
+	alphabet: "base64url",
+	omitPadding: true
+};
+var BASE64_VERIFY = { alphabet: "base64url" };
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+//#endregion
+export { CREATE_PRINCIPAL_HOOK, CREATE_SESSION_HOOK, DELETE_SESSION_HOOK, GET_PRINCIPAL_HOOK, clearSession, defineAuthProvider, getCryptoKey, getSession, methodSchema, passkeyMethodSchema, passwordMethodSchema, principalSchema, providerMethodSchema, registerAuthHooks, requireSession, setSession, useAuth };

package/dist/module/index.d.ts

@@ -0,0 +1,10 @@
+import type { CookieOptions } from "@revojs/server";
+export interface SessionOptions {
+    name: string;
+    cookie: CookieOptions;
+}
+export interface AuthConfig {
+    session: SessionOptions;
+}
+declare const _default: import("revojs/module").Module<"auth", AuthConfig, []>;
+export default _default;

package/dist/module/index.js

@@ -0,0 +1,62 @@
+import { defineModule, useModule } from "revojs/module";
+//#region src/module/index.ts
+var module_default = defineModule({
+	name: "auth",
+	config: () => ({ session: {
+		name: "session",
+		cookie: {
+			path: "/",
+			secure: true,
+			httpOnly: true,
+			sameSite: "Lax",
+			maxAge: 604800
+		}
+	} }),
+	setup() {
+		const { fromModule } = useModule(import.meta.url);
+		return {
+			variables: { server: {
+				sessionSecret: { type: "string" },
+				appleClientKey: {
+					type: "string",
+					optional: true
+				},
+				appleClientSecret: {
+					type: "string",
+					optional: true
+				},
+				githubClientKey: {
+					type: "string",
+					optional: true
+				},
+				githubClientSecret: {
+					type: "string",
+					optional: true
+				},
+				googleClientKey: {
+					type: "string",
+					optional: true
+				},
+				googleClientSecret: {
+					type: "string",
+					optional: true
+				},
+				microsoftClientKey: {
+					type: "string",
+					optional: true
+				},
+				microsoftClientSecret: {
+					type: "string",
+					optional: true
+				},
+				microsoftTenant: {
+					type: "string",
+					optional: true
+				}
+			} },
+			sources: { routes: { from: [fromModule("../routes")] } }
+		};
+	}
+});
+//#endregion
+export { module_default as default };

package/dist/routes/auth/provider/apple/get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@revojs/server").Route;
+export default _default;

package/dist/routes/auth/provider/apple/get.js

@@ -0,0 +1,22 @@
+import { defineAuthProvider } from "../../../../index.js";
+import { sendNotFound } from "@revojs/server";
+import { useVariables } from "revojs";
+//#region src/routes/auth/provider/apple/get.ts
+var get_default = defineAuthProvider({ setup(scope) {
+	const { appleClientKey, appleClientSecret } = useVariables(scope);
+	if (!appleClientKey || !appleClientSecret) throw sendNotFound(scope);
+	return {
+		issuer: "apple",
+		scope: "name email",
+		clientKey: appleClientKey,
+		clientSecret: appleClientSecret,
+		authorize: {
+			url: "https://appleid.apple.com/auth/authorize",
+			parameters: { response_mode: "query" }
+		},
+		token: { url: "https://appleid.apple.com/auth/token" },
+		userInfo: { url: "https://appleid.apple.com/auth/userinfo" }
+	};
+} });
+//#endregion
+export { get_default as default };

package/dist/routes/auth/provider/github/get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@revojs/server").Route;
+export default _default;

package/dist/routes/auth/provider/github/get.js

@@ -0,0 +1,37 @@
+import { defineAuthProvider } from "../../../../index.js";
+import { sendNotFound } from "@revojs/server";
+import { useVariables } from "revojs";
+//#region src/routes/auth/provider/github/get.ts
+var get_default = defineAuthProvider({ setup(scope) {
+	const { githubClientKey, githubClientSecret } = useVariables(scope);
+	if (!githubClientKey || !githubClientSecret) throw sendNotFound(scope);
+	return {
+		issuer: "github",
+		scope: "read:user user:email",
+		clientKey: githubClientKey,
+		clientSecret: githubClientSecret,
+		authorize: { url: "https://github.com/login/oauth/authorize" },
+		token: {
+			url: "https://github.com/login/oauth/access_token",
+			headers: { Accept: "application/json" }
+		},
+		userInfo: {
+			url: "https://api.github.com/user",
+			headers: {
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28"
+			}
+		},
+		toPrincipal(principal) {
+			return {
+				sub: String(principal.id),
+				email: principal.email ?? void 0,
+				given_name: principal.name ?? void 0,
+				picture: principal.avatar_url ?? void 0,
+				preferred_username: principal.login ?? void 0
+			};
+		}
+	};
+} });
+//#endregion
+export { get_default as default };

package/dist/routes/auth/provider/google/get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@revojs/server").Route;
+export default _default;

package/dist/routes/auth/provider/google/get.js

@@ -0,0 +1,19 @@
+import { defineAuthProvider } from "../../../../index.js";
+import { sendNotFound } from "@revojs/server";
+import { useVariables } from "revojs";
+//#region src/routes/auth/provider/google/get.ts
+var get_default = defineAuthProvider({ setup(scope) {
+	const { googleClientKey, googleClientSecret } = useVariables(scope);
+	if (!googleClientKey || !googleClientSecret) throw sendNotFound(scope);
+	return {
+		issuer: "google",
+		scope: "email profile",
+		clientKey: googleClientKey,
+		clientSecret: googleClientSecret,
+		authorize: { url: "https://accounts.google.com/o/oauth2/v2/auth" },
+		token: { url: "https://oauth2.googleapis.com/token" },
+		userInfo: { url: "https://www.googleapis.com/oauth2/v3/userinfo" }
+	};
+} });
+//#endregion
+export { get_default as default };

package/dist/routes/auth/provider/microsoft/get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@revojs/server").Route;
+export default _default;

package/dist/routes/auth/provider/microsoft/get.js

@@ -0,0 +1,19 @@
+import { defineAuthProvider } from "../../../../index.js";
+import { sendNotFound } from "@revojs/server";
+import { useVariables } from "revojs";
+//#region src/routes/auth/provider/microsoft/get.ts
+var get_default = defineAuthProvider({ setup(scope) {
+	const { microsoftClientKey, microsoftClientSecret, microsoftTenant } = useVariables(scope);
+	if (!microsoftClientKey || !microsoftClientSecret) throw sendNotFound(scope);
+	return {
+		issuer: "microsoft",
+		scope: "openid email profile",
+		clientKey: microsoftClientKey,
+		clientSecret: microsoftClientSecret,
+		authorize: { url: `https://login.microsoftonline.com/${microsoftTenant ?? "common"}/oauth2/v2.0/authorize` },
+		token: { url: `https://login.microsoftonline.com/${microsoftTenant ?? "common"}/oauth2/v2.0/token` },
+		userInfo: { url: "https://graph.microsoft.com/oidc/userinfo" }
+	};
+} });
+//#endregion
+export { get_default as default };

package/dist/routes/auth/sessions/delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(scope: import("revojs").Scope): Promise<Response>;
+};
+export default _default;

package/dist/routes/auth/sessions/delete.js

@@ -0,0 +1,12 @@
+import { DELETE_SESSION_HOOK, clearSession, getSession } from "../../../index.js";
+import { defineRoute, sendOk } from "@revojs/server";
+import { dispatchHook } from "revojs";
+//#region src/routes/auth/sessions/delete.ts
+var delete_default = defineRoute({ async fetch(scope) {
+	const session = await getSession(scope);
+	if (session) await dispatchHook(scope, DELETE_SESSION_HOOK, session);
+	clearSession(scope);
+	return sendOk(scope);
+} });
+//#endregion
+export { delete_default as default };

package/dist/routes/auth/sessions/get.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(scope: import("revojs").Scope): Promise<Response>;
+};
+export default _default;

package/dist/routes/auth/sessions/get.js

@@ -0,0 +1,10 @@
+import { getSession } from "../../../index.js";
+import { defineRoute, sendOk, sendUnauthorized } from "@revojs/server";
+//#region src/routes/auth/sessions/get.ts
+var get_default = defineRoute({ async fetch(scope) {
+	const session = await getSession(scope);
+	if (session) return sendOk(scope, session);
+	return sendUnauthorized(scope);
+} });
+//#endregion
+export { get_default as default };

package/dist/routes/auth/sessions/post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(scope: import("revojs").Scope): Promise<Response>;
+};
+export default _default;

package/dist/routes/auth/sessions/post.js

@@ -0,0 +1,19 @@
+import { CREATE_PRINCIPAL_HOOK, CREATE_SESSION_HOOK, GET_PRINCIPAL_HOOK, passkeyMethodSchema, passwordMethodSchema, setSession } from "../../../index.js";
+import { defineRoute, sendNotFound, sendOk, useBody } from "@revojs/server";
+import { dispatchHookSingle } from "revojs";
+import { union } from "valibot";
+//#region src/routes/auth/sessions/post.ts
+var post_default = defineRoute({ async fetch(scope) {
+	const method = await useBody(scope, union([passwordMethodSchema, passkeyMethodSchema]));
+	const principal = await dispatchHookSingle(scope, GET_PRINCIPAL_HOOK, method) ?? (method.type !== "PASSWORD" || method.register ? await dispatchHookSingle(scope, CREATE_PRINCIPAL_HOOK, method) : void 0);
+	if (principal) {
+		const session = await dispatchHookSingle(scope, CREATE_SESSION_HOOK, principal);
+		if (session) {
+			await setSession(scope, session);
+			return sendOk(scope);
+		}
+	}
+	return sendNotFound(scope);
+} });
+//#endregion
+export { post_default as default };

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+declare module "#variables" {
+    export const sessionSecret: string;
+
+    export const appleClientKey: string | undefined;
+    export const appleClientSecret: string | undefined;
+
+    export const githubClientKey: string | undefined;
+    export const githubClientSecret: string | undefined;
+
+    export const googleClientKey: string | undefined;
+    export const googleClientSecret: string | undefined;
+
+    export const microsoftClientKey: string | undefined;
+    export const microsoftClientSecret: string | undefined;
+    export const microsoftTenant: string | undefined;
+}
+
+declare module "#config/auth" {
+    import type { AuthConfig } from "@revojs/auth/module";
+
+    const config: AuthConfig;
+    export default config;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@revojs/auth",
+    "version": "0.1.58",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tellua/revojs.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./module": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js"
+        }
+    },
+    "scripts": {
+        "build": "vite build",
+        "watch": "vite build --watch"
+    },
+    "dependencies": {
+        "@revojs/server": "*",
+        "revojs": "*",
+        "valibot": "^1.5.0"
+    },
+    "devDependencies": {
+        "@revojs/tsconfig": "*"
+    }
+}