@riligar/agents-kit 1.12.0 → 1.14.0

package/.agent/skills/riligar-dev-stripe/assets/stripe-server.js

@@ -0,0 +1,300 @@
+/**
+ * Stripe Server Snippets for Elysia
+ * Copy-paste ready code for backend Stripe integration
+ */
+
+// ============================================
+// 1. SETUP & PLUGIN
+// ============================================
+
+// plugins/stripe.js
+import { Elysia } from 'elysia'
+import Stripe from 'stripe'
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY)
+
+export const stripePlugin = new Elysia({ name: 'stripe' })
+    .decorate('stripe', stripe)
+
+// ============================================
+// 2. BILLING ROUTES
+// ============================================
+
+// routes/billing.js
+import { Elysia, t } from 'elysia'
+import { stripePlugin } from '../plugins/stripe'
+import { billingService } from '../services/billing'
+
+export const billingRoutes = new Elysia({ prefix: '/billing' })
+    .use(stripePlugin)
+
+    // Create checkout session
+    .post('/checkout', async ({ stripe, body, user }) => {
+        // Get or create Stripe customer
+        let customerId = user.stripeCustomerId
+        if (!customerId) {
+            const customer = await stripe.customers.create({
+                email: user.email,
+                name: user.name,
+                metadata: { userId: user.id }
+            })
+            customerId = customer.id
+            await billingService.linkStripeCustomer(user.id, customerId)
+        }
+
+        const session = await stripe.checkout.sessions.create({
+            mode: body.mode,
+            customer: customerId,
+            line_items: [{ price: body.priceId, quantity: 1 }],
+            success_url: `${process.env.APP_URL}/success?session_id={CHECKOUT_SESSION_ID}`,
+            cancel_url: `${process.env.APP_URL}/pricing`,
+            metadata: { userId: user.id }
+        })
+
+        return { url: session.url }
+    }, {
+        body: t.Object({
+            priceId: t.String(),
+            mode: t.Union([t.Literal('subscription'), t.Literal('payment')])
+        })
+    })
+
+    // Get subscription status
+    .get('/subscription', async ({ stripe, user }) => {
+        if (!user.stripeSubscriptionId) {
+            return { status: 'none', plan: null }
+        }
+
+        const subscription = await stripe.subscriptions.retrieve(user.stripeSubscriptionId)
+
+        return {
+            status: subscription.status,
+            plan: subscription.items.data[0].price.id,
+            currentPeriodEnd: subscription.current_period_end,
+            cancelAtPeriodEnd: subscription.cancel_at_period_end
+        }
+    })
+
+    // Customer portal
+    .post('/portal', async ({ stripe, user, set }) => {
+        if (!user.stripeCustomerId) {
+            set.status = 400
+            return { error: 'No billing account' }
+        }
+
+        const portal = await stripe.billingPortal.sessions.create({
+            customer: user.stripeCustomerId,
+            return_url: `${process.env.APP_URL}/account`
+        })
+
+        return { url: portal.url }
+    })
+
+    // Cancel subscription
+    .post('/subscription/cancel', async ({ stripe, user, set }) => {
+        if (!user.stripeSubscriptionId) {
+            set.status = 400
+            return { error: 'No active subscription' }
+        }
+
+        const subscription = await stripe.subscriptions.update(
+            user.stripeSubscriptionId,
+            { cancel_at_period_end: true }
+        )
+
+        return {
+            status: subscription.status,
+            cancelAt: subscription.cancel_at
+        }
+    })
+
+    // Resume subscription
+    .post('/subscription/resume', async ({ stripe, user, set }) => {
+        if (!user.stripeSubscriptionId) {
+            set.status = 400
+            return { error: 'No subscription to resume' }
+        }
+
+        const subscription = await stripe.subscriptions.update(
+            user.stripeSubscriptionId,
+            { cancel_at_period_end: false }
+        )
+
+        return { status: subscription.status }
+    })
+
+    // List invoices
+    .get('/invoices', async ({ stripe, user, query }) => {
+        if (!user.stripeCustomerId) {
+            return { data: [], hasMore: false }
+        }
+
+        const invoices = await stripe.invoices.list({
+            customer: user.stripeCustomerId,
+            limit: query.limit
+        })
+
+        return {
+            data: invoices.data.map(inv => ({
+                id: inv.id,
+                amount: inv.amount_paid,
+                status: inv.status,
+                date: inv.created,
+                pdfUrl: inv.invoice_pdf
+            })),
+            hasMore: invoices.has_more
+        }
+    }, {
+        query: t.Object({
+            limit: t.Optional(t.Numeric({ default: 10 }))
+        })
+    })
+
+// ============================================
+// 3. WEBHOOK ROUTES
+// ============================================
+
+// routes/webhook.js
+import { Elysia } from 'elysia'
+import Stripe from 'stripe'
+import { billingService } from '../services/billing'
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY)
+
+export const webhookRoutes = new Elysia()
+    .post('/webhook/stripe', async ({ request, set }) => {
+        const sig = request.headers.get('stripe-signature')
+        const body = await request.text()
+
+        let event
+
+        try {
+            event = stripe.webhooks.constructEvent(
+                body,
+                sig,
+                process.env.STRIPE_WEBHOOK_SECRET
+            )
+        } catch (err) {
+            console.error('Webhook signature failed:', err.message)
+            set.status = 400
+            return { error: 'Invalid signature' }
+        }
+
+        // Handle events
+        switch (event.type) {
+            case 'checkout.session.completed': {
+                const session = event.data.object
+                const userId = session.metadata.userId
+
+                await billingService.activateSubscription(userId, {
+                    subscriptionId: session.subscription,
+                    plan: 'pro', // Map from price ID
+                    periodEnd: new Date(session.expires_at * 1000)
+                })
+                break
+            }
+
+            case 'customer.subscription.updated': {
+                const subscription = event.data.object
+                // Handle plan changes, status updates
+                break
+            }
+
+            case 'customer.subscription.deleted': {
+                const subscription = event.data.object
+                await billingService.deactivateSubscription(subscription.id)
+                break
+            }
+
+            case 'invoice.paid': {
+                const invoice = event.data.object
+                // Record successful payment
+                break
+            }
+
+            case 'invoice.payment_failed': {
+                const invoice = event.data.object
+                // Handle failed payment - notify user
+                break
+            }
+        }
+
+        return { received: true }
+    })
+
+// ============================================
+// 4. BILLING SERVICE
+// ============================================
+
+// services/billing.js
+import { db } from '../database'
+import { users } from '../database/schema'
+import { eq } from 'drizzle-orm'
+
+export const billingService = {
+    async linkStripeCustomer(userId, stripeCustomerId) {
+        await db.update(users)
+            .set({ stripeCustomerId, updatedAt: new Date() })
+            .where(eq(users.id, userId))
+    },
+
+    async activateSubscription(userId, { subscriptionId, plan, periodEnd }) {
+        await db.update(users)
+            .set({
+                stripeSubscriptionId: subscriptionId,
+                plan,
+                subscriptionStatus: 'active',
+                currentPeriodEnd: periodEnd,
+                cancelAtPeriodEnd: false,
+                updatedAt: new Date()
+            })
+            .where(eq(users.id, userId))
+    },
+
+    async deactivateSubscription(subscriptionId) {
+        await db.update(users)
+            .set({
+                plan: 'free',
+                subscriptionStatus: 'canceled',
+                stripeSubscriptionId: null,
+                updatedAt: new Date()
+            })
+            .where(eq(users.stripeSubscriptionId, subscriptionId))
+    },
+
+    async canAccessFeature(userId, requiredPlan) {
+        const [user] = await db.select()
+            .from(users)
+            .where(eq(users.id, userId))
+            .limit(1)
+
+        if (!user) return false
+
+        const planHierarchy = { free: 0, starter: 1, pro: 2, enterprise: 3 }
+        return (planHierarchy[user.plan] || 0) >= (planHierarchy[requiredPlan] || 0)
+    }
+}
+
+// ============================================
+// 5. MIDDLEWARE
+// ============================================
+
+// middleware/require-subscription.js
+export const requireSubscription = async ({ user, set }) => {
+    if (!user?.stripeSubscriptionId) {
+        set.status = 403
+        return { error: 'Subscription required' }
+    }
+}
+
+export const requirePlan = (plan) => async ({ user, set }) => {
+    const canAccess = await billingService.canAccessFeature(user.id, plan)
+    if (!canAccess) {
+        set.status = 403
+        return { error: `Plan ${plan} required` }
+    }
+}
+
+// Usage:
+// app.guard({ beforeHandle: requireSubscription }, app => app.get('/premium', handler))
+// app.get('/enterprise-only', handler, { beforeHandle: requirePlan('enterprise') })

