@geenius/adapters 0.1.0

package/packages/shared/src/__tests__/adapters.test.ts

@@ -0,0 +1,545 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  // Tier gate
+  isFeatureAvailable, isPackageAvailable,
+  getAvailableFeatures, getAvailablePackages,
+  getUpgradeFeatures, DEFAULT_TIER_GATE,
+  // Config
+  configureAdapters, getAdapterConfig, isAdaptersConfigured, resetAdapterConfig, getDomainConfig,
+  // Constants
+  ADAPTER_DOMAINS, DB_PROVIDERS, AUTH_PROVIDERS, AI_PROVIDERS,
+  STORAGE_PROVIDERS, PAYMENT_PROVIDERS, ADMIN_PROVIDERS,
+  PROVIDER_REGISTRY, getProvidersForDomain, getProviderMeta,
+  DOMAIN_LABELS, DOMAIN_ICONS, DOMAIN_DESCRIPTIONS,
+  // Factories
+  createLocalStorageAuthAdapter,
+  createLocalStorageDbAdapter,
+  createLocalStoragePaymentsAdapter,
+  createNoopPaymentsAdapter,
+  createLocalStorageAiAdapter,
+  createLocalStorageFileAdapter,
+  createLocalStorageAdminAdapter,
+} from '../index'
+
+// ─── localStorage mock ───────────────────────────────────────────────────────
+// Vitest runs in Node (jsdom or node env). We need a minimal localStorage mock.
+
+const localStorageStore: Record<string, string> = {}
+
+const localStorageMock = {
+  getItem: (key: string) => localStorageStore[key] ?? null,
+  setItem: (key: string, value: string) => { localStorageStore[key] = value },
+  removeItem: (key: string) => { delete localStorageStore[key] },
+  clear: () => { Object.keys(localStorageStore).forEach(k => delete localStorageStore[k]) },
+  get length() { return Object.keys(localStorageStore).length },
+  key: (index: number) => Object.keys(localStorageStore)[index] ?? null,
+}
+
+vi.stubGlobal('localStorage', localStorageMock)
+vi.stubGlobal('crypto', {
+  randomUUID: () => `${Math.random().toString(36).slice(2)}-${Date.now()}`,
+})
+
+function clearStorage() {
+  localStorageMock.clear()
+}
+
+// ─── Tier Gate ───────────────────────────────────────────────────────────────
+
+describe('Tier Gate — isFeatureAvailable', () => {
+  it('pronto tier has basic features', () => {
+    expect(isFeatureAvailable('auth', 'pronto')).toBe(true)
+  })
+
+  it('pronto tier lacks premium features', () => {
+    expect(isFeatureAvailable('ai-magic', 'pronto')).toBe(false)
+  })
+
+  it('lancio tier has intermediate features', () => {
+    expect(isFeatureAvailable('admin', 'lancio')).toBe(true)
+    expect(isFeatureAvailable('payments', 'lancio')).toBe(true)
+  })
+
+  it('lancio tier lacks studio-only features', () => {
+    expect(isFeatureAvailable('ai-magic', 'lancio')).toBe(false)
+  })
+
+  it('studio tier has all features', () => {
+    expect(isFeatureAvailable('ai-magic', 'studio')).toBe(true)
+    expect(isFeatureAvailable('analytics', 'studio')).toBe(true)
+    expect(isFeatureAvailable('monitoring', 'studio')).toBe(true)
+  })
+
+  it('returns false for unknown features', () => {
+    expect(isFeatureAvailable('nonexistent-feature', 'studio')).toBe(false)
+  })
+})
+
+describe('Tier Gate — isPackageAvailable', () => {
+  it('returns true for packages in tier', () => {
+    expect(isPackageAvailable('@geenius/auth', 'lancio')).toBe(true)
+    expect(isPackageAvailable('@geenius/auth', 'pronto')).toBe(true)
+    expect(isPackageAvailable('@geenius/auth', 'studio')).toBe(true)
+  })
+
+  it('returns false for unavailable packages', () => {
+    expect(isPackageAvailable('@geenius/admin', 'pronto')).toBe(false)
+    expect(isPackageAvailable('@geenius/ai-magic', 'lancio')).toBe(false)
+  })
+
+  it('studio has all packages', () => {
+    expect(isPackageAvailable('@geenius/agent', 'studio')).toBe(true)
+  })
+})
+
+describe('Tier Gate — getAvailable and getUpgrade', () => {
+  it('getAvailableFeatures returns array', () => {
+    const features = getAvailableFeatures('lancio')
+    expect(Array.isArray(features)).toBe(true)
+    expect(features.length).toBeGreaterThan(0)
+  })
+
+  it('getAvailablePackages returns array', () => {
+    const pkgs = getAvailablePackages('studio')
+    expect(Array.isArray(pkgs)).toBe(true)
+    expect(pkgs.length).toBeGreaterThan(0)
+  })
+
+  it('getUpgradeFeatures shows what pronto is missing vs lancio', () => {
+    const upgrades = getUpgradeFeatures('pronto', 'lancio')
+    expect(Array.isArray(upgrades)).toBe(true)
+    expect(upgrades).toContain('admin')
+    expect(upgrades).toContain('payments')
+    expect(upgrades).not.toContain('auth') // already in pronto
+  })
+
+  it('getUpgradeFeatures shows what lancio is missing vs studio', () => {
+    const upgrades = getUpgradeFeatures('lancio', 'studio')
+    expect(Array.isArray(upgrades)).toBe(true)
+    expect(upgrades).toContain('ai-magic')
+    expect(upgrades).toContain('analytics')
+    expect(upgrades).not.toContain('admin') // already in lancio
+  })
+
+  it('getUpgradeFeatures returns empty when already at same tier', () => {
+    const upgrades = getUpgradeFeatures('studio', 'studio')
+    expect(upgrades).toHaveLength(0)
+  })
+
+  it('DEFAULT_TIER_GATE is defined and has three tiers', () => {
+    expect(DEFAULT_TIER_GATE).toBeDefined()
+    expect(typeof DEFAULT_TIER_GATE).toBe('object')
+    expect(DEFAULT_TIER_GATE.features).toHaveProperty('pronto')
+    expect(DEFAULT_TIER_GATE.features).toHaveProperty('lancio')
+    expect(DEFAULT_TIER_GATE.features).toHaveProperty('studio')
+    expect(DEFAULT_TIER_GATE.packages).toHaveProperty('pronto')
+    expect(DEFAULT_TIER_GATE.packages).toHaveProperty('lancio')
+    expect(DEFAULT_TIER_GATE.packages).toHaveProperty('studio')
+  })
+})
+
+// ─── Configuration ────────────────────────────────────────────────────────────
+
+describe('configureAdapters', () => {
+  beforeEach(() => {
+    resetAdapterConfig()
+  })
+
+  it('isAdaptersConfigured returns false before configure()', () => {
+    expect(isAdaptersConfigured()).toBe(false)
+  })
+
+  it('configureAdapters sets config and isAdaptersConfigured returns true', () => {
+    configureAdapters({ db: { provider: 'convex' } })
+    expect(isAdaptersConfigured()).toBe(true)
+  })
+
+  it('getAdapterConfig returns the config', () => {
+    configureAdapters({ db: { provider: 'convex' }, auth: { provider: 'clerk' } })
+    const cfg = getAdapterConfig()
+    expect(cfg.db?.provider).toBe('convex')
+    expect(cfg.auth?.provider).toBe('clerk')
+  })
+
+  it('getAdapterConfig throws when not configured', () => {
+    expect(() => getAdapterConfig()).toThrow('Adapters not configured')
+  })
+
+  it('getDomainConfig returns specific domain config', () => {
+    configureAdapters({ ai: { provider: 'openai', apiKey: 'sk-test' } })
+    const ai = getDomainConfig('ai')
+    expect(ai?.provider).toBe('openai')
+    expect(ai?.apiKey).toBe('sk-test')
+  })
+
+  it('getDomainConfig returns null for unconfigured domains', () => {
+    configureAdapters({ db: { provider: 'convex' } })
+    expect(getDomainConfig('auth')).toBeNull()
+  })
+
+  it('resetAdapterConfig allows reconfiguring', () => {
+    configureAdapters({ db: { provider: 'convex' } })
+    resetAdapterConfig()
+    expect(isAdaptersConfigured()).toBe(false)
+    configureAdapters({ db: { provider: 'neon' } })
+    expect(getAdapterConfig().db?.provider).toBe('neon')
+  })
+})
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+describe('Constants & Registry', () => {
+  it('ADAPTER_DOMAINS has all 6 domains', () => {
+    expect(ADAPTER_DOMAINS).toHaveLength(6)
+    expect(ADAPTER_DOMAINS).toContain('db')
+    expect(ADAPTER_DOMAINS).toContain('auth')
+    expect(ADAPTER_DOMAINS).toContain('ai')
+    expect(ADAPTER_DOMAINS).toContain('storage')
+    expect(ADAPTER_DOMAINS).toContain('payments')
+    expect(ADAPTER_DOMAINS).toContain('admin')
+  })
+
+  it('provider arrays contain localStorage as first entry', () => {
+    expect(DB_PROVIDERS[0]).toBe('localStorage')
+    expect(AUTH_PROVIDERS[0]).toBe('localStorage')
+    expect(AI_PROVIDERS[0]).toBe('localStorage')
+    expect(STORAGE_PROVIDERS[0]).toBe('localStorage')
+    expect(PAYMENT_PROVIDERS[0]).toBe('localStorage')
+    expect(ADMIN_PROVIDERS[0]).toBe('localStorage')
+  })
+
+  it('DOMAIN_LABELS covers all domains', () => {
+    for (const domain of ADAPTER_DOMAINS) {
+      expect(DOMAIN_LABELS[domain]).toBeTruthy()
+    }
+  })
+
+  it('DOMAIN_ICONS covers all domains', () => {
+    for (const domain of ADAPTER_DOMAINS) {
+      expect(DOMAIN_ICONS[domain]).toBeTruthy()
+    }
+  })
+
+  it('DOMAIN_DESCRIPTIONS covers all domains', () => {
+    for (const domain of ADAPTER_DOMAINS) {
+      expect(DOMAIN_DESCRIPTIONS[domain]).toBeTruthy()
+    }
+  })
+
+  it('PROVIDER_REGISTRY has entries for all domains', () => {
+    for (const domain of ADAPTER_DOMAINS) {
+      const entries = PROVIDER_REGISTRY.filter(p => p.domain === domain)
+      expect(entries.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('PROVIDER_REGISTRY uses correct tier names (pronto | lancio | studio)', () => {
+    const validTiers = new Set(['pronto', 'lancio', 'studio'])
+    for (const entry of PROVIDER_REGISTRY) {
+      expect(validTiers.has(entry.tier)).toBe(true)
+    }
+  })
+
+  it('getProvidersForDomain returns filtered list', () => {
+    const dbProviders = getProvidersForDomain('db')
+    expect(dbProviders.every(p => p.domain === 'db')).toBe(true)
+    expect(dbProviders.length).toBe(5) // localStorage, convex, supabase, neon, mongodb
+  })
+
+  it('getProviderMeta finds by domain + id', () => {
+    const stripe = getProviderMeta('payments', 'stripe')
+    expect(stripe).toBeDefined()
+    expect(stripe?.name).toBe('Stripe')
+    expect(stripe?.tier).toBe('lancio')
+  })
+
+  it('getProviderMeta returns undefined for unknown provider', () => {
+    expect(getProviderMeta('db', 'firebase')).toBeUndefined()
+  })
+})
+
+// ─── localStorage Auth Adapter ────────────────────────────────────────────────
+
+describe('createLocalStorageAuthAdapter', () => {
+  beforeEach(() => clearStorage())
+
+  it('signUp creates a user and returns a session', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    const session = await auth.signUp('test@example.com', 'password123', 'Test User')
+    expect(session.userId).toBeTruthy()
+    expect(session.token).toBeTruthy()
+    expect(session.expiresAt).toBeTruthy()
+  })
+
+  it('signUp throws if email already registered', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('dup@example.com', 'pass')
+    await expect(auth.signUp('dup@example.com', 'pass')).rejects.toThrow('User already exists')
+  })
+
+  it('signIn returns session with correct credentials', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'secret')
+    const session = await auth.signIn('user@example.com', 'secret')
+    expect(session.userId).toBeTruthy()
+  })
+
+  it('signIn throws on wrong password', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'correct')
+    await expect(auth.signIn('user@example.com', 'wrong')).rejects.toThrow('Invalid email or password')
+  })
+
+  it('getSession returns current session', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'pw')
+    const session = await auth.getSession()
+    expect(session).not.toBeNull()
+  })
+
+  it('signOut clears the session', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'pw')
+    await auth.signOut()
+    const session = await auth.getSession()
+    expect(session).toBeNull()
+  })
+
+  it('getUser returns the current user', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'pw', 'Alice')
+    const user = await auth.getUser()
+    expect(user?.email).toBe('user@example.com')
+    expect(user?.name).toBe('Alice')
+    expect((user as any)?.passwordHash).toBeUndefined() // never leak the hash
+  })
+
+  it('getUser returns null when not signed in', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    const user = await auth.getUser()
+    expect(user).toBeNull()
+  })
+
+  it('updateUser mutates name and image', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    await auth.signUp('user@example.com', 'pw', 'Original')
+    const updated = await auth.updateUser({ name: 'Updated', image: 'https://example.com/avatar.png' })
+    expect(updated?.name).toBe('Updated')
+    expect(updated?.image).toBe('https://example.com/avatar.png')
+  })
+
+  it('signInWithOAuth returns a redirect url', async () => {
+    const auth = createLocalStorageAuthAdapter()
+    const result = await auth.signInWithOAuth('google', { redirectUrl: '/dashboard' })
+    expect(result.url).toBe('/dashboard')
+    // Should also have created a session
+    const session = await auth.getSession()
+    expect(session).not.toBeNull()
+  })
+})
+
+// ─── localStorage DB Adapter ─────────────────────────────────────────────────
+
+describe('createLocalStorageDbAdapter', () => {
+  beforeEach(() => clearStorage())
+
+  it('create and get round-trips', async () => {
+    const db = createLocalStorageDbAdapter()
+    const created = await db.create<{ id: string; name: string; value: number }>('items', { name: 'test', value: 42 })
+    expect(created.id).toBeTruthy()
+    expect(created.name).toBe('test')
+    const fetched = await db.get<typeof created>('items', created.id)
+    expect(fetched).toEqual(created)
+  })
+
+  it('get returns null for missing id', async () => {
+    const db = createLocalStorageDbAdapter()
+    const result = await db.get('items', 'nonexistent')
+    expect(result).toBeNull()
+  })
+
+  it('update modifies fields', async () => {
+    const db = createLocalStorageDbAdapter()
+    const item = await db.create<{ id: string; name: string }>('items', { name: 'original' })
+    const updated = await db.update<typeof item>('items', item.id, { name: 'changed' })
+    expect(updated.name).toBe('changed')
+  })
+
+  it('delete removes the item', async () => {
+    const db = createLocalStorageDbAdapter()
+    const item = await db.create<{ id: string; val: string }>('things', { val: 'x' })
+    await db.delete('things', item.id)
+    const result = await db.get('things', item.id)
+    expect(result).toBeNull()
+  })
+
+  it('list returns all items in a table', async () => {
+    const db = createLocalStorageDbAdapter()
+    await db.create('docs', { title: 'A' })
+    await db.create('docs', { title: 'B' })
+    const all = await db.list('docs')
+    expect(all.length).toBe(2)
+  })
+
+  it('query filters by field equality', async () => {
+    const db = createLocalStorageDbAdapter()
+    await db.create('users', { role: 'admin' })
+    await db.create('users', { role: 'user' })
+    await db.create('users', { role: 'admin' })
+    const admins = await db.query('users', [{ field: 'role', operator: 'eq', value: 'admin' }])
+    expect(admins.length).toBe(2)
+  })
+})
+
+// ─── localStorage Payments Adapter ───────────────────────────────────────────
+
+describe('createLocalStoragePaymentsAdapter', () => {
+  beforeEach(() => clearStorage())
+
+  it('getPlans returns default plans', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    const plans = await payments.getPlans()
+    expect(plans.length).toBeGreaterThan(0)
+    expect(plans[0]).toHaveProperty('id')
+    expect(plans[0]).toHaveProperty('price')
+  })
+
+  it('createCheckout creates a subscription', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    const result = await payments.createCheckout({ planId: 'pro', userId: 'user-1', successUrl: '/success' })
+    expect(result.sessionId).toBeTruthy()
+    expect(result.url).toBe('/success')
+  })
+
+  it('getSubscription returns active subscription', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    await payments.createCheckout({ planId: 'pro', userId: 'user-1' })
+    const sub = await payments.getSubscription('user-1')
+    expect(sub).not.toBeNull()
+    expect(sub?.status).toBe('active')
+    expect(sub?.planId).toBe('pro')
+  })
+
+  it('cancelSubscription marks subscription cancelled', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    const { sessionId } = await payments.createCheckout({ planId: 'pro', userId: 'user-2' })
+    await payments.cancelSubscription(sessionId)
+    const sub = await payments.getSubscription('user-2')
+    expect(sub?.status).toBe('cancelled')
+  })
+
+  it('isFeatureEnabled returns false for free plan (no AI features)', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    await payments.createCheckout({ planId: 'free', userId: 'user-3' })
+    const enabled = await payments.isFeatureEnabled('user-3', 'AI features')
+    expect(enabled).toBe(false)
+  })
+
+  it('isFeatureEnabled returns true for pro plan with matching feature', async () => {
+    const payments = createLocalStoragePaymentsAdapter()
+    await payments.createCheckout({ planId: 'pro', userId: 'user-4' })
+    const enabled = await payments.isFeatureEnabled('user-4', 'AI features')
+    expect(enabled).toBe(true)
+  })
+})
+
+describe('createNoopPaymentsAdapter', () => {
+  it('createCheckout throws with Lancio upgrade message', async () => {
+    const noop = createNoopPaymentsAdapter()
+    await expect(noop.createCheckout({ planId: 'pro', userId: 'u1' })).rejects.toThrow('Lancio')
+  })
+
+  it('getSubscription returns null', async () => {
+    const noop = createNoopPaymentsAdapter()
+    expect(await noop.getSubscription('u1')).toBeNull()
+  })
+
+  it('isFeatureEnabled returns false', async () => {
+    const noop = createNoopPaymentsAdapter()
+    expect(await noop.isFeatureEnabled('u1', 'any-feature')).toBe(false)
+  })
+})
+
+// ─── localStorage AI Adapter ─────────────────────────────────────────────────
+
+describe('createLocalStorageAiAdapter', () => {
+  it('chat returns a deterministic response', async () => {
+    const ai = createLocalStorageAiAdapter()
+    const response = await ai.chat([{ role: 'user', content: 'Hello' }])
+    expect(response.content).toBeTruthy()
+    expect(response.finishReason).toBe('stop')
+    expect(response.usage).toBeDefined()
+  })
+
+  it('complete returns a string', async () => {
+    const ai = createLocalStorageAiAdapter()
+    const result = await ai.complete('What is 2+2?')
+    expect(typeof result).toBe('string')
+    expect(result.length).toBeGreaterThan(0)
+  })
+
+  it('embed returns array of embeddings', async () => {
+    const ai = createLocalStorageAiAdapter()
+    const embeddings = await ai.embed(['hello', 'world'])
+    expect(Array.isArray(embeddings)).toBe(true)
+    expect(embeddings.length).toBe(2)
+    expect(Array.isArray(embeddings[0])).toBe(true)
+  })
+})
+
+// ─── localStorage File Adapter ────────────────────────────────────────────────
+
+describe('createLocalStorageFileAdapter', () => {
+  beforeEach(() => clearStorage())
+
+  it('upload returns a StoredFile', async () => {
+    const storage = createLocalStorageFileAdapter()
+    const mockFile = new Blob(['hello'], { type: 'text/plain' })
+    const file = await storage.upload(mockFile as File, 'hello.txt')
+    expect(file.id).toBeTruthy()
+    expect(file.name).toBe('hello.txt')
+  })
+
+  it('list returns uploaded files', async () => {
+    const storage = createLocalStorageFileAdapter()
+    await storage.upload(new Blob(['a']) as File, 'a.txt')
+    await storage.upload(new Blob(['b']) as File, 'b.txt')
+    const files = await storage.list()
+    expect(files.length).toBe(2)
+  })
+
+  it('delete removes a file', async () => {
+    const storage = createLocalStorageFileAdapter()
+    const file = await storage.upload(new Blob(['data']) as File, 'to-delete.txt')
+    await storage.delete(file.id)
+    const files = await storage.list()
+    expect(files.find(f => f.id === file.id)).toBeUndefined()
+  })
+
+  it('getUrl returns a url string', async () => {
+    const storage = createLocalStorageFileAdapter()
+    const file = await storage.upload(new Blob(['x']) as File, 'test.txt')
+    const url = await storage.getUrl(file.id)
+    expect(typeof url).toBe('string')
+  })
+})
+
+// ─── localStorage Admin Adapter ───────────────────────────────────────────────
+
+describe('createLocalStorageAdminAdapter', () => {
+  beforeEach(() => clearStorage())
+
+  it('getMetrics returns shaped metrics object', async () => {
+    const admin = createLocalStorageAdminAdapter()
+    const metrics = await admin.getMetrics()
+    expect(metrics).toHaveProperty('totalUsers')
+    expect(metrics).toHaveProperty('activeUsers')
+    expect(metrics).toHaveProperty('revenue')
+  })
+
+  it('listUsers returns an array', async () => {
+    const admin = createLocalStorageAdminAdapter()
+    const users = await admin.listUsers()
+    expect(Array.isArray(users)).toBe(true)
+  })
+})

