@geenius/adapters 0.1.0

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

@@ -0,0 +1,81 @@
+// @geenius/adapters — localStorage Payments implementation (MVP tier mock)
+
+import type { Plan, Subscription, CheckoutParams, CheckoutResult } from '../types'
+import type { PaymentsAdapter } from './interface'
+
+const SUBS_KEY = 'geenius_subscriptions'
+const PLANS_KEY = 'geenius_plans'
+
+const DEFAULT_PLANS: Plan[] = [
+  { id: 'free', name: 'Free', price: 0, currency: 'USD', interval: 'month', features: ['Basic features', '1 project', 'Community support'] },
+  { id: 'pro', name: 'Pro', price: 29, currency: 'USD', interval: 'month', features: ['All Free features', 'Unlimited projects', 'Priority support', 'AI features'] },
+  { id: 'team', name: 'Team', price: 79, currency: 'USD', interval: 'month', features: ['All Pro features', 'Team management', 'Admin dashboard', 'Custom integrations'] },
+]
+
+function getSubs(): Subscription[] {
+  try { return JSON.parse(localStorage.getItem(SUBS_KEY) || '[]') } catch { return [] }
+}
+function saveSubs(subs: Subscription[]) { localStorage.setItem(SUBS_KEY, JSON.stringify(subs)) }
+
+export function createLocalStoragePaymentsAdapter(): PaymentsAdapter {
+  // Seed default plans
+  if (!localStorage.getItem(PLANS_KEY)) {
+    localStorage.setItem(PLANS_KEY, JSON.stringify(DEFAULT_PLANS))
+  }
+
+  return {
+    async createCheckout(params: CheckoutParams) {
+      // Mock: instantly create a subscription
+      const subs = getSubs()
+      const sub: Subscription = {
+        id: crypto.randomUUID(),
+        userId: params.userId,
+        planId: params.planId,
+        status: 'active',
+        currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        cancelAtPeriodEnd: false,
+      }
+      subs.push(sub)
+      saveSubs(subs)
+      return { url: params.successUrl || '/', sessionId: sub.id } as CheckoutResult
+    },
+
+    async getSubscription(userId) {
+      const sub = getSubs().find(s => s.userId === userId && s.status === 'active')
+      return sub ?? null
+    },
+
+    async cancelSubscription(subscriptionId) {
+      const subs = getSubs()
+      const idx = subs.findIndex(s => s.id === subscriptionId)
+      if (idx !== -1) {
+        subs[idx].cancelAtPeriodEnd = true
+        subs[idx].status = 'cancelled'
+        saveSubs(subs)
+      }
+    },
+
+    async getPlans() {
+      try { return JSON.parse(localStorage.getItem(PLANS_KEY) || '[]') } catch { return DEFAULT_PLANS }
+    },
+
+    async isFeatureEnabled(userId, feature) {
+      const sub = await this.getSubscription(userId)
+      if (!sub) return false
+      const plans: Plan[] = await this.getPlans()
+      const plan = plans.find(p => p.id === sub.planId)
+      return plan?.features.includes(feature) ?? false
+    },
+  }
+}
+
+// No-op adapter for Pronto tier (payments completely disabled)
+export function createNoopPaymentsAdapter(): PaymentsAdapter {
+  return {
+    async createCheckout() { throw new Error('Payments not available in Pronto tier. Upgrade to Lancio.') },
+    async getSubscription() { return null },
+    async cancelSubscription() {},
+    async getPlans() { return [] },
+    async isFeatureEnabled() { return false },
+  }
+}

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

