@korajs/auth 1.0.0-beta.12 → 1.0.0-beta.13

package/src/bindings/create-auth-session.ts

@@ -0,0 +1,184 @@
+import type {
+	AuthClient,
+	AuthState,
+	AuthUser,
+	LinkedOAuthAccount,
+	OAuthAuthorizationOptions,
+	OAuthAuthorizationResult,
+	OAuthCallbackParams,
+} from '../client/auth-client'
+
+export interface AuthSessionSnapshot {
+	state: AuthState
+	user: AuthUser | null
+	isAuthenticated: boolean
+	isLoading: boolean
+	initError: Error | null
+	error: string | null
+}
+
+export interface AuthSession {
+	readonly client: AuthClient
+	getSnapshot(): AuthSessionSnapshot
+	subscribe(listener: () => void): () => void
+	signUp(params: {
+		email: string
+		password: string
+		name?: string
+		deviceId?: string
+		devicePublicKey?: string
+	}): Promise<void>
+	signIn(params: {
+		email: string
+		password: string
+		deviceId?: string
+		devicePublicKey?: string
+	}): Promise<void>
+	signInWithOAuth(
+		provider: string,
+		options?: OAuthAuthorizationOptions,
+	): Promise<OAuthAuthorizationResult>
+	completeOAuthSignIn(provider: string, params: OAuthCallbackParams): Promise<void>
+	getOAuthAuthorizationUrl(
+		provider: string,
+		options?: OAuthAuthorizationOptions,
+	): Promise<OAuthAuthorizationResult>
+	linkOAuth(provider: string, params: OAuthCallbackParams): Promise<LinkedOAuthAccount | null>
+	listLinkedAccounts(): Promise<LinkedOAuthAccount[]>
+	unlinkOAuth(provider: string): Promise<void>
+	signOut(): Promise<void>
+	destroy(): void
+}
+
+/**
+ * Framework-agnostic auth session: initialization, reactive snapshot, and client methods.
+ */
+export function createAuthSession(client: AuthClient): AuthSession {
+	let state: AuthState = client.state
+	let isLoading = true
+	let initError: Error | null = null
+	let lastError: string | null = null
+
+	const listeners = new Set<() => void>()
+	let snapshot = buildSnapshot()
+
+	const refreshSnapshot = (): void => {
+		snapshot = buildSnapshot()
+	}
+
+	const notify = (): void => {
+		refreshSnapshot()
+		for (const listener of listeners) {
+			listener()
+		}
+	}
+
+	function buildSnapshot(): AuthSessionSnapshot {
+		return {
+			state,
+			user: client.currentUser,
+			isAuthenticated: state === 'authenticated',
+			isLoading,
+			initError,
+			error: lastError,
+		}
+	}
+
+	const captureError = (error: unknown): void => {
+		lastError = error instanceof Error ? error.message : String(error)
+		notify()
+	}
+
+	const run = async (action: () => Promise<void>): Promise<void> => {
+		lastError = null
+		try {
+			await action()
+		} catch (error) {
+			captureError(error)
+		}
+	}
+
+	const runWithResult = async <T>(action: () => Promise<T>): Promise<T | null> => {
+		lastError = null
+		try {
+			return await action()
+		} catch (error) {
+			captureError(error)
+			return null
+		}
+	}
+
+	const unsubscribeAuth = client.onAuthChange((nextState) => {
+		state = nextState
+		notify()
+	})
+
+	void client
+		.initialize()
+		.then(() => {
+			state = client.state
+			isLoading = false
+			notify()
+		})
+		.catch((error: unknown) => {
+			initError = error instanceof Error ? error : new Error(String(error))
+			isLoading = false
+			notify()
+		})
+
+	return {
+		client,
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener)
+			return () => {
+				listeners.delete(listener)
+			}
+		},
+		signUp: (params) =>
+			run(async () => {
+				await client.signUp(params)
+			}),
+		signIn: (params) =>
+			run(async () => {
+				await client.signIn(params)
+			}),
+		signInWithOAuth: async (provider, options) => {
+			lastError = null
+			try {
+				return await client.signInWithOAuth(provider, options)
+			} catch (error) {
+				captureError(error)
+				throw error instanceof Error ? error : new Error(String(error))
+			}
+		},
+		completeOAuthSignIn: (provider, params) =>
+			run(async () => {
+				await client.completeOAuthSignIn(provider, params)
+			}),
+		getOAuthAuthorizationUrl: async (provider, options) => {
+			lastError = null
+			try {
+				return await client.getOAuthAuthorizationUrl(provider, options)
+			} catch (error) {
+				captureError(error)
+				throw error instanceof Error ? error : new Error(String(error))
+			}
+		},
+		linkOAuth: (provider, params) => runWithResult(async () => client.linkOAuth(provider, params)),
+		listLinkedAccounts: () =>
+			runWithResult(async () => client.listLinkedAccounts()).then((value) => value ?? []),
+		unlinkOAuth: (provider) =>
+			run(async () => {
+				await client.unlinkOAuth(provider)
+			}),
+		signOut: () =>
+			run(async () => {
+				await client.signOut()
+			}),
+		destroy() {
+			unsubscribeAuth()
+			listeners.clear()
+		},
+	}
+}