package/.agent/skills/riligar-dev-stripe/references/stripe-database.md

@@ -0,0 +1,369 @@
+# Stripe Database Patterns (Drizzle)
+
+Database schemas and queries for Stripe billing with SQLite and Drizzle ORM.
+
+## Schema
+
+### Users Table (with Stripe fields)
+
+```javascript
+// database/schema.js
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+
+export const users = sqliteTable('users', {
+    id: text('id').primaryKey(),
+    email: text('email').notNull().unique(),
+    name: text('name'),
+
+    // Stripe fields
+    stripeCustomerId: text('stripe_customer_id').unique(),
+    stripeSubscriptionId: text('stripe_subscription_id').unique(),
+    plan: text('plan').default('free'),  // free, starter, pro, enterprise
+    subscriptionStatus: text('subscription_status'),  // active, past_due, canceled, trialing
+    currentPeriodEnd: integer('current_period_end', { mode: 'timestamp' }),
+    cancelAtPeriodEnd: integer('cancel_at_period_end', { mode: 'boolean' }).default(false),
+
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+    updatedAt: integer('updated_at', { mode: 'timestamp' })
+})
+```
+
+### Invoices Table (optional)
+
+```javascript
+export const invoices = sqliteTable('invoices', {
+    id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text('user_id').references(() => users.id).notNull(),
+    stripeInvoiceId: text('stripe_invoice_id').unique().notNull(),
+    amount: integer('amount').notNull(),  // in cents
+    status: text('status').notNull(),  // paid, open, void
+    url: text('url'),  // hosted invoice URL
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date())
+})
+```
+
+### Webhook Events Table (for idempotency)
+
+```javascript
+export const webhookEvents = sqliteTable('webhook_events', {
+    id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+    stripeEventId: text('stripe_event_id').unique().notNull(),
+    type: text('type').notNull(),
+    processedAt: integer('processed_at', { mode: 'timestamp' }).notNull()
+})
+```
+
+### Products Table (for local price cache)
+
+```javascript
+export const products = sqliteTable('products', {
+    id: text('id').primaryKey(),
+    stripePriceId: text('stripe_price_id').unique().notNull(),
+    name: text('name').notNull(),
+    description: text('description'),
+    amount: integer('amount').notNull(),  // in cents
+    interval: text('interval'),  // month, year, null for one-time
+    active: integer('active', { mode: 'boolean' }).default(true),
+    features: text('features', { mode: 'json' })  // ["feature1", "feature2"]
+})
+```
+
+## Queries
+
+### Get User with Subscription
+
+```javascript
+import { db } from '../database'
+import { users } from '../database/schema'
+import { eq } from 'drizzle-orm'
+
+export async function getUserWithSubscription(userId) {
+    const [user] = await db.select()
+        .from(users)
+        .where(eq(users.id, userId))
+        .limit(1)
+
+    return user
+}
+```
+
+### Check Active Subscription
+
+```javascript
+export async function hasActiveSubscription(userId) {
+    const [user] = await db.select({
+        status: users.subscriptionStatus,
+        periodEnd: users.currentPeriodEnd
+    })
+        .from(users)
+        .where(eq(users.id, userId))
+        .limit(1)
+
+    if (!user) return false
+
+    const activeStatuses = ['active', 'trialing']
+    return activeStatuses.includes(user.status)
+}
+```
+
+### Get User by Stripe Customer
+
+```javascript
+export async function getUserByStripeCustomer(stripeCustomerId) {
+    const [user] = await db.select()
+        .from(users)
+        .where(eq(users.stripeCustomerId, stripeCustomerId))
+        .limit(1)
+
+    return user
+}
+```
+
+### Get User by Subscription
+
+```javascript
+export async function getUserBySubscription(stripeSubscriptionId) {
+    const [user] = await db.select()
+        .from(users)
+        .where(eq(users.stripeSubscriptionId, stripeSubscriptionId))
+        .limit(1)
+
+    return user
+}
+```
+
+### Update Subscription
+
+```javascript
+export async function updateUserSubscription(userId, data) {
+    await db.update(users)
+        .set({
+            stripeCustomerId: data.customerId,
+            stripeSubscriptionId: data.subscriptionId,
+            plan: data.plan,
+            subscriptionStatus: data.status,
+            currentPeriodEnd: data.periodEnd,
+            cancelAtPeriodEnd: data.cancelAtPeriodEnd,
+            updatedAt: new Date()
+        })
+        .where(eq(users.id, userId))
+}
+```
+
+### Cancel Subscription (in DB)
+
+```javascript
+export async function cancelSubscriptionInDb(subscriptionId) {
+    await db.update(users)
+        .set({
+            plan: 'free',
+            subscriptionStatus: 'canceled',
+            stripeSubscriptionId: null,
+            updatedAt: new Date()
+        })
+        .where(eq(users.stripeSubscriptionId, subscriptionId))
+}
+```
+
+### Get User Invoices
+
+```javascript
+import { desc } from 'drizzle-orm'
+
+export async function getUserInvoices(userId, limit = 10) {
+    return db.select()
+        .from(invoices)
+        .where(eq(invoices.userId, userId))
+        .orderBy(desc(invoices.createdAt))
+        .limit(limit)
+}
+```
+
+### Check Webhook Processed
+
+```javascript
+export async function isWebhookProcessed(eventId) {
+    const [event] = await db.select()
+        .from(webhookEvents)
+        .where(eq(webhookEvents.stripeEventId, eventId))
+        .limit(1)
+
+    return !!event
+}
+
+export async function markWebhookProcessed(eventId, type) {
+    await db.insert(webhookEvents).values({
+        stripeEventId: eventId,
+        type,
+        processedAt: new Date()
+    })
+}
+```
+
+## Migrations
+
+### Initial Migration
+
+```javascript
+// database/migrations/0001_add_stripe_fields.js
+import { sql } from 'drizzle-orm'
+
+export async function up(db) {
+    await db.run(sql`
+        ALTER TABLE users ADD COLUMN stripe_customer_id TEXT UNIQUE;
+        ALTER TABLE users ADD COLUMN stripe_subscription_id TEXT UNIQUE;
+        ALTER TABLE users ADD COLUMN plan TEXT DEFAULT 'free';
+        ALTER TABLE users ADD COLUMN subscription_status TEXT;
+        ALTER TABLE users ADD COLUMN current_period_end INTEGER;
+        ALTER TABLE users ADD COLUMN cancel_at_period_end INTEGER DEFAULT 0;
+    `)
+}
+
+export async function down(db) {
+    // SQLite doesn't support DROP COLUMN easily
+    // Would need to recreate table
+}
+```
+
+### Create Invoices Table
+
+```javascript
+// database/migrations/0002_create_invoices.js
+import { sql } from 'drizzle-orm'
+
+export async function up(db) {
+    await db.run(sql`
+        CREATE TABLE invoices (
+            id TEXT PRIMARY KEY,
+            user_id TEXT NOT NULL REFERENCES users(id),
+            stripe_invoice_id TEXT UNIQUE NOT NULL,
+            amount INTEGER NOT NULL,
+            status TEXT NOT NULL,
+            url TEXT,
+            created_at INTEGER NOT NULL
+        )
+    `)
+}
+
+export async function down(db) {
+    await db.run(sql`DROP TABLE invoices`)
+}
+```
+
+## Helper Service
+
+```javascript
+// services/billing.js
+import { db } from '../database'
+import { users, invoices } from '../database/schema'
+import { eq, and } from 'drizzle-orm'
+
+export const billingService = {
+    // Check if user can access feature
+    async canAccessFeature(userId, requiredPlan) {
+        const user = await this.getUser(userId)
+
+        if (!user) return false
+
+        const planHierarchy = { free: 0, starter: 1, pro: 2, enterprise: 3 }
+        const userLevel = planHierarchy[user.plan] || 0
+        const requiredLevel = planHierarchy[requiredPlan] || 0
+
+        return userLevel >= requiredLevel
+    },
+
+    // Get user
+    async getUser(userId) {
+        const [user] = await db.select()
+            .from(users)
+            .where(eq(users.id, userId))
+            .limit(1)
+        return user
+    },
+
+    // Link Stripe customer
+    async linkStripeCustomer(userId, stripeCustomerId) {
+        await db.update(users)
+            .set({ stripeCustomerId, updatedAt: new Date() })
+            .where(eq(users.id, userId))
+    },
+
+    // Activate subscription
+    async activateSubscription(userId, { subscriptionId, plan, periodEnd }) {
+        await db.update(users)
+            .set({
+                stripeSubscriptionId: subscriptionId,
+                plan,
+                subscriptionStatus: 'active',
+                currentPeriodEnd: periodEnd,
+                cancelAtPeriodEnd: false,
+                updatedAt: new Date()
+            })
+            .where(eq(users.id, userId))
+    },
+
+    // Deactivate subscription
+    async deactivateSubscription(subscriptionId) {
+        await db.update(users)
+            .set({
+                plan: 'free',
+                subscriptionStatus: 'canceled',
+                stripeSubscriptionId: null,
+                updatedAt: new Date()
+            })
+            .where(eq(users.stripeSubscriptionId, subscriptionId))
+    },
+
+    // Record invoice
+    async recordInvoice(userId, stripeInvoice) {
+        await db.insert(invoices).values({
+            userId,
+            stripeInvoiceId: stripeInvoice.id,
+            amount: stripeInvoice.amount_paid,
+            status: stripeInvoice.status,
+            url: stripeInvoice.hosted_invoice_url
+        })
+    }
+}
+```
+
+## Plan Feature Checks
+
+```javascript
+// services/features.js
+const planFeatures = {
+    free: {
+        projects: 1,
+        storage: 100 * 1024 * 1024,  // 100MB
+        apiCalls: 100,
+        support: 'community'
+    },
+    starter: {
+        projects: 5,
+        storage: 1 * 1024 * 1024 * 1024,  // 1GB
+        apiCalls: 1000,
+        support: 'email'
+    },
+    pro: {
+        projects: Infinity,
+        storage: 10 * 1024 * 1024 * 1024,  // 10GB
+        apiCalls: 10000,
+        support: 'priority'
+    },
+    enterprise: {
+        projects: Infinity,
+        storage: Infinity,
+        apiCalls: Infinity,
+        support: 'dedicated'
+    }
+}
+
+export function getFeatureLimits(plan) {
+    return planFeatures[plan] || planFeatures.free
+}
+
+export function canCreateProject(plan, currentCount) {
+    const limits = getFeatureLimits(plan)
+    return currentCount < limits.projects
+}
+```