@libreapps/auth 3.0.1

package/service/impl/stub-auth-service.ts

@@ -0,0 +1,131 @@
+/**
+ * Stub Authentication Service
+ *
+ * This implementation is used when no auth provider is configured.
+ * All auth operations return unsuccessful results gracefully.
+ */
+
+import { makeAutoObservable, makeObservable, computed } from 'mobx'
+
+import type AuthService from '../auth-service'
+import type { AuthServiceConf, LibreAppsUserInfo, LibreAppsUserInfoValue } from '../../types'
+
+class LibreAppsUserInfoStore implements LibreAppsUserInfo {
+
+  constructor() {
+    makeAutoObservable(this)
+  }
+
+  _email: string = ''
+  _displayName: string | null = null
+  _walletAddress: string | null = null
+
+  get email(): string { return this._email}
+  get displayName(): string | null { return this._displayName}
+  get walletAddress(): string | null { return this._walletAddress}
+
+  clear():void  {
+    this._email = ''
+    this._displayName = null
+    this._walletAddress = null
+  }
+
+  set(v: LibreAppsUserInfoValue):void {
+    this._email = v.email
+    this._displayName = v.displayName
+    this._walletAddress = v.walletAddress
+  }
+
+  get isValid(): boolean {
+    return (this._email.length > 0)
+  }
+}
+
+/**
+ * Stub auth service that does nothing but returns graceful failures.
+ * Used when no auth provider is configured.
+ */
+export class StubAuthService implements AuthService {
+
+  private _hzUser = new LibreAppsUserInfoStore()
+
+  constructor(conf: AuthServiceConf, user: LibreAppsUserInfoValue | null) {
+    makeObservable(this, {
+      loggedIn: computed,
+      user: computed
+    })
+
+    if (user) {
+      this._hzUser.set(user)
+    }
+  }
+
+  get user(): LibreAppsUserInfo | null {
+    return this._hzUser.isValid ? this._hzUser : null
+  }
+
+  get loggedIn(): boolean {
+    return this._hzUser.isValid
+  }
+
+  signupEmailAndPassword = async (
+    _email: string,
+    _password: string
+  ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}> => {
+    console.warn('Auth provider not configured. Install @libreapps/auth-firebase or another auth provider.')
+    return {
+      success: false,
+      userInfo: null,
+      message: 'Auth provider not configured'
+    }
+  }
+
+  loginEmailAndPassword = async (
+    _email: string,
+    _password: string
+  ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null, message?: string}> => {
+    console.warn('Auth provider not configured. Install @libreapps/auth-firebase or another auth provider.')
+    return {
+      success: false,
+      userInfo: null,
+      message: 'Auth provider not configured'
+    }
+  }
+
+  loginWithProvider = async (
+    _provider: 'google' | 'facebook' | 'github'
+  ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}> => {
+    console.warn('Auth provider not configured. Install @libreapps/auth-firebase or another auth provider.')
+    return {
+      success: false,
+      userInfo: null
+    }
+  }
+
+  loginWithCustomToken = async (
+    _token: string
+  ):  Promise<{success: boolean, userInfo: LibreAppsUserInfo | null}> => {
+    console.warn('Auth provider not configured. Install @libreapps/auth-firebase or another auth provider.')
+    return {
+      success: false,
+      userInfo: null
+    }
+  }
+
+  associateWallet = async (): Promise<void> => {
+    console.warn('Auth provider not configured. Install @libreapps/auth-firebase or another auth provider.')
+  }
+
+  logout = async (): Promise<{ success: boolean }> => {
+    this._hzUser.clear()
+    return { success: true }
+  }
+
+  setServerSideUser = (user: LibreAppsUserInfoValue | null) => {
+    if (user) {
+      this._hzUser.set(user)
+    }
+  }
+}
+
+export default StubAuthService

package/service/impl/wallet-support.ts

@@ -0,0 +1,100 @@
+
+import { collection, doc, getDoc, setDoc } from 'firebase/firestore'
+
+import { auth, db } from './firebase-support'
+
+const isObject = (obj: any): obj is Record<any, any> => typeof obj === 'object' && obj !== null
+const isGlobalThisEthereum = (obj: any): obj is { ethereum: { request: <R = any>(payload: Record<any, any>) => Promise<R> } } => isObject(obj) && isObject(obj.ethereum) && typeof obj.ethereum.request === 'function'
+const getEthereum = (obj: any) => isGlobalThisEthereum(obj) ? obj.ethereum : null
+
+const ethereum = getEthereum(globalThis)
+
+let signMessage = (opts: { siteName: string, address: string }) => `${opts.siteName} wants you to sign in with your Ethereum account:\n${opts.address}`
+
+const USER_INFO_COLLECTION = 'HZ_USER_INFO'
+
+async function connectWalletAddress(siteName?: string) {
+  if (!ethereum) {
+    throw new Error('No ethereum provider found')
+  }
+
+  if (!auth) {
+    throw new Error('Firebase auth not configured')
+  }
+
+  const [account] = await ethereum.request<string[]>({ method: 'eth_requestAccounts' })
+
+  if (!account) {
+    throw new Error('No account found')
+  }
+
+  const signed = await ethereum.request<string>({
+    method: 'personal_sign',
+    params: [
+      signMessage({
+        siteName: siteName ?? auth.app.options.projectId ?? globalThis.location.hostname,
+        address: account,
+      }),
+      account,
+      auth.app.options.appId,
+    ],
+  })
+
+  if (!signed) {
+    throw new Error('Not signed')
+  }
+
+  return {account, signed}
+}
+  
+export async function associateWalletAddressWithAccount(userEmail: string, siteName?: string) {
+  const {account} = await connectWalletAddress(siteName)
+
+  if (!db) {
+    return { result: null, error: new Error('Firebase Firestore not configured') }
+  }
+
+  let result = null
+  let error = null
+  const accountsRef = collection(db, USER_INFO_COLLECTION) 
+
+  try {  
+    try {
+      await setDoc(doc(accountsRef, userEmail), { walletAddress: account })
+      result = account
+    } catch (e) {  
+      console.error(e)
+      error = e  
+    }  
+  } catch (e) {  
+    console.error(e)
+    error = e  
+  }  
+
+  return { result, error }  
+}
+
+export async function getAssociatedWalletAddress(userEmail: string) : Promise<{error: any, result?: string}> {
+  if (!db) {
+    return { error: new Error('Firebase Firestore not configured'), result: undefined }
+  }
+
+  let result = undefined
+  let error = null
+  try {
+    try {
+      const docRef = await getDoc(doc(db, USER_INFO_COLLECTION, userEmail))
+      result = docRef.data() ? docRef.data()!.walletAddress as string : undefined
+    } 
+    catch (e) {  
+      console.error(e)
+      error = e  
+    }  
+  } 
+  catch (e) {  
+    console.error(e)
+    error = e  
+  }  
+
+  return { result, error }  
+}

