@geenius/adapters 0.1.0

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

@@ -0,0 +1,125 @@
+// @geenius/adapters — localStorage Auth implementation
+
+import type { AuthUser, AuthSession } from '../types'
+import type { AuthAdapter } from './interface'
+
+interface StoredUser extends AuthUser {
+  passwordHash: string
+  email: string
+}
+
+const USERS_KEY = 'geenius_users'
+const SESSION_KEY = 'geenius_session'
+
+function getUsers(): StoredUser[] {
+  try { return JSON.parse(localStorage.getItem(USERS_KEY) || '[]') } catch { return [] }
+}
+
+function saveUsers(users: StoredUser[]) {
+  localStorage.setItem(USERS_KEY, JSON.stringify(users))
+}
+
+function simpleHash(str: string): string {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i)
+    hash |= 0
+  }
+  return Math.abs(hash).toString(36)
+}
+
+function createSession(userId: string): AuthSession {
+  const session: AuthSession = {
+    userId,
+    token: crypto.randomUUID(),
+    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+  }
+  localStorage.setItem(SESSION_KEY, JSON.stringify(session))
+  return session
+}
+
+export function createLocalStorageAuthAdapter(): AuthAdapter {
+  return {
+    async signInWithOAuth(provider, options) {
+      // Mock OAuth flow — create a synthetic user and return a fake redirect URL.
+      // In real adapters this would redirect to the provider's authorization endpoint.
+      const mockEmail = `oauth-${provider}-user@example.com`
+      const users = getUsers()
+      let user = users.find(u => u.email === mockEmail)
+      if (!user) {
+        user = {
+          id: crypto.randomUUID(),
+          email: mockEmail,
+          name: `${provider.charAt(0).toUpperCase() + provider.slice(1)} User`,
+          createdAt: new Date().toISOString(),
+          passwordHash: '',
+        }
+        users.push(user)
+        saveUsers(users)
+      }
+      createSession(user.id)
+      const redirectUrl = options?.redirectUrl || '/'
+      return { url: redirectUrl }
+    },
+
+    async signUp(email, password, name) {
+      const users = getUsers()
+      if (users.find(u => u.email === email)) throw new Error('User already exists')
+      const user: StoredUser = {
+        id: crypto.randomUUID(),
+        email,
+        name: name || email.split('@')[0],
+        createdAt: new Date().toISOString(),
+        passwordHash: simpleHash(password),
+      }
+      users.push(user)
+      saveUsers(users)
+      return createSession(user.id)
+    },
+
+    async signIn(email, password) {
+      const user = getUsers().find(u => u.email === email)
+      if (!user || user.passwordHash !== simpleHash(password)) {
+        throw new Error('Invalid email or password')
+      }
+      return createSession(user.id)
+    },
+
+    async signOut() {
+      localStorage.removeItem(SESSION_KEY)
+    },
+
+    async getSession() {
+      try {
+        const s: AuthSession | null = JSON.parse(localStorage.getItem(SESSION_KEY) || 'null')
+        if (!s || !s.expiresAt) return null
+        if (new Date(s.expiresAt) < new Date()) {
+          localStorage.removeItem(SESSION_KEY)
+          return null
+        }
+        return s
+      } catch { return null }
+    },
+
+    async getUser() {
+      const session = await this.getSession()
+      if (!session) return null
+      const stored = getUsers().find(u => u.id === session.userId)
+      if (!stored) return null
+      const { passwordHash: _, ...user } = stored
+      return user
+    },
+
+    async updateUser(updates) {
+      const session = await this.getSession()
+      if (!session) return null
+      const users = getUsers()
+      const idx = users.findIndex(u => u.id === session.userId)
+      if (idx === -1) return null
+      Object.assign(users[idx], updates)
+      saveUsers(users)
+      const { passwordHash: _, ...user } = users[idx]
+      return user
+    },
+  }
+}

package/packages/shared/src/auth/supabase-auth.ts

