@meeovi/auth 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,56 @@
+
+---
+
+# 📦 `@meeovi/auth` — README.md
+
+```md
+# @meeovi/auth
+
+A unified authentication abstraction for Meeovi.  
+Supports Better Auth, Auth.js, Lucia, Ory, and custom auth backends.
+
+## ✨ Features
+
+- Unified `useAuth()` composable  
+- Pluggable auth providers  
+- Runtime configuration  
+- Session helpers  
+
+## 📦 Installation
+
+```sh
+npm install @meeovi/auth
+
+⚙️ Configuration
+
+import { setAuthConfig } from '@meeovi/auth'
+
+setAuthConfig({
+  authProvider: 'better-auth',
+  authUrl: '/api/auth'
+})
+🧩 Usage
+
+import { useAuth } from '@meeovi/auth'
+
+const { login, logout, session } = useAuth()
+
+await login({ email, password })
+🔌 Providers
+
+export interface AuthProvider {
+  login(credentials: any): Promise<any>
+  logout(): Promise<void>
+  session(): Promise<any>
+}
+Register:
+
+
+registerAuthProvider('better-auth', { login, logout, session })
+🧱 Folder Structure
+Code
+src/
+  providers/
+  config.
+  registry.
+  useAuth.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/auth",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Authentication for M Framework.",
   "license": "ISC",
   "author": "",
@@ -15,10 +15,13 @@
     "@better-auth/passkey": "^1.4.10",
     "@better-auth/scim": "^1.4.15",
     "@better-auth/sso": "^1.4.12",
+    "@better-auth/stripe": "^1.4.15",
     "@polar-sh/better-auth": "^1.6.3",
     "better-auth": "^1.4.12",
     "mjml": "^4.18.0",
     "uncrypto": "^0.1.3",
-    "uuid": "^13.0.0"
+    "uuid": "^13.0.0",
+    "vue": "^3.5.27",
+    "vue-router": "^4.6.4"
   }
 }

package/src/config.ts

