@geenius/adapters 0.1.0

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

@@ -0,0 +1,91 @@
+// @geenius/adapters — localStorage DB implementation
+
+import type { ListOptions, QueryFilter, QueryCondition } from '../types'
+import type { DbAdapter } from './interface'
+
+const DB_PREFIX = 'geenius_db_'
+
+function getCollection<T>(collection: string): (T & { id: string })[] {
+  try { return JSON.parse(localStorage.getItem(DB_PREFIX + collection) || '[]') } catch { return [] }
+}
+
+function saveCollection<T>(collection: string, data: T[]) {
+  localStorage.setItem(DB_PREFIX + collection, JSON.stringify(data))
+}
+
+function matchesCondition(item: Record<string, unknown>, cond: QueryCondition): boolean {
+  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
+  }
+}
+
+function matchesFilter(item: Record<string, unknown>, filter: QueryFilter): boolean {
+  return filter.every(cond => matchesCondition(item, cond))
+}
+
+export function createLocalStorageDbAdapter(): DbAdapter {
+  return {
+    async create(collection, data) {
+      const items = getCollection(collection)
+      const item = { ...data, id: crypto.randomUUID() } as any
+      items.push(item)
+      saveCollection(collection, items)
+      return item
+    },
+
+    async get(collection, id) {
+      return getCollection(collection).find((item: any) => item.id === id) as any ?? null
+    },
+
+    async update(collection, id, data) {
+      const items = getCollection(collection)
+      const idx = items.findIndex((item: any) => item.id === id)
+      if (idx === -1) return null
+      Object.assign(items[idx], data)
+      saveCollection(collection, items)
+      return items[idx] as any
+    },
+
+    async delete(collection, id) {
+      const items = getCollection(collection)
+      const idx = items.findIndex((item: any) => item.id === id)
+      if (idx === -1) return false
+      items.splice(idx, 1)
+      saveCollection(collection, items)
+      return true
+    },
+
+    async list(collection, options?: ListOptions) {
+      let items = getCollection(collection)
+      if (options?.orderBy) {
+        const dir = options.order === 'desc' ? -1 : 1
+        items.sort((a: any, b: any) => {
+          const av = a[options.orderBy!], bv = b[options.orderBy!]
+          return av < bv ? -dir : av > bv ? dir : 0
+        })
+      }
+      if (options?.offset) items = items.slice(options.offset)
+      if (options?.limit) items = items.slice(0, options.limit)
+      return items as any
+    },
+
+    async query(collection, filter) {
+      return getCollection(collection).filter(item => matchesFilter(item as any, filter)) as any
+    },
+
+    async count(collection, filter?) {
+      const items = getCollection(collection)
+      if (!filter || filter.length === 0) return items.length
+      return items.filter(item => matchesFilter(item as any, filter)).length
+    },
+  }
+}

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