package/packages/shared/src/admin/index.ts

@@ -0,0 +1,2 @@
+export type { AdminAdapter, AdminMetrics, ManagedUser } from './interface'
+export { createLocalStorageAdminAdapter } from './localStorage'

package/packages/shared/src/admin/interface.ts

@@ -0,0 +1,34 @@
+// @geenius/adapters — Admin adapter interface
+// Provides user management and dashboard metrics for admin panels.
+
+import type { AuthUser } from '../types'
+
+export interface AdminMetrics {
+  totalUsers: number
+  activeUsers: number
+  newUsersToday: number
+  totalRevenue?: number
+  mrr?: number
+}
+
+export interface ManagedUser extends AuthUser {
+  isActive: boolean
+  isBanned: boolean
+  plan?: string
+  lastLoginAt?: string
+}
+
+export interface AdminAdapter {
+  /** List all users with pagination */
+  listUsers(options?: { limit?: number; offset?: number; search?: string }): Promise<ManagedUser[]>
+  /** Get a single user by ID */
+  getUser(id: string): Promise<ManagedUser | null>
+  /** Ban a user */
+  banUser(id: string): Promise<boolean>
+  /** Unban a user */
+  unbanUser(id: string): Promise<boolean>
+  /** Delete a user */
+  deleteUser(id: string): Promise<boolean>
+  /** Get dashboard metrics */
+  getMetrics(): Promise<AdminMetrics>
+}