@@ -0,0 +1,136 @@
+// @geenius/adapters — Supabase Auth adapter
+// Wraps the Supabase Auth client to conform to AuthAdapter interface.
+// Requires: @supabase/supabase-js
+
+import type { AuthUser, AuthSession } from '../types'
+import type { AuthAdapter, OAuthProvider } from './interface'
+
+interface SupabaseAuthClient {
+  auth: {
+    signInWithPassword: (params: { email: string; password: string }) => Promise<{
+      data: { session: { access_token: string; user: { id: string; email?: string; user_metadata: Record<string, any> } } | null }
+      error: { message: string } | null
+    }>
+    signUp: (params: { email: string; password: string; options?: { data?: Record<string, any> } }) => Promise<{
+      data: { session: { access_token: string; user: { id: string; email?: string; user_metadata: Record<string, any> } } | null }
+      error: { message: string } | null
+    }>
+    signOut: () => Promise<{ error: { message: string } | null }>
+    getSession: () => Promise<{
+      data: { session: { access_token: string; expires_at?: number; user: { id: string; email?: string; user_metadata: Record<string, any> } } | null }
+      error: { message: string } | null
+    }>
+    getUser: () => Promise<{
+      data: { user: { id: string; email?: string; user_metadata: Record<string, any> } | null }
+      error: { message: string } | null
+    }>
+    updateUser: (params: { data?: Record<string, any> }) => Promise<{
+      data: { user: { id: string; email?: string; user_metadata: Record<string, any> } | null }
+      error: { message: string } | null
+    }>
+    signInWithOAuth: (params: { provider: string; options?: { redirectTo?: string } }) => Promise<{
+      data: { url: string | null; provider: string } | null
+      error: { message: string } | null
+    }>
+  }
+}
+
+export interface SupabaseAuthAdapterOptions {
+  /** Pre-configured Supabase client instance (from createClient()) */
+  client: SupabaseAuthClient
+}
+
+export function createSupabaseAuthAdapter(options: SupabaseAuthAdapterOptions): AuthAdapter {
+  const { client } = options
+
+  function mapUser(user: { id: string; email?: string; user_metadata: Record<string, any> }): AuthUser {
+    return {
+      id: user.id,
+      email: user.email || '',
+      name: user.user_metadata?.name || user.user_metadata?.full_name,
+      image: user.user_metadata?.avatar_url || user.user_metadata?.image,
+    }
+  }
+
+  return {
+    async signInWithOAuth(provider: OAuthProvider, options?: { redirectUrl?: string }): Promise<{ url: string }> {
+      const { data, error } = await client.auth.signInWithOAuth({
+        provider,
+        options: options?.redirectUrl ? { redirectTo: options.redirectUrl } : undefined,
+      })
+      if (error) throw new Error(error.message)
+      if (!data?.url) throw new Error(`Supabase OAuth: no redirect URL returned for provider "${provider}"`)
+      return { url: data.url }
+    },
+
+    async signIn(email: string, password: string): Promise<AuthSession> {
+      const { data, error } = await client.auth.signInWithPassword({ email, password })
+      if (error) throw new Error(error.message)
+      if (!data.session) throw new Error('Supabase sign in failed — no session returned')
+
+      return {
+        userId: data.session.user.id,
+        token: data.session.access_token,
+      }
+    },
+
+    async signUp(email: string, password: string, name?: string): Promise<AuthSession> {
+      const { data, error } = await client.auth.signUp({
+        email,
+        password,
+        options: name ? { data: { name, full_name: name } } : undefined,
+      })
+      if (error) throw new Error(error.message)
+      if (!data.session) throw new Error('Supabase sign up failed — no session returned (check email confirmation settings)')
+
+      return {
+        userId: data.session.user.id,
+        token: data.session.access_token,
+      }
+    },
+
+    async signOut(): Promise<void> {
+      const { error } = await client.auth.signOut()
+      if (error) throw new Error(error.message)
+    },
+
+    async getSession(): Promise<AuthSession | null> {
+      try {
+        const { data, error } = await client.auth.getSession()
+        if (error || !data.session) return null
+
+        return {
+          userId: data.session.user.id,
+          token: data.session.access_token,
+          expiresAt: data.session.expires_at ? new Date(data.session.expires_at * 1000).toISOString() : undefined,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async getUser(): Promise<AuthUser | null> {
+      try {
+        const { data, error } = await client.auth.getUser()
+        if (error || !data.user) return null
+        return mapUser(data.user)
+      } catch {
+        return null
+      }
+    },
+
+    async updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null> {
+      try {
+        const metadata: Record<string, any> = {}
+        if (updates.name) { metadata.name = updates.name; metadata.full_name = updates.name }
+        if (updates.image) { metadata.avatar_url = updates.image; metadata.image = updates.image }
+
+        const { data, error } = await client.auth.updateUser({ data: metadata })
+        if (error || !data.user) return null
+        return mapUser(data.user)
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/packages/shared/src/config.ts

@@ -0,0 +1,57 @@
+// @geenius-adapters/shared — Configuration singleton
+
+import type { AdapterConfig, AdapterDomain } from './types'
+
+let _config: AdapterConfig | null = null
+
+/**
+ * Configure the adapter system.
+ * Call once at app startup before using any adapter hooks.
+ *
+ * @example
+ * ```ts
+ * configureAdapters({
+ *   db: { provider: 'convex' },
+ *   auth: { provider: 'better-auth' },
+ *   ai: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY },
+ *   storage: { provider: 'r2' },
+ *   payments: { provider: 'stripe' },
+ * })
+ * ```
+ */
+export function configureAdapters(config: AdapterConfig): void {
+  _config = config
+}
+
+/**
+ * Get the current adapter configuration.
+ * Throws if configureAdapters() has not been called.
+ */
+export function getAdapterConfig(): AdapterConfig {
+  if (!_config) {
+    throw new Error('Adapters not configured. Call configureAdapters() first.')
+  }
+  return _config
+}
+
+/**
+ * Check if adapters have been configured.
+ */
+export function isAdaptersConfigured(): boolean {
+  return _config !== null
+}
+
+/**
+ * Reset adapter configuration (useful for testing).
+ */
+export function resetAdapterConfig(): void {
+  _config = null
+}
+
+/**
+ * Get config for a specific adapter domain.
+ */
+export function getDomainConfig(domain: AdapterDomain) {
+  const config = getAdapterConfig()
+  return config[domain] ?? null
+}

package/packages/shared/src/constants.ts

@@ -0,0 +1,122 @@
+// @geenius-adapters/shared — Constants & defaults
+
+import type { AdapterDomain } from './types'
+
+// ─── Adapter Domains ─────────────────────────────────────────────────────────
+
+export const ADAPTER_DOMAINS: readonly AdapterDomain[] = [
+  'db', 'auth', 'payments', 'ai', 'storage', 'admin',
+] as const
+
+// ─── Provider Names per Domain ───────────────────────────────────────────────
+
+export const DB_PROVIDERS = ['localStorage', 'convex', 'supabase', 'neon', 'mongodb'] as const
+export const AUTH_PROVIDERS = ['localStorage', 'better-auth', 'convex-auth', 'clerk', 'supabase-auth'] as const
+export const AI_PROVIDERS = ['localStorage', 'openai', 'anthropic', 'gemini', 'ollama', 'cloudflare-ai-gateway', 'vercel-ai-sdk'] as const
+export const STORAGE_PROVIDERS = ['localStorage', 'r2', 's3', 'uploadthing', 'supabase-storage', 'convex-storage', 'minio'] as const
+export const PAYMENT_PROVIDERS = ['localStorage', 'stripe', 'noop'] as const
+export const ADMIN_PROVIDERS = ['localStorage'] as const
+
+export type DbProviderName = (typeof DB_PROVIDERS)[number]
+export type AuthProviderName = (typeof AUTH_PROVIDERS)[number]
+export type AiProviderName = (typeof AI_PROVIDERS)[number]
+export type StorageProviderName = (typeof STORAGE_PROVIDERS)[number]
+export type PaymentProviderName = (typeof PAYMENT_PROVIDERS)[number]
+export type AdminProviderName = (typeof ADMIN_PROVIDERS)[number]
+
+// ─── Status Types ────────────────────────────────────────────────────────────
+
+export const ADAPTER_STATUSES = ['connected', 'disconnected', 'error', 'initializing'] as const
+export type AdapterStatus = (typeof ADAPTER_STATUSES)[number]
+
+// ─── Domain Labels ───────────────────────────────────────────────────────────
+
+export const DOMAIN_LABELS: Record<AdapterDomain, string> = {
+  db: 'Database',
+  auth: 'Authentication',
+  payments: 'Payments',
+  ai: 'AI & LLM',
+  storage: 'File Storage',
+  admin: 'Admin Panel',
+}
+
+export const DOMAIN_ICONS: Record<AdapterDomain, string> = {
+  db: '🗄️',
+  auth: '🔐',
+  payments: '💳',
+  ai: '🤖',
+  storage: '📁',
+  admin: '⚙️',
+}
+
+export const DOMAIN_DESCRIPTIONS: Record<AdapterDomain, string> = {
+  db: 'Connect to your preferred database backend for data persistence.',
+  auth: 'User authentication, sessions, and identity management.',
+  payments: 'Subscriptions, checkout, and billing management.',
+  ai: 'AI completions, chat, and embeddings via any LLM provider.',
+  storage: 'Upload, download, and manage files with any storage provider.',
+  admin: 'Admin dashboard metrics and user management.',
+}
+
+// ─── Provider Metadata ───────────────────────────────────────────────────────
+
+export interface ProviderMeta {
+  id: string
+  name: string
+  domain: AdapterDomain
+  description: string
+  /** Minimum tier required to use this provider */
+  tier: 'pronto' | 'lancio' | 'studio'
+  docUrl?: string
+}
+
+export const PROVIDER_REGISTRY: ProviderMeta[] = [
+  // DB
+  { id: 'localStorage', name: 'localStorage', domain: 'db', description: 'In-browser mock storage for prototyping', tier: 'pronto' },
+  { id: 'convex', name: 'Convex', domain: 'db', description: 'Real-time cloud database with sub-50ms reactivity', tier: 'lancio' },
+  { id: 'supabase', name: 'Supabase', domain: 'db', description: 'PostgreSQL + Auth + Storage', tier: 'lancio' },
+  { id: 'neon', name: 'Neon', domain: 'db', description: 'Serverless PostgreSQL', tier: 'lancio' },
+  { id: 'mongodb', name: 'MongoDB', domain: 'db', description: 'Document database via Prisma ORM', tier: 'lancio' },
+  // Auth
+  { id: 'localStorage', name: 'localStorage', domain: 'auth', description: 'Mock auth for prototyping', tier: 'pronto' },
+  { id: 'better-auth', name: 'Better Auth', domain: 'auth', description: 'Self-hosted auth with OAuth + MFA', tier: 'lancio' },
+  { id: 'convex-auth', name: 'Convex Auth', domain: 'auth', description: 'Built-in Convex sessions', tier: 'lancio' },
+  { id: 'clerk', name: 'Clerk', domain: 'auth', description: 'SaaS auth with pre-built UI', tier: 'lancio' },
+  { id: 'supabase-auth', name: 'Supabase Auth', domain: 'auth', description: 'Built-in Supabase auth', tier: 'lancio' },
+  // AI
+  { id: 'localStorage', name: 'localStorage', domain: 'ai', description: 'Mock AI for prototyping', tier: 'pronto' },
+  { id: 'openai', name: 'OpenAI', domain: 'ai', description: 'GPT models with streaming + embeddings', tier: 'lancio' },
+  { id: 'anthropic', name: 'Anthropic', domain: 'ai', description: 'Claude models with streaming', tier: 'lancio' },
+  { id: 'gemini', name: 'Google Gemini', domain: 'ai', description: 'Gemini models, zero npm deps', tier: 'lancio' },
+  { id: 'ollama', name: 'Ollama', domain: 'ai', description: 'Local LLMs, zero npm deps', tier: 'lancio' },
+  { id: 'cloudflare-ai-gateway', name: 'CF AI Gateway', domain: 'ai', description: 'Caching/rate-limiting proxy', tier: 'studio' },
+  { id: 'vercel-ai-sdk', name: 'Vercel AI SDK', domain: 'ai', description: 'generateText/embed wrappers', tier: 'studio' },
+  // Storage
+  { id: 'localStorage', name: 'localStorage', domain: 'storage', description: 'Base64 in-browser storage', tier: 'pronto' },
+  { id: 'r2', name: 'Cloudflare R2', domain: 'storage', description: 'S3-compatible, zero egress', tier: 'lancio' },
+  { id: 's3', name: 'AWS S3', domain: 'storage', description: 'IAM roles + CloudFront CDN', tier: 'lancio' },
+  { id: 'uploadthing', name: 'Uploadthing', domain: 'storage', description: 'REST API file upload SaaS', tier: 'lancio' },
+  { id: 'supabase-storage', name: 'Supabase Storage', domain: 'storage', description: 'Native Supabase storage', tier: 'lancio' },
+  { id: 'convex-storage', name: 'Convex Storage', domain: 'storage', description: 'Convex built-in file storage', tier: 'lancio' },
+  { id: 'minio', name: 'Minio', domain: 'storage', description: 'Self-hosted S3-compatible', tier: 'studio' },
+  // Payments
+  { id: 'localStorage', name: 'localStorage', domain: 'payments', description: 'Mock billing for prototyping', tier: 'pronto' },
+  { id: 'stripe', name: 'Stripe', domain: 'payments', description: 'Full billing, subscriptions, checkout', tier: 'lancio' },
+  { id: 'noop', name: 'Noop', domain: 'payments', description: 'No-op adapter — always returns success', tier: 'pronto' },
+  // Admin
+  { id: 'localStorage', name: 'localStorage', domain: 'admin', description: 'Mock admin for prototyping', tier: 'pronto' },
+]
+
+/**
+ * Get all providers for a specific domain.
+ */
+export function getProvidersForDomain(domain: AdapterDomain): ProviderMeta[] {
+  return PROVIDER_REGISTRY.filter((p) => p.domain === domain)
+}
+
+/**
+ * Get a specific provider by id and domain.
+ */
+export function getProviderMeta(domain: AdapterDomain, providerId: string): ProviderMeta | undefined {
+  return PROVIDER_REGISTRY.find((p) => p.domain === domain && p.id === providerId)
+}

package/packages/shared/src/db/convex.ts

@@ -0,0 +1,146 @@
+// @geenius/adapters — Convex DB implementation (MVP tier)
+// Wraps the Convex client to conform to DbAdapter interface.
+// Requires: convex
+
+import type { ListOptions, QueryFilter } from '../types'
+import type { DbAdapter } from './interface'
+
+interface ConvexClient {
+  query: (fn: any, args?: any) => Promise<any>
+  mutation: (fn: any, args?: any) => Promise<any>
+}
+
+export interface ConvexDbAdapterOptions {
+  /** Pre-configured Convex client */
+  client: ConvexClient
+  /** Map of collection names to Convex function references */
+  functions: {
+    [collection: string]: {
+      create?: any
+      get?: any
+      update?: any
+      delete?: any
+      list?: any
+      query?: any
+      count?: any
+    }
+  }
+}
+
+/**
+ * Creates a Convex-backed DbAdapter.
+ *
+ * Since Convex uses predefined queries/mutations rather than arbitrary SQL,
+ * you must provide function references for each collection. The adapter maps
+ * generic CRUD calls to these Convex functions.
+ *
+ * @example
+ * ```ts
+ * import { api } from '../convex/_generated/api'
+ *
+ * const db = createConvexDbAdapter({
+ *   client: convex,
+ *   functions: {
+ *     tasks: {
+ *       create: api.tasks.create,
+ *       get: api.tasks.get,
+ *       list: api.tasks.list,
+ *       update: api.tasks.update,
+ *       delete: api.tasks.remove,
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export function createConvexDbAdapter(options: ConvexDbAdapterOptions): DbAdapter {
+  const { client, functions } = options
+
+  function getFns(collection: string) {
+    const fns = functions[collection]
+    if (!fns) throw new Error(`No Convex functions configured for collection: ${collection}`)
+    return fns
+  }
+
+  return {
+    async create(collection, data) {
+      const fns = getFns(collection)
+      if (!fns.create) throw new Error(`No create function for ${collection}`)
+      const id = await client.mutation(fns.create, data)
+      return { ...data, id } as any
+    },
+
+    async get(collection, id) {
+      const fns = getFns(collection)
+      if (!fns.get) throw new Error(`No get function for ${collection}`)
+      const doc = await client.query(fns.get, { id })
+      if (!doc) return null
+      return { ...doc, id: doc._id || id } as any
+    },
+
+    async update(collection, id, data) {
+      const fns = getFns(collection)
+      if (!fns.update) throw new Error(`No update function for ${collection}`)
+      await client.mutation(fns.update, { id, ...data })
+      return this.get(collection, id) as any
+    },
+
+    async delete(collection, id) {
+      const fns = getFns(collection)
+      if (!fns.delete) throw new Error(`No delete function for ${collection}`)
+      try {
+        await client.mutation(fns.delete, { id })
+        return true
+      } catch {
+        return false
+      }
+    },
+
+    async list(collection, options?: ListOptions) {
+      const fns = getFns(collection)
+      if (!fns.list) throw new Error(`No list function for ${collection}`)
+      const docs = await client.query(fns.list, {
+        limit: options?.limit,
+        offset: options?.offset,
+        orderBy: options?.orderBy,
+        order: options?.order,
+      })
+      return (docs || []).map((d: any) => ({ ...d, id: d._id || d.id }))
+    },
+
+    async query(collection, filter) {
+      const fns = getFns(collection)
+      if (!fns.query) {
+        // Fallback: list all and filter client-side
+        const all = await this.list(collection)
+        return all.filter((item: any) =>
+          filter.every((cond) => {
+            const val = item[cond.field]
+            switch (cond.operator) {
+              case 'eq': return val === cond.value
+              case 'neq': return val !== cond.value
+              case 'gt': return (val as number) > (cond.value as number)
+              case 'gte': return (val as number) >= (cond.value as number)
+              case 'lt': return (val as number) < (cond.value as number)
+              case 'lte': return (val as number) <= (cond.value as number)
+              case 'in': return Array.isArray(cond.value) && cond.value.includes(val)
+              case 'contains': return typeof val === 'string' && val.includes(cond.value as string)
+              default: return false
+            }
+          })
+        )
+      }
+      const docs = await client.query(fns.query, { filter })
+      return (docs || []).map((d: any) => ({ ...d, id: d._id || d.id }))
+    },
+
+    async count(collection, filter?) {
+      const fns = getFns(collection)
+      if (fns.count) {
+        return client.query(fns.count, filter ? { filter } : undefined)
+      }
+      // Fallback: count via list/query
+      const items = filter ? await this.query(collection, filter) : await this.list(collection)
+      return items.length
+    },
+  }
+}

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

@@ -0,0 +1,10 @@
+export type { DbAdapter } from './interface'
+export { createLocalStorageDbAdapter } from './localStorage'
+export { createConvexDbAdapter } from './convex'
+export type { ConvexDbAdapterOptions } from './convex'
+export { createNeonDbAdapter } from './neon'
+export type { NeonDbAdapterOptions } from './neon'
+export { createSupabaseDbAdapter } from './supabase'
+export type { SupabaseDbAdapterOptions } from './supabase'
+export { createMongoDbAdapter } from './mongodb'
+export type { MongoDbAdapterOptions } from './mongodb'

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

@@ -0,0 +1,13 @@
+// @geenius/adapters — DB adapter interface
+
+import type { ListOptions, QueryFilter } from '../types'
+
+export interface DbAdapter {
+  create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>): Promise<T & { id: string }>
+  get<T>(collection: string, id: string): Promise<T | null>
+  update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>): Promise<T | null>
+  delete(collection: string, id: string): Promise<boolean>
+  list<T>(collection: string, options?: ListOptions): Promise<T[]>
+  query<T>(collection: string, filter: QueryFilter): Promise<T[]>
+  count(collection: string, filter?: QueryFilter): Promise<number>
+}