@@ -0,0 +1,125 @@
+// @geenius/adapters — MongoDB implementation (MVP tier)
+// Wraps the MongoDB Node.js driver to conform to DbAdapter interface.
+// Requires: mongodb
+
+import type { ListOptions, QueryFilter } from '../types'
+import type { DbAdapter } from './interface'
+
+interface MongoCollection {
+  insertOne: (doc: any) => Promise<{ insertedId: any }>
+  findOne: (filter: any) => Promise<any>
+  updateOne: (filter: any, update: any) => Promise<any>
+  deleteOne: (filter: any) => Promise<{ deletedCount: number }>
+  find: (filter?: any) => MongoCursor
+  countDocuments: (filter?: any) => Promise<number>
+}
+
+interface MongoCursor {
+  sort: (sort: any) => MongoCursor
+  skip: (n: number) => MongoCursor
+  limit: (n: number) => MongoCursor
+  toArray: () => Promise<any[]>
+}
+
+interface MongoDb {
+  collection: (name: string) => MongoCollection
+}
+
+export interface MongoDbAdapterOptions {
+  /** Pre-configured MongoDB database instance */
+  db: MongoDb
+  /** Optional collection name mapping */
+  collectionNames?: Record<string, string>
+}
+
+/**
+ * Creates a MongoDB-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { MongoClient } from 'mongodb'
+ *
+ * const client = new MongoClient(process.env.MONGODB_URI!)
+ * const db = client.db('myapp')
+ * const adapter = createMongoDbAdapter({ db })
+ * ```
+ */
+export function createMongoDbAdapter(options: MongoDbAdapterOptions): DbAdapter {
+  const { db, collectionNames = {} } = options
+
+  function col(collection: string): MongoCollection {
+    return db.collection(collectionNames[collection] || collection)
+  }
+
+  function buildMongoFilter(filter: QueryFilter): Record<string, any> {
+    const mongoFilter: Record<string, any> = {}
+
+    for (const cond of filter) {
+      switch (cond.operator) {
+        case 'eq': mongoFilter[cond.field] = cond.value; break
+        case 'neq': mongoFilter[cond.field] = { $ne: cond.value }; break
+        case 'gt': mongoFilter[cond.field] = { $gt: cond.value }; break
+        case 'gte': mongoFilter[cond.field] = { $gte: cond.value }; break
+        case 'lt': mongoFilter[cond.field] = { $lt: cond.value }; break
+        case 'lte': mongoFilter[cond.field] = { $lte: cond.value }; break
+        case 'in': mongoFilter[cond.field] = { $in: cond.value }; break
+        case 'contains':
+          mongoFilter[cond.field] = { $regex: cond.value, $options: 'i' }
+          break
+      }
+    }
+
+    return mongoFilter
+  }
+
+  return {
+    async create(collection, data) {
+      const id = crypto.randomUUID()
+      const doc = { ...data, id }
+      await col(collection).insertOne(doc)
+      return doc as any
+    },
+
+    async get(collection, id) {
+      const doc = await col(collection).findOne({ id })
+      if (!doc) return null
+      const { _id, ...rest } = doc
+      return rest as any
+    },
+
+    async update(collection, id, data) {
+      const result = await col(collection).updateOne({ id }, { $set: data })
+      if (!result) return null
+      return this.get(collection, id) as any
+    },
+
+    async delete(collection, id) {
+      const result = await col(collection).deleteOne({ id })
+      return result.deletedCount > 0
+    },
+
+    async list(collection, options?: ListOptions) {
+      let cursor = col(collection).find()
+
+      if (options?.orderBy) {
+        cursor = cursor.sort({ [options.orderBy]: options.order === 'desc' ? -1 : 1 })
+      }
+      if (options?.offset) cursor = cursor.skip(options.offset)
+      if (options?.limit) cursor = cursor.limit(options.limit)
+
+      const docs = await cursor.toArray()
+      return docs.map(({ _id, ...rest }: any) => rest)
+    },
+
+    async query(collection, filter) {
+      const mongoFilter = buildMongoFilter(filter)
+      const docs = await col(collection).find(mongoFilter).toArray()
+      return docs.map(({ _id, ...rest }: any) => rest)
+    },
+
+    async count(collection, filter?) {
+      const mongoFilter = filter ? buildMongoFilter(filter) : {}
+      return col(collection).countDocuments(mongoFilter)
+    },
+  }
+}

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