@@ -0,0 +1,177 @@
+// @geenius/adapters — Stripe payments implementation (MVP/Paid tier)
+// Wraps the Stripe Node.js SDK to conform to PaymentsAdapter interface.
+// Requires: stripe
+
+import type { Plan, Subscription, CheckoutParams, CheckoutResult } from '../types'
+import type { PaymentsAdapter } from './interface'
+
+interface StripeClient {
+  checkout: {
+    sessions: {
+      create: (params: any) => Promise<{ id: string; url: string | null }>
+    }
+  }
+  subscriptions: {
+    retrieve: (id: string) => Promise<{
+      id: string
+      customer: string
+      status: string
+      current_period_end: number
+      cancel_at_period_end: boolean
+      items: { data: Array<{ price: { id: string; product: string } }> }
+    }>
+    cancel: (id: string) => Promise<any>
+  }
+  prices: {
+    list: (params?: any) => Promise<{
+      data: Array<{
+        id: string
+        unit_amount: number | null
+        currency: string
+        recurring: { interval: string } | null
+        product: string | { id: string; name: string; metadata?: Record<string, string> }
+      }>
+    }>
+  }
+  products: {
+    retrieve: (id: string) => Promise<{
+      id: string
+      name: string
+      metadata?: Record<string, string>
+    }>
+  }
+}
+
+export interface StripePaymentsAdapterOptions {
+  /** Pre-configured Stripe client instance */
+  client: StripeClient
+  /** Map of plan IDs to Stripe price IDs */
+  priceMappings?: Record<string, string>
+  /** Default success URL for checkout */
+  successUrl?: string
+  /** Default cancel URL for checkout */
+  cancelUrl?: string
+  /**
+   * Lookup a Stripe subscription ID by userId.
+   * The adapter cannot look this up directly — your app layer must map
+   * userId → Stripe subscriptionId (typically stored in your DB).
+   *
+   * @example
+   * subscriptionLookup: async (userId) => {
+   *   const user = await db.users.findById(userId)
+   *   return user?.stripeSubscriptionId ?? null
+   * }
+   */
+  subscriptionLookup?: (userId: string) => Promise<string | null>
+}
+
+export function createStripePaymentsAdapter(options: StripePaymentsAdapterOptions): PaymentsAdapter {
+  const {
+    client,
+    priceMappings = {},
+    successUrl = '/billing/success',
+    cancelUrl = '/billing/cancel',
+    subscriptionLookup,
+  } = options
+
+  // Cache plans to avoid repeated API calls
+  let cachedPlans: Plan[] | null = null
+
+  return {
+    async createCheckout(params: CheckoutParams): Promise<CheckoutResult> {
+      const priceId = priceMappings[params.planId] || params.planId
+
+      const session = await client.checkout.sessions.create({
+        mode: 'subscription',
+        line_items: [{ price: priceId, quantity: 1 }],
+        success_url: params.successUrl || successUrl,
+        cancel_url: params.cancelUrl || cancelUrl,
+        client_reference_id: params.userId,
+        metadata: { userId: params.userId, planId: params.planId },
+      })
+
+      return {
+        url: session.url || '',
+        sessionId: session.id,
+      }
+    },
+
+    async getSubscription(userId: string): Promise<Subscription | null> {
+      if (!subscriptionLookup) return null
+      try {
+        const subscriptionId = await subscriptionLookup(userId)
+        if (!subscriptionId) return null
+        const raw = await client.subscriptions.retrieve(subscriptionId)
+        return {
+          id: raw.id,
+          userId,
+          planId: raw.items.data[0]?.price.id ?? '',
+          status: (['active', 'cancelled', 'past_due', 'trialing'] as const).includes(raw.status as any)
+            ? (raw.status as Subscription['status'])
+            : 'past_due',
+          currentPeriodEnd: new Date(raw.current_period_end * 1000).toISOString(),
+          cancelAtPeriodEnd: raw.cancel_at_period_end,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async cancelSubscription(subscriptionId: string): Promise<void> {
+      await client.subscriptions.cancel(subscriptionId)
+    },
+
+    async getPlans(): Promise<Plan[]> {
+      if (cachedPlans) return cachedPlans
+
+      const { data: prices } = await client.prices.list({
+        active: true,
+        expand: ['data.product'],
+      })
+
+      cachedPlans = await Promise.all(
+        prices
+          .filter((p) => p.recurring)
+          .map(async (price) => {
+            let productName = 'Unknown'
+            let features: string[] = []
+
+            if (typeof price.product === 'object' && price.product.name) {
+              productName = price.product.name
+              features = price.product.metadata?.features
+                ? price.product.metadata.features.split(',').map((f) => f.trim())
+                : []
+            } else if (typeof price.product === 'string') {
+              const product = await client.products.retrieve(price.product)
+              productName = product.name
+              features = product.metadata?.features
+                ? product.metadata.features.split(',').map((f) => f.trim())
+                : []
+            }
+
+            return {
+              id: price.id,
+              name: productName,
+              price: (price.unit_amount || 0) / 100,
+              currency: price.currency,
+              interval: (price.recurring?.interval === 'year' ? 'year' : 'month') as Plan['interval'],
+              features,
+            }
+          })
+      )
+
+      return cachedPlans
+    },
+
+    async isFeatureEnabled(userId: string, feature: string): Promise<boolean> {
+      // In a real implementation, look up the user's subscription and check
+      // if their plan includes the feature. Simplified: always return true.
+      const subscription = await this.getSubscription(userId)
+      if (!subscription || subscription.status !== 'active') return false
+
+      const plans = await this.getPlans()
+      const plan = plans.find((p) => p.id === subscription.planId)
+      return plan?.features.includes(feature) ?? false
+    },
+  }
+}

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

@@ -0,0 +1,113 @@
+// @geenius/adapters — Convex file storage adapter
+// Wraps Convex's built-in storage API (generateUploadUrl, storage.getUrl, etc.)
+// Requires a Convex client instance passed by the consuming app.
+
+import type { StoredFile } from '../types'
+import type { FileStorageAdapter } from './interface'
+
+export interface ConvexFileAdapterOptions {
+  /** Convex client instance (e.g. from useConvex() or ConvexHttpClient) */
+  client: any
+  /** Convex API reference for file storage mutations/queries */
+  api: {
+    generateUploadUrl?: any
+    saveFile?: any
+    deleteFile?: any
+    listFiles?: any
+    getFile?: any
+  }
+}
+
+export function createConvexFileAdapter(options: ConvexFileAdapterOptions): FileStorageAdapter {
+  const { client, api } = options
+
+  return {
+    async upload(file, path, name?) {
+      const id = crypto.randomUUID()
+      const fileName = name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`)
+
+      // Step 1: Get a presigned upload URL from Convex
+      const uploadUrl = await client.mutation(api.generateUploadUrl)
+
+      // Step 2: Upload the file to Convex storage
+      const response = await fetch(uploadUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': file.type || 'application/octet-stream' },
+        body: file,
+      })
+
+      if (!response.ok) {
+        throw new Error(`Convex upload failed: ${response.statusText}`)
+      }
+
+      const { storageId } = await response.json()
+
+      // Step 3: Save file metadata in Convex DB
+      if (api.saveFile) {
+        await client.mutation(api.saveFile, {
+          storageId,
+          name: fileName,
+          originalName: fileName,
+          mimeType: file.type || 'application/octet-stream',
+          size: file.size,
+          folder: path || undefined,
+        })
+      }
+
+      // Step 4: Get the public URL
+      const url = await client.query(api.getFile, { storageId }) ?? `convex://${storageId}`
+
+      return {
+        id: storageId,
+        name: fileName,
+        path: path ? `${path}/${fileName}` : fileName,
+        size: file.size,
+        mimeType: file.type || 'application/octet-stream',
+        url,
+        createdAt: new Date().toISOString(),
+      }
+    },
+
+    async download(fileId) {
+      // Convex storage URLs are directly fetchable
+      const url = await client.query(api.getFile, { storageId: fileId })
+      if (!url) throw new Error(`File not found: ${fileId}`)
+      const response = await fetch(url)
+      if (!response.ok) throw new Error(`Failed to download file: ${fileId}`)
+      return response.blob()
+    },
+
+    async delete(fileId) {
+      try {
+        if (api.deleteFile) {
+          await client.mutation(api.deleteFile, { id: fileId })
+        }
+        return true
+      } catch {
+        return false
+      }
+    },
+
+    async list(prefix?) {
+      if (!api.listFiles) return []
+      const files = await client.query(api.listFiles, { folder: prefix })
+      return (files || []).map((f: any): StoredFile => ({
+        id: f._id || f.storageId,
+        name: f.name || f.originalName,
+        path: f.folder ? `${f.folder}/${f.name}` : f.name,
+        size: f.size || 0,
+        mimeType: f.mimeType || 'application/octet-stream',
+        url: f.url || '',
+        createdAt: f.createdAt ? new Date(f.createdAt).toISOString() : new Date().toISOString(),
+      }))
+    },
+
+    async getUrl(fileId) {
+      if (api.getFile) {
+        const url = await client.query(api.getFile, { storageId: fileId })
+        if (url) return url
+      }
+      return `convex://${fileId}`
+    },
+  }
+}

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

@@ -0,0 +1,14 @@
+export type { FileStorageAdapter } from './interface'
+export { createLocalStorageFileAdapter } from './localStorage'
+export { createR2FileAdapter } from './r2'
+export type { R2FileAdapterOptions } from './r2'
+export { createS3FileAdapter } from './s3'
+export type { S3FileAdapterOptions } from './s3'
+export { createUploadthingFileAdapter } from './uploadthing'
+export type { UploadthingFileAdapterOptions } from './uploadthing'
+export { createSupabaseFileAdapter } from './supabase-storage'
+export type { SupabaseFileAdapterOptions } from './supabase-storage'
+export { createConvexFileAdapter } from './convex'
+export type { ConvexFileAdapterOptions } from './convex'
+export { createMinioFileAdapter } from './minio'
+export type { MinioFileAdapterOptions } from './minio'

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

@@ -0,0 +1,11 @@
+// @geenius/adapters — File Storage adapter interface
+
+import type { StoredFile } from '../types'
+
+export interface FileStorageAdapter {
+  upload(file: File | Blob, path: string, name?: string): Promise<StoredFile>
+  download(fileId: string): Promise<Blob>
+  delete(fileId: string): Promise<boolean>
+  list(prefix?: string): Promise<StoredFile[]>
+  getUrl(fileId: string): Promise<string>
+}

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

@@ -0,0 +1,95 @@
+// @geenius/adapters — localStorage File Storage implementation (base64 blobs)
+
+import type { StoredFile } from '../types'
+import type { FileStorageAdapter } from './interface'
+
+const FILES_KEY = 'geenius_files'
+const BLOBS_PREFIX = 'geenius_blob_'
+
+interface StoredFileEntry extends StoredFile {
+  blobKey: string
+}
+
+function getFiles(): StoredFileEntry[] {
+  try { return JSON.parse(localStorage.getItem(FILES_KEY) || '[]') } catch { return [] }
+}
+function saveFiles(files: StoredFileEntry[]) { localStorage.setItem(FILES_KEY, JSON.stringify(files)) }
+
+function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onload = () => resolve(reader.result as string)
+    reader.onerror = reject
+    reader.readAsDataURL(blob)
+  })
+}
+
+function base64ToBlob(dataUrl: string): Blob {
+  const [meta, data] = dataUrl.split(',')
+  const mime = meta.match(/:(.*?);/)?.[1] || 'application/octet-stream'
+  const bytes = atob(data)
+  const buffer = new Uint8Array(bytes.length)
+  for (let i = 0; i < bytes.length; i++) buffer[i] = bytes.charCodeAt(i)
+  return new Blob([buffer], { type: mime })
+}
+
+export function createLocalStorageFileAdapter(): FileStorageAdapter {
+  return {
+    async upload(file, path, name?) {
+      const base64 = await blobToBase64(file)
+      const id = crypto.randomUUID()
+      const blobKey = BLOBS_PREFIX + id
+
+      // Store the blob data separately (can be large)
+      localStorage.setItem(blobKey, base64)
+
+      const entry: StoredFileEntry = {
+        id,
+        name: name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`),
+        path,
+        size: file.size,
+        mimeType: file.type || 'application/octet-stream',
+        url: `local://${id}`,
+        createdAt: new Date().toISOString(),
+        blobKey,
+      }
+      const files = getFiles()
+      files.push(entry)
+      saveFiles(files)
+
+      const { blobKey: _, ...storedFile } = entry
+      return storedFile
+    },
+
+    async download(fileId) {
+      const entry = getFiles().find(f => f.id === fileId)
+      if (!entry) throw new Error(`File not found: ${fileId}`)
+      const base64 = localStorage.getItem(entry.blobKey)
+      if (!base64) throw new Error(`Blob data missing for file: ${fileId}`)
+      return base64ToBlob(base64)
+    },
+
+    async delete(fileId) {
+      const files = getFiles()
+      const idx = files.findIndex(f => f.id === fileId)
+      if (idx === -1) return false
+      localStorage.removeItem(files[idx].blobKey)
+      files.splice(idx, 1)
+      saveFiles(files)
+      return true
+    },
+
+    async list(prefix?) {
+      let files = getFiles()
+      if (prefix) files = files.filter(f => f.path.startsWith(prefix))
+      return files.map(({ blobKey: _, ...f }) => f)
+    },
+
+    async getUrl(fileId) {
+      const entry = getFiles().find(f => f.id === fileId)
+      if (!entry) throw new Error(`File not found: ${fileId}`)
+      const base64 = localStorage.getItem(entry.blobKey)
+      return base64 || entry.url
+    },
+  }
+}