package/service/index.ts

@@ -0,0 +1,11 @@
+export type { default as AuthService, AuthProvider } from './auth-service'
+export { useAuth, AuthServiceProvider } from './context'
+export {
+  registerAuthProvider,
+  setActiveProvider,
+  getActiveProvider,
+  hasAuthProvider,
+  getRegisteredProviders,
+  type AuthServiceFactory
+} from './provider-registry'
+export { StubAuthService } from './impl/stub-auth-service'

package/service/provider-registry.ts

@@ -0,0 +1,71 @@
+/**
+ * Auth Provider Registry
+ *
+ * Allows registration of pluggable auth providers.
+ * Firebase support is available via @libreapps/auth-firebase (optional).
+ */
+
+import type AuthService from './auth-service'
+import type { AuthServiceConf, LibreAppsUserInfoValue } from '../types'
+
+export type AuthServiceFactory = new (
+  conf: AuthServiceConf,
+  user: LibreAppsUserInfoValue | null
+) => AuthService
+
+// Registry of available auth providers
+const providers = new Map<string, AuthServiceFactory>()
+
+// Current active provider
+let activeProvider: string | null = null
+
+/**
+ * Register an auth provider
+ *
+ * @example
+ * ```ts
+ * import { FirebaseAuthService } from '@libreapps/auth-firebase'
+ * import { registerAuthProvider } from '@libreapps/auth'
+ *
+ * registerAuthProvider('firebase', FirebaseAuthService)
+ * ```
+ */
+export function registerAuthProvider(name: string, factory: AuthServiceFactory): void {
+  providers.set(name, factory)
+  // Auto-activate if this is the first provider
+  if (!activeProvider) {
+    activeProvider = name
+  }
+}
+
+/**
+ * Set the active auth provider by name
+ */
+export function setActiveProvider(name: string): void {
+  if (!providers.has(name)) {
+    throw new Error(`Auth provider '${name}' is not registered`)
+  }
+  activeProvider = name
+}
+
+/**
+ * Get the active auth provider factory
+ */
+export function getActiveProvider(): AuthServiceFactory | null {
+  if (!activeProvider) return null
+  return providers.get(activeProvider) ?? null
+}
+
+/**
+ * Check if any auth provider is registered
+ */
+export function hasAuthProvider(): boolean {
+  return providers.size > 0
+}
+
+/**
+ * Get list of registered provider names
+ */
+export function getRegisteredProviders(): string[] {
+  return Array.from(providers.keys())
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.libreapps.base.json",
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true
+  }
+}

package/types/api-response.ts

@@ -0,0 +1,5 @@
+type APIResponse<T = object> = { success: true; data: T } | { success: false; error: string };
+
+export {
+  type APIResponse as default
+}

package/types/auth-service-conf.ts

@@ -0,0 +1,9 @@
+
+interface AuthServiceConf {
+  firestoreDB: string
+  userInfoCollection: string 
+}
+
+export {
+  type AuthServiceConf as default
+}

package/types/index.ts

@@ -0,0 +1,6 @@
+export type { default as LibreAppsUserInfo } from './libreapps-user-info'
+export type { default as APIResponse } from './api-response'
+export type { default as AuthServiceConf } from './auth-service-conf'
+export type { default as LibreAppsUserInfoValue } from './libreapps-user-info-value'
+
+

package/types/libreapps-user-info-value.ts

@@ -0,0 +1,9 @@
+type LibreAppsUserInfoValue = {
+  email: string
+  displayName: string | null     
+  walletAddress: string | null    
+}
+
+export {
+  type LibreAppsUserInfoValue as default
+}

package/types/libreapps-user-info.ts

@@ -0,0 +1,9 @@
+interface LibreAppsUserInfo {
+  get email(): string
+  get displayName(): string | null     
+  get walletAddress(): string | null   
+}
+
+export {
+  type LibreAppsUserInfo as default
+}

package/util/analytics.ts

@@ -0,0 +1,21 @@
+declare global {
+  interface Window {
+    fbq: Function;
+    gtag: Function;
+  }
+}
+
+// https://developers.facebook.com/docs/meta-pixel/reference
+const sendFBEvent = (name: string, options = {}) => {
+  window.fbq('track', name, options)
+}
+
+// https://developers.google.com/analytics/devguides/collection/ga4/ecommerce?client_type=gtag
+const sendGAEvent = (name: string, options = {}) => {
+  window.gtag('event', name, options)
+}
+
+export {
+  sendFBEvent,
+  sendGAEvent,
+}