@@ -0,0 +1,171 @@
+// @geenius/adapters — Neon/Drizzle DB implementation (MVP tier)
+// Wraps a Drizzle ORM instance over Neon Postgres to conform to DbAdapter.
+// Requires: drizzle-orm, @neondatabase/serverless
+//
+// The adapter accepts pre-built Drizzle operator functions via the options
+// to avoid importing drizzle-orm at build time (it's an optional peer dep).
+
+import type { ListOptions, QueryFilter } from '../types'
+import type { DbAdapter } from './interface'
+
+interface DrizzleTable {
+  [key: string]: any
+}
+
+interface DrizzleClient {
+  select: (fields?: any) => any
+  insert: (table: any) => any
+  update: (table: any) => any
+  delete: (table: any) => any
+}
+
+/** Drizzle operator functions — injected by the consumer */
+export interface DrizzleOperators {
+  eq: (col: any, value: any) => any
+  ne: (col: any, value: any) => any
+  gt: (col: any, value: any) => any
+  gte: (col: any, value: any) => any
+  lt: (col: any, value: any) => any
+  lte: (col: any, value: any) => any
+  inArray: (col: any, values: any[]) => any
+  like: (col: any, pattern: string) => any
+  and: (...conditions: any[]) => any
+  asc: (col: any) => any
+  desc: (col: any) => any
+  sql: any
+}
+
+export interface NeonDbAdapterOptions {
+  /** Pre-configured Drizzle client instance */
+  client: DrizzleClient
+  /** Map of collection names to Drizzle table schema objects */
+  tables: Record<string, DrizzleTable>
+  /** Drizzle operator functions (import from 'drizzle-orm') */
+  operators: DrizzleOperators
+}
+
+/**
+ * Creates a Neon-backed DbAdapter using Drizzle ORM.
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/neon-http'
+ * import { neon } from '@neondatabase/serverless'
+ * import { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql } from 'drizzle-orm'
+ * import * as schema from './schema'
+ *
+ * const db = drizzle(neon(process.env.DATABASE_URL!))
+ *
+ * const adapter = createNeonDbAdapter({
+ *   client: db,
+ *   tables: { tasks: schema.tasks },
+ *   operators: { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql },
+ * })
+ * ```
+ */
+export function createNeonDbAdapter(options: NeonDbAdapterOptions): DbAdapter {
+  const { client, tables, operators: ops } = options
+
+  function getTable(collection: string) {
+    const table = tables[collection]
+    if (!table) throw new Error(`No table configured for collection: ${collection}`)
+    return table
+  }
+
+  return {
+    async create(collection, data) {
+      const table = getTable(collection)
+      const [result] = await client
+        .insert(table)
+        .values(data)
+        .returning()
+      return result as any
+    },
+
+    async get(collection, id) {
+      const table = getTable(collection)
+      const [result] = await client
+        .select()
+        .from(table)
+        .where(ops.eq(table.id, id))
+        .limit(1)
+      return (result as any) ?? null
+    },
+
+    async update(collection, id, data) {
+      const table = getTable(collection)
+      const [result] = await client
+        .update(table)
+        .set(data)
+        .where(ops.eq(table.id, id))
+        .returning()
+      return (result as any) ?? null
+    },
+
+    async delete(collection, id) {
+      const table = getTable(collection)
+      try {
+        await client.delete(table).where(ops.eq(table.id, id))
+        return true
+      } catch {
+        return false
+      }
+    },
+
+    async list(collection, options?: ListOptions) {
+      const table = getTable(collection)
+      let query = client.select().from(table)
+
+      if (options?.orderBy) {
+        const col = table[options.orderBy]
+        if (col) {
+          query = query.orderBy(options.order === 'desc' ? ops.desc(col) : ops.asc(col))
+        }
+      }
+      if (options?.limit) query = query.limit(options.limit)
+      if (options?.offset) query = query.offset(options.offset)
+
+      return query as any
+    },
+
+    async query(collection, filter) {
+      const table = getTable(collection)
+
+      const conditions = filter.map((cond) => {
+        const col = table[cond.field]
+        if (!col) throw new Error(`Column ${cond.field} not found in ${collection}`)
+
+        switch (cond.operator) {
+          case 'eq': return ops.eq(col, cond.value)
+          case 'neq': return ops.ne(col, cond.value)
+          case 'gt': return ops.gt(col, cond.value)
+          case 'gte': return ops.gte(col, cond.value)
+          case 'lt': return ops.lt(col, cond.value)
+          case 'lte': return ops.lte(col, cond.value)
+          case 'in': return ops.inArray(col, cond.value as any[])
+          case 'contains': return ops.like(col, `%${cond.value}%`)
+          default: throw new Error(`Unsupported operator: ${cond.operator}`)
+        }
+      })
+
+      return client
+        .select()
+        .from(table)
+        .where(ops.and(...conditions)) as any
+    },
+
+    async count(collection, filter?) {
+      const table = getTable(collection)
+
+      if (!filter || filter.length === 0) {
+        const [result] = await client
+          .select({ count: ops.sql`count(*)` })
+          .from(table)
+        return Number(result?.count ?? 0)
+      }
+
+      const items = await this.query(collection, filter)
+      return items.length
+    },
+  }
+}

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