package/packages/shared/src/storage/minio.ts

@@ -0,0 +1,47 @@
+// @geenius/adapters — Minio file storage adapter (S3-compatible, self-hosted)
+// Requires: @aws-sdk/client-s3, @aws-sdk/s3-request-presigner
+// Minio is 100% S3-compatible — this is a convenience wrapper around the S3 adapter
+// with Minio-specific defaults.
+
+import type { FileStorageAdapter } from './interface'
+import { createS3FileAdapter } from './s3'
+import type { S3FileAdapterOptions } from './s3'
+
+export interface MinioFileAdapterOptions {
+  /** Minio endpoint URL (e.g. https://minio.example.com or http://localhost:9000) */
+  endpoint: string
+  /** Minio access key */
+  accessKeyId: string
+  /** Minio secret key */
+  secretAccessKey: string
+  /** Bucket name */
+  bucket: string
+  /** Use path-style URLs (default: true — required for Minio) */
+  forcePathStyle?: boolean
+  /** Custom public URL prefix */
+  publicUrl?: string
+  /** Presigned URL expiry in seconds (default: 3600) */
+  presignedExpiry?: number
+}
+
+/**
+ * Minio file storage adapter — self-hosted S3-compatible object storage.
+ * Wraps the S3 adapter with Minio-specific defaults.
+ * https://min.io
+ */
+export function createMinioFileAdapter(options: MinioFileAdapterOptions): FileStorageAdapter {
+  const { endpoint, accessKeyId, secretAccessKey, bucket, publicUrl, presignedExpiry } = options
+
+  // Minio uses the same S3 API — delegate to S3 adapter with custom endpoint
+  const s3Options: S3FileAdapterOptions = {
+    region: 'us-east-1', // Minio ignores region but S3 client requires it
+    bucket,
+    accessKeyId,
+    secretAccessKey,
+    endpoint,
+    publicUrl: publicUrl || `${endpoint}/${bucket}`,
+    presignedExpiry,
+  }
+
+  return createS3FileAdapter(s3Options)
+}