package/src/bindings/create-org-session.ts

@@ -0,0 +1,130 @@
+import type {
+	ClientInvitation,
+	ClientMembership,
+	ClientOrganization,
+	OrgClient,
+} from '../client/org-client'
+
+export interface OrgSnapshot {
+	orgId: string | null
+	org: ClientOrganization | null
+	role: string | null
+}
+
+export interface OrgSession {
+	readonly client: OrgClient
+	getSnapshot(): OrgSnapshot
+	subscribe(listener: () => void): () => void
+	checkPermission(requiredRole: string): boolean
+	destroy(): void
+}
+
+const ROLE_LEVELS: Record<string, number> = {
+	viewer: 10,
+	billing: 15,
+	member: 20,
+	admin: 30,
+	owner: 40,
+}
+
+export function checkOrgPermission(currentRole: string | null, requiredRole: string): boolean {
+	if (!currentRole) return false
+	const currentLevel = ROLE_LEVELS[currentRole] ?? 0
+	const requiredLevel = ROLE_LEVELS[requiredRole] ?? 0
+	return currentLevel >= requiredLevel
+}
+
+/**
+ * Framework-agnostic org session with reactive snapshot subscription.
+ */
+export function createOrgSession(client: OrgClient): OrgSession {
+	let snapshot = buildSnapshot(client)
+	const listeners = new Set<() => void>()
+
+	const notify = (): void => {
+		snapshot = buildSnapshot(client)
+		for (const listener of listeners) {
+			listener()
+		}
+	}
+
+	const unsubscribeOrgChange = client.onOrgChange(notify)
+
+	return {
+		client,
+		getSnapshot: () => snapshot,
+		subscribe(listener: () => void): () => void {
+			listeners.add(listener)
+			return () => {
+				listeners.delete(listener)
+			}
+		},
+		checkPermission(requiredRole: string): boolean {
+			return checkOrgPermission(snapshot.role, requiredRole)
+		},
+		destroy(): void {
+			unsubscribeOrgChange()
+			listeners.clear()
+		},
+	}
+}
+
+function buildSnapshot(client: OrgClient): OrgSnapshot {
+	return {
+		orgId: client.activeOrgId,
+		org: client.activeOrg,
+		role: client.activeRole,
+	}
+}
+
+export interface UseOrgMembersActions {
+	refresh: () => Promise<void>
+	invite: (email: string, role: string) => Promise<ClientInvitation>
+	removeMember: (userId: string) => Promise<void>
+	updateRole: (userId: string, role: string) => Promise<void>
+}
+
+/**
+ * Shared org member management actions (loading state remains framework-specific).
+ */
+export function createOrgMembersActions(
+	client: OrgClient,
+	orgId: string,
+	onError: (message: string) => void,
+): UseOrgMembersActions {
+	return {
+		async refresh(): Promise<void> {
+			await client.listMembers(orgId)
+		},
+		async invite(email: string, role: string): Promise<ClientInvitation> {
+			try {
+				return await client.inviteMember(orgId, { email, role })
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				onError(message)
+				throw error
+			}
+		},
+		async removeMember(userId: string): Promise<void> {
+			try {
+				await client.removeMember(orgId, userId)
+			} catch (error) {
+				onError(error instanceof Error ? error.message : String(error))
+			}
+		},
+		async updateRole(userId: string, role: string): Promise<void> {
+			try {
+				await client.updateMemberRole(orgId, userId, role)
+			} catch (error) {
+				onError(error instanceof Error ? error.message : String(error))
+			}
+		},
+	}
+}
+
+export async function loadOrgMembers(
+	client: OrgClient,
+	orgId: string,
+): Promise<ClientMembership[]> {
+	return client.listMembers(orgId)
+}