@geenius/adapters 0.1.0 → 0.3.0

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

@@ -1,91 +0,0 @@
-// @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

@@ -1,125 +0,0 @@
-// @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

@@ -1,171 +0,0 @@
-// @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

@@ -1,158 +0,0 @@
-// @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

@@ -1,117 +0,0 @@
-// @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

@@ -1,4 +0,0 @@
-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

@@ -1,11 +0,0 @@
-// @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>
-}