@@ -0,0 +1,158 @@
+// @geenius/adapters — Supabase DB implementation (MVP tier)
+// Wraps the Supabase client to conform to DbAdapter interface.
+// Requires: @supabase/supabase-js
+
+import type { ListOptions, QueryFilter } from '../types'
+import type { DbAdapter } from './interface'
+
+interface SupabaseClient {
+  from: (table: string) => SupabaseQueryBuilder
+}
+
+interface SupabaseQueryBuilder {
+  select: (columns?: string) => SupabaseQueryBuilder
+  insert: (data: any) => SupabaseQueryBuilder
+  update: (data: any) => SupabaseQueryBuilder
+  delete: () => SupabaseQueryBuilder
+  eq: (column: string, value: any) => SupabaseQueryBuilder
+  neq: (column: string, value: any) => SupabaseQueryBuilder
+  gt: (column: string, value: any) => SupabaseQueryBuilder
+  gte: (column: string, value: any) => SupabaseQueryBuilder
+  lt: (column: string, value: any) => SupabaseQueryBuilder
+  lte: (column: string, value: any) => SupabaseQueryBuilder
+  in: (column: string, values: any[]) => SupabaseQueryBuilder
+  ilike: (column: string, pattern: string) => SupabaseQueryBuilder
+  order: (column: string, options?: { ascending?: boolean }) => SupabaseQueryBuilder
+  range: (from: number, to: number) => SupabaseQueryBuilder
+  limit: (count: number) => SupabaseQueryBuilder
+  single: () => SupabaseQueryBuilder
+  then: (resolve: (value: any) => void) => Promise<any>
+  // Result accessors
+  data?: any
+  error?: any
+}
+
+export interface SupabaseDbAdapterOptions {
+  /** Pre-configured Supabase client instance */
+  client: SupabaseClient
+  /** Optional table name mapping: { collectionName: 'actual_table_name' } */
+  tableNames?: Record<string, string>
+}
+
+/**
+ * Creates a Supabase-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient(url, key)
+ * const db = createSupabaseDbAdapter({ client: supabase })
+ * ```
+ */
+export function createSupabaseDbAdapter(options: SupabaseDbAdapterOptions): DbAdapter {
+  const { client, tableNames = {} } = options
+
+  function tableName(collection: string): string {
+    return tableNames[collection] || collection
+  }
+
+  return {
+    async create(collection, data) {
+      const { data: result, error } = await client
+        .from(tableName(collection))
+        .insert(data)
+        .select()
+        .single() as any
+
+      if (error) throw new Error(`Supabase insert error: ${error.message}`)
+      return result
+    },
+
+    async get(collection, id) {
+      const { data, error } = await client
+        .from(tableName(collection))
+        .select()
+        .eq('id', id)
+        .single() as any
+
+      if (error) return null
+      return data
+    },
+
+    async update(collection, id, data) {
+      const { data: result, error } = await client
+        .from(tableName(collection))
+        .update(data)
+        .eq('id', id)
+        .select()
+        .single() as any
+
+      if (error) return null
+      return result
+    },
+
+    async delete(collection, id) {
+      const { error } = await client
+        .from(tableName(collection))
+        .delete()
+        .eq('id', id) as any
+
+      return !error
+    },
+
+    async list(collection, options?: ListOptions) {
+      let query = client.from(tableName(collection)).select()
+
+      if (options?.orderBy) {
+        query = query.order(options.orderBy, {
+          ascending: options.order !== 'desc',
+        })
+      }
+
+      if (options?.offset !== undefined && options?.limit !== undefined) {
+        query = query.range(options.offset, options.offset + options.limit - 1)
+      } else if (options?.limit) {
+        query = query.limit(options.limit)
+      }
+
+      const { data, error } = await query as any
+      if (error) throw new Error(`Supabase list error: ${error.message}`)
+      return data || []
+    },
+
+    async query(collection, filter) {
+      let query = client.from(tableName(collection)).select()
+
+      for (const cond of filter) {
+        switch (cond.operator) {
+          case 'eq': query = query.eq(cond.field, cond.value); break
+          case 'neq': query = query.neq(cond.field, cond.value); break
+          case 'gt': query = query.gt(cond.field, cond.value); break
+          case 'gte': query = query.gte(cond.field, cond.value); break
+          case 'lt': query = query.lt(cond.field, cond.value); break
+          case 'lte': query = query.lte(cond.field, cond.value); break
+          case 'in': query = query.in(cond.field, cond.value as any[]); break
+          case 'contains': query = query.ilike(cond.field, `%${cond.value}%`); break
+        }
+      }
+
+      const { data, error } = await query as any
+      if (error) throw new Error(`Supabase query error: ${error.message}`)
+      return data || []
+    },
+
+    async count(collection, filter?) {
+      if (!filter || filter.length === 0) {
+        // Fetch all IDs and count — simple approach that avoids Supabase-specific count API
+        const { data } = await client
+          .from(tableName(collection))
+          .select('id') as any
+        return data?.length ?? 0
+      }
+
+      const items = await this.query(collection, filter)
+      return items.length
+    },
+  }
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,117 @@
+// @geenius-adapters/shared — root barrel export
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type {
+  AuthUser, AuthSession,
+  ListOptions, QueryOperator, QueryCondition, QueryFilter,
+  Plan, Subscription, CheckoutParams, CheckoutResult,
+  ChatRole, ChatMessage, AiOptions, ChatResponse,
+  StoredFile,
+  AdapterDomain, DomainAdapterConfig, AdapterConfig,
+  AdapterStatusType, AdapterStatusInfo, AdapterRegistryEntry,
+} from './types'
+
+// ─── Configuration ───────────────────────────────────────────────────────────
+
+export {
+  configureAdapters, getAdapterConfig, isAdaptersConfigured,
+  resetAdapterConfig, getDomainConfig,
+} from './config'
+
+// ─── Constants & Registry ────────────────────────────────────────────────────
+
+export {
+  ADAPTER_DOMAINS, ADAPTER_STATUSES,
+  DB_PROVIDERS, AUTH_PROVIDERS, AI_PROVIDERS, STORAGE_PROVIDERS, PAYMENT_PROVIDERS, ADMIN_PROVIDERS,
+  DOMAIN_LABELS, DOMAIN_ICONS, DOMAIN_DESCRIPTIONS,
+  PROVIDER_REGISTRY, getProvidersForDomain, getProviderMeta,
+} from './constants'
+export type {
+  DbProviderName, AuthProviderName, AiProviderName, StorageProviderName,
+  PaymentProviderName, AdminProviderName, AdapterStatus, ProviderMeta,
+} from './constants'
+
+// ─── Adapter Interfaces ──────────────────────────────────────────────────────
+
+export type { AuthAdapter, OAuthProvider } from './auth'
+export type { DbAdapter } from './db'
+export type { PaymentsAdapter } from './payments'
+export type { AiAdapter } from './ai'
+export type { FileStorageAdapter } from './storage'
+export type { AdminAdapter, AdminMetrics, ManagedUser } from './admin'
+
+// ─── localStorage implementations (Pronto tier) ─────────────────────────────
+
+export { createLocalStorageAuthAdapter } from './auth'
+export { createLocalStorageDbAdapter } from './db'
+export { createLocalStoragePaymentsAdapter, createNoopPaymentsAdapter } from './payments'
+export { createLocalStorageAiAdapter } from './ai'
+export { createLocalStorageFileAdapter } from './storage'
+export { createLocalStorageAdminAdapter } from './admin'
+
+// ─── AI Provider implementations ─────────────────────────────────────────────
+
+export { createOpenAiAdapter } from './ai'
+export type { OpenAiAdapterOptions } from './ai'
+export { createAnthropicAdapter } from './ai'
+export type { AnthropicAdapterOptions } from './ai'
+export { createGeminiAdapter } from './ai'
+export type { GeminiAdapterOptions } from './ai'
+export { createOllamaAdapter } from './ai'
+export type { OllamaAdapterOptions } from './ai'
+export { createCloudflareAiGatewayAdapter } from './ai'
+export type { CloudflareAiGatewayOptions } from './ai'
+export { createVercelAiAdapter } from './ai'
+export type { VercelAiAdapterOptions } from './ai'
+
+// ─── Storage Provider implementations ────────────────────────────────────────
+
+export { createR2FileAdapter } from './storage'
+export type { R2FileAdapterOptions } from './storage'
+export { createS3FileAdapter } from './storage'
+export type { S3FileAdapterOptions } from './storage'
+export { createUploadthingFileAdapter } from './storage'
+export type { UploadthingFileAdapterOptions } from './storage'
+export { createSupabaseFileAdapter } from './storage'
+export type { SupabaseFileAdapterOptions } from './storage'
+export { createConvexFileAdapter } from './storage'
+export type { ConvexFileAdapterOptions } from './storage'
+export { createMinioFileAdapter } from './storage'
+export type { MinioFileAdapterOptions } from './storage'
+
+// ─── Auth Provider implementations ──────────────────────────────────────────
+
+export { createBetterAuthAdapter } from './auth'
+export type { BetterAuthAdapterOptions } from './auth'
+export { createConvexAuthAdapter } from './auth'
+export type { ConvexAuthAdapterOptions } from './auth'
+export { createClerkAuthAdapter } from './auth'
+export type { ClerkAuthAdapterOptions } from './auth'
+export { createSupabaseAuthAdapter } from './auth'
+export type { SupabaseAuthAdapterOptions } from './auth'
+
+// ─── DB Provider implementations ────────────────────────────────────────────
+
+export { createConvexDbAdapter } from './db'
+export type { ConvexDbAdapterOptions } from './db'
+export { createNeonDbAdapter } from './db'
+export type { NeonDbAdapterOptions } from './db'
+export { createSupabaseDbAdapter } from './db'
+export type { SupabaseDbAdapterOptions } from './db'
+export { createMongoDbAdapter } from './db'
+export type { MongoDbAdapterOptions } from './db'
+
+// ─── Payments Provider implementations ──────────────────────────────────────
+
+export { createStripePaymentsAdapter } from './payments'
+export type { StripePaymentsAdapterOptions } from './payments'
+
+// ─── Tier Gating ─────────────────────────────────────────────────────────────
+
+export type { ProjectTier, TierGateConfig } from './tier-gate'
+export {
+  isFeatureAvailable, isPackageAvailable,
+  getAvailableFeatures, getAvailablePackages,
+  getUpgradeFeatures, DEFAULT_TIER_GATE,
+} from './tier-gate'

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

@@ -0,0 +1,4 @@
+export type { PaymentsAdapter } from './interface'
+export { createLocalStoragePaymentsAdapter, createNoopPaymentsAdapter } from './localStorage'
+export { createStripePaymentsAdapter } from './stripe'
+export type { StripePaymentsAdapterOptions } from './stripe'

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

@@ -0,0 +1,11 @@
+// @geenius/adapters — Payments adapter interface
+
+import type { Plan, Subscription, CheckoutParams, CheckoutResult } from '../types'
+
+export interface PaymentsAdapter {
+  createCheckout(params: CheckoutParams): Promise<CheckoutResult>
+  getSubscription(userId: string): Promise<Subscription | null>
+  cancelSubscription(subscriptionId: string): Promise<void>
+  getPlans(): Promise<Plan[]>
+  isFeatureEnabled(userId: string, feature: string): Promise<boolean>
+}