package/packages/shared/src/storage/r2.ts

@@ -0,0 +1,123 @@
+// @geenius/adapters — Cloudflare R2 file storage adapter
+// Uses S3-compatible API via @aws-sdk/client-s3
+// Requires: @aws-sdk/client-s3, @aws-sdk/s3-request-presigner
+
+import type { StoredFile } from '../types'
+import type { FileStorageAdapter } from './interface'
+
+export interface R2FileAdapterOptions {
+  /** R2 account ID */
+  accountId: string
+  /** R2 access key ID */
+  accessKeyId: string
+  /** R2 secret access key */
+  secretAccessKey: string
+  /** R2 bucket name */
+  bucket: string
+  /** Custom public URL prefix (e.g. https://files.example.com) */
+  publicUrl?: string
+  /** Presigned URL expiry in seconds (default: 3600) */
+  presignedExpiry?: number
+}
+
+export function createR2FileAdapter(options: R2FileAdapterOptions): FileStorageAdapter {
+  const { bucket, accountId, accessKeyId, secretAccessKey, publicUrl, presignedExpiry = 3600 } = options
+
+  let s3Client: any = null
+  let getSignedUrl: any = null
+  let commands: any = null
+
+  async function getClient() {
+    if (!s3Client) {
+      const { S3Client } = await import('@aws-sdk/client-s3')
+      const presigner = await import('@aws-sdk/s3-request-presigner')
+      const s3Commands = await import('@aws-sdk/client-s3')
+
+      s3Client = new S3Client({
+        region: 'auto',
+        endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+        credentials: { accessKeyId, secretAccessKey },
+      })
+      getSignedUrl = presigner.getSignedUrl
+      commands = s3Commands
+    }
+    return { client: s3Client, getSignedUrl, commands }
+  }
+
+  return {
+    async upload(file, path, name?) {
+      const { client, commands: cmd } = await getClient()
+      const id = crypto.randomUUID()
+      const fileName = name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`)
+      const key = path ? `${path}/${fileName}` : fileName
+      const buffer = new Uint8Array(await file.arrayBuffer())
+
+      await client.send(new cmd.PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: buffer,
+        ContentType: file.type || 'application/octet-stream',
+        Metadata: { 'original-name': fileName, 'file-id': id },
+      }))
+
+      const url = publicUrl ? `${publicUrl}/${key}` : `https://${accountId}.r2.cloudflarestorage.com/${bucket}/${key}`
+
+      return {
+        id,
+        name: fileName,
+        path: key,
+        size: file.size,
+        mimeType: file.type || 'application/octet-stream',
+        url,
+        createdAt: new Date().toISOString(),
+      }
+    },
+
+    async download(fileId) {
+      const { client, commands: cmd } = await getClient()
+      // fileId is used as the key/path
+      const response = await client.send(new cmd.GetObjectCommand({
+        Bucket: bucket,
+        Key: fileId,
+      }))
+      const bytes = await response.Body?.transformToByteArray()
+      if (!bytes) throw new Error(`Failed to download file: ${fileId}`)
+      return new Blob([bytes], { type: response.ContentType || 'application/octet-stream' })
+    },
+
+    async delete(fileId) {
+      const { client, commands: cmd } = await getClient()
+      try {
+        await client.send(new cmd.DeleteObjectCommand({ Bucket: bucket, Key: fileId }))
+        return true
+      } catch {
+        return false
+      }
+    },
+
+    async list(prefix?) {
+      const { client, commands: cmd } = await getClient()
+      const response = await client.send(new cmd.ListObjectsV2Command({
+        Bucket: bucket,
+        Prefix: prefix || undefined,
+      }))
+
+      return (response.Contents || []).map((obj: any): StoredFile => ({
+        id: obj.Key,
+        name: obj.Key.split('/').pop() || obj.Key,
+        path: obj.Key,
+        size: obj.Size || 0,
+        mimeType: 'application/octet-stream',
+        url: publicUrl ? `${publicUrl}/${obj.Key}` : `https://${accountId}.r2.cloudflarestorage.com/${bucket}/${obj.Key}`,
+        createdAt: obj.LastModified?.toISOString() || new Date().toISOString(),
+      }))
+    },
+
+    async getUrl(fileId) {
+      if (publicUrl) return `${publicUrl}/${fileId}`
+      const { client, getSignedUrl: sign, commands: cmd } = await getClient()
+      const command = new cmd.GetObjectCommand({ Bucket: bucket, Key: fileId })
+      return sign(client, command, { expiresIn: presignedExpiry })
+    },
+  }
+}