package/packages/shared/src/admin/localStorage.ts

@@ -0,0 +1,109 @@
+// @geenius/adapters — localStorage admin implementation (Pronto/MVP tier)
+
+import type { AdminAdapter, AdminMetrics, ManagedUser } from './interface'
+
+const USERS_KEY = 'geenius_auth_users'
+
+export function createLocalStorageAdminAdapter(): AdminAdapter {
+  function getUsers(): ManagedUser[] {
+    try {
+      const data = localStorage.getItem(USERS_KEY)
+      if (!data) return []
+      const raw = JSON.parse(data) as Record<string, any>
+      return Object.values(raw).map((u: any) => ({
+        id: u.id,
+        email: u.email,
+        name: u.name,
+        image: u.image,
+        role: u.role || 'user',
+        isActive: true,
+        isBanned: u.isBanned || false,
+        plan: u.plan || 'free',
+        createdAt: u.createdAt,
+        lastLoginAt: u.lastLoginAt,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  return {
+    async listUsers(options?) {
+      let users = getUsers()
+
+      if (options?.search) {
+        const q = options.search.toLowerCase()
+        users = users.filter(
+          (u) =>
+            u.email?.toLowerCase().includes(q) ||
+            u.name?.toLowerCase().includes(q)
+        )
+      }
+
+      const offset = options?.offset || 0
+      const limit = options?.limit || 50
+      return users.slice(offset, offset + limit)
+    },
+
+    async getUser(id) {
+      const users = getUsers()
+      return users.find((u) => u.id === id) || null
+    },
+
+    async banUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY) || '{}')
+        if (data[id]) {
+          data[id].isBanned = true
+          localStorage.setItem(USERS_KEY, JSON.stringify(data))
+          return true
+        }
+        return false
+      } catch {
+        return false
+      }
+    },
+
+    async unbanUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY) || '{}')
+        if (data[id]) {
+          data[id].isBanned = false
+          localStorage.setItem(USERS_KEY, JSON.stringify(data))
+          return true
+        }
+        return false
+      } catch {
+        return false
+      }
+    },
+
+    async deleteUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY) || '{}')
+        if (data[id]) {
+          delete data[id]
+          localStorage.setItem(USERS_KEY, JSON.stringify(data))
+          return true
+        }
+        return false
+      } catch {
+        return false
+      }
+    },
+
+    async getMetrics(): Promise<AdminMetrics> {
+      const users = getUsers()
+      const today = new Date().toISOString().split('T')[0]
+      const newToday = users.filter(
+        (u) => u.createdAt && u.createdAt.startsWith(today)
+      ).length
+
+      return {
+        totalUsers: users.length,
+        activeUsers: users.filter((u) => u.isActive && !u.isBanned).length,
+        newUsersToday: newToday,
+      }
+    },
+  }
+}