@@ -1,5 +1,6 @@
 
 export interface AuthConfig {
+  baseUrl: any
   authProvider: string
   authUrl?: string
   sessionCookieName?: string
@@ -8,7 +9,8 @@ export interface AuthConfig {
 let config: AuthConfig = {
   authProvider: 'better-auth',
   authUrl: '',
-  sessionCookieName: 'meeovi_session'
+  sessionCookieName: 'session',
+  baseUrl: undefined
 }
 
 export function setAuthConfig(newConfig: Partial<AuthConfig>) {

package/src/framework.ts

@@ -0,0 +1,24 @@
+
+export interface FrameworkContext {
+  getRequestURL?(): string
+  getRequestHeaders?(): Record<string, string>
+  getConfig?(): any
+  reloadApp?(): void
+  state?<T>(key: string, init: () => T): { value: T }
+}
+
+let ctx: FrameworkContext = {}
+
+/**
+ * Frameworks (Nuxt, React, etc.) call this once during initialization.
+ */
+export function setFrameworkContext(newCtx: FrameworkContext) {
+  ctx = { ...ctx, ...newCtx }
+}
+
+/**
+ * Auth providers use this to access framework-specific helpers.
+ */
+export function getFrameworkContext(): FrameworkContext {
+  return ctx
+}

package/src/plugins.ts

@@ -0,0 +1,25 @@
+import { stripeClient } from '@better-auth/stripe/client'
+import { polarClient } from '@polar-sh/better-auth'
+import { adminClient, inferAdditionalFields } from 'better-auth/client/plugins'
+
+export type AuthPluginOptions = {
+  /** whether to enable subscription support for stripe plugin */
+  subscription?: boolean
+}
+
+export function getAuthPlugins(opts: AuthPluginOptions = {}) {
+  const { subscription = true } = opts
+
+  return [
+    inferAdditionalFields({
+      user: {
+        polarCustomerId: {
+          type: 'string'
+        }
+      }
+    }),
+    adminClient(),
+    polarClient(),
+    stripeClient({ subscription })
+  ]
+}

package/src/providers/better-auth.ts

@@ -0,0 +1,107 @@
+import * as BetterAuth from 'better-auth'
+import { registerAuthProvider } from '../registry'
+import type { AuthProvider } from '../types'
+import { getAuthConfig } from '../config'
+import { getFrameworkContext } from '../framework'
+
+// Create a single shared Better Auth client instance
+let client: any = null
+
+function resolveClientFactory() {
+  return (BetterAuth as any).Client ?? (BetterAuth as any).default ?? BetterAuth
+}
+
+function getClient() {
+  if (client) return client
+
+  const config = getAuthConfig()
+  const ctx = getFrameworkContext()
+
+  const Client = resolveClientFactory()
+  client = Client({
+    baseURL: config.baseUrl,
+    fetch: async (url: string | Request | URL, options: RequestInit = {}) => {
+      // Framework‑agnostic request wrapper
+      const baseHeaders = ctx.getRequestHeaders?.() || {}
+
+      let optionHeaders: Record<string, string> = {}
+
+      if (options.headers instanceof Headers) {
+        options.headers.forEach((value, key) => {
+          optionHeaders[key] = value
+        })
+      } else if (Array.isArray(options.headers)) {
+        for (const [k, v] of options.headers) {
+          optionHeaders[k] = v
+        }
+      } else if (typeof options.headers === 'object' && options.headers !== null) {
+        optionHeaders = options.headers as Record<string, string>
+      }
+
+      const headers = {
+        ...baseHeaders,
+        ...optionHeaders
+      }
+
+      return fetch(url, { ...options, headers })
+    }
+  })
+
+  return client
+}
+
+const BetterAuthProvider: AuthProvider = {
+  async login(credentials) {
+    const client = getClient()
+    const result = await client.signIn(credentials)
+
+    if (result.error) {
+      throw new Error(result.error.message || 'Login failed')
+    }
+
+    return result.data
+  },
+
+  async logout() {
+    const client = getClient()
+    await client.signOut()
+
+    const ctx = getFrameworkContext()
+    ctx.reloadApp?.()
+  },
+
+  async session() {
+    const client = getClient()
+    const result = await client.session()
+
+    if (result.error) {
+      return null
+    }
+
+    return result.data
+  },
+
+  async register(data) {
+    const client = getClient()
+    const result = await client.signUp(data)
+
+    if (result.error) {
+      throw new Error(result.error.message || 'Registration failed')
+    }
+
+    return result.data
+  },
+
+  async refresh() {
+    const client = getClient()
+    const result = await client.refresh()
+
+    if (result.error) {
+      throw new Error(result.error.message || 'Session refresh failed')
+    }
+
+    return result.data
+  }
+}
+
+registerAuthProvider('better-auth', BetterAuthProvider)

package/src/registry.ts

@@ -0,0 +1,22 @@
+import type { AuthProvider } from './types'
+
+const providers: Record<string, AuthProvider> = {}
+let activeProvider: string | null = null
+
+export function registerAuthProvider(name: string, provider: AuthProvider) {
+  providers[name] = provider
+}
+
+export function setActiveAuthProvider(name: string) {
+  if (!providers[name]) {
+    throw new Error(`Auth provider "${name}" is not registered`)
+  }
+  activeProvider = name
+}
+
+export function getAuthProvider(): AuthProvider {
+  if (!activeProvider) {
+    throw new Error('No active auth provider has been set')
+  }
+  return providers[activeProvider]
+}

package/src/types.ts

@@ -0,0 +1,33 @@
+
+export interface AuthSession {
+  user: {
+    id: string
+    email?: string
+    name?: string
+    avatarUrl?: string
+    [key: string]: any
+  }
+  expiresAt?: string
+  [key: string]: any
+}
+
+export interface AuthCredentials {
+  email: string
+  password: string
+  [key: string]: any
+}
+
+export interface AuthRegistration {
+  email: string
+  password: string
+  name?: string
+  [key: string]: any
+}
+
+export interface AuthProvider {
+  login(credentials: AuthCredentials): Promise<AuthSession>
+  logout(): Promise<void>
+  session(): Promise<AuthSession | null>
+  register?(data: AuthRegistration): Promise<AuthSession>
+  refresh?(): Promise<AuthSession>
+}

package/src/useAuth.ts

@@ -1,18 +1,112 @@
+import type { Subscription } from '@better-auth/stripe'
+import type { CustomerState } from '@polar-sh/sdk/models/components/customerstate.js'
+import type {
+  BetterAuthClientOptions,
+  InferSessionFromClient,
+  User
+} from 'better-auth/client'
 import { createAuthClient } from 'better-auth/client'
-import { useRuntimeConfig } from '#imports'
+import { getAuthPlugins } from './plugins'
 
-let client: any = null
+export type UseAuthOptions = {
+  /** An existing auth client. If provided, it's used as-is. */
+  client?: any
+  /** Base URL for the auth client if creating one. */
+  baseURL?: string
+  /** Optional headers to send with requests. */
+  headers?: Record<string, string>
+  /** Payment provider: 'stripe' or 'polar'. If omitted, 'stripe' is assumed. */
+  payment?: 'stripe' | 'polar'
+  /** Optional app-level reload/redirect function (framework-specific). */
+  reload?: (opts: { path?: string }) => Promise<void>
+}
+
+export function useAuth(options: UseAuthOptions = {}) {
+  const { client: providedClient, baseURL, headers, payment = 'stripe', reload } = options
+
+  const client = providedClient || createAuthClient({
+    baseURL: baseURL || undefined,
+    fetchOptions: {
+      headers
+    },
+    plugins: getAuthPlugins({ subscription: true })
+  })
+
+  let session: InferSessionFromClient<BetterAuthClientOptions> | null = null
+  let user: User | null = null
+  let subscriptions: Subscription[] = []
+  let polarState: CustomerState | null = null
+  let sessionFetching = false
+
+  const fetchSession = async () => {
+    if (sessionFetching) return
+    sessionFetching = true
+    const { data } = await client.getSession()
+    session = data?.session || null
+
+    const userDefaults = {
+      image: null,
+      role: null,
+      banReason: null,
+      banned: null,
+      banExpires: null,
+      stripeCustomerId: null
+    }
+    user = data?.user ? Object.assign({}, userDefaults, data.user) : null
+    subscriptions = []
+    if (user) {
+      if (payment == 'stripe') {
+        const { data: subscriptionData } = await client.subscription.list()
+        subscriptions = subscriptionData || []
+      } else if (payment == 'polar') {
+        const { data: customerState } = await client.customer.state()
+        polarState = customerState
+      }
+    }
+    sessionFetching = false
+    return data
+  }
 
-export function useAuth() {
-  if (!client) {
-    const config = useRuntimeConfig()
-    client = createAuthClient({ baseURL: config.public.authUrl })
+  if (client?.$store?.listen) {
+    client.$store.listen('$sessionSignal', async (signal: any) => {
+      if (!signal) return
+      await fetchSession()
+    })
   }
 
   return {
-    login: client.login,
-    logout: client.logout,
-    register: client.register,
-    session: client.session
+    session,
+    user,
+    subscription: client.subscription,
+    subscriptions,
+    loggedIn: () => !!session,
+    activeStripeSubscription: () => {
+      return subscriptions.find((sub: { status: string }) => sub.status === 'active' || sub.status === 'trialing')
+    },
+    activePolarSubscriptions: () => {
+      return polarState?.activeSubscriptions
+    },
+    signIn: client.signIn,
+    signUp: client.signUp,
+    forgetPassword: client.forgetPassword,
+    resetPassword: client.resetPassword,
+    sendVerificationEmail: client.sendVerificationEmail,
+    errorCodes: client.$ERROR_CODES,
+    async signOut({ redirectTo }: { redirectTo?: string } = {}) {
+      await client.signOut({
+        fetchOptions: {
+          onSuccess: async () => {
+            session = null
+            user = null
+            if (redirectTo && typeof reload === 'function') {
+              await reload({ path: redirectTo.toString() })
+            }
+          }
+        }
+      })
+    },
+    fetchSession,
+    payment,
+    client